/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/ImageIO.cpp

Aller à la documentation de ce fichier.

/******************************************************************************
 *       __    _    _   _       _       _   _____                             *
 *       | \  / |  | | | |     | |     | |  | ___|                            *
 *       |  \/  |  | | | |     | |     | |  | |_                              *
 *       |      |  | | | |     | |     | |  |  _|                             *
 *       | |\/| |  | | | |__   | |__   | |  | |__                             *
 *       |_|  |_|  |_| |____|  |____|  |_|  |____|                            *
 * __________________________________________________________________________ *
 *                 Multifunctional Library For Image Processing               *
 *                                                                            *
 *                                                                            *
 *                                                                            *
 *      (c) Copyright 2007 by Humbert Florent                                 *
 *                                                                            *
 *      This program is free software; you can redistribute it and/or modify  *
 *      it under the terms of the GNU General Public License as published by  *
 *      the Free Software Foundation; only version 2 of the License.          *
 *                                                                            *
 *      This program is distributed in the hope that it will be useful,       *
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *      GNU General Public License for more details.                          *
 *                                                                            *
 *      You should have received a copy of the GNU General Public License     *
 *      along with this program; if not, write to the Free Software           *
 *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA             *
 *      02111-1307, USA.                                                      *
 ******************************************************************************/

#ifndef _MILLIE_WITHOUT_SDL_
#include <SDL/SDL.h>
#endif

#ifdef _MILLIE_WITH_SDLIMAGE_
#include <SDL/SDL_image.h>
#endif

#include <iostream>

#include "ImageIO.hpp"


#define IMAGEIO_BLUE_COLOR 0
#define IMAGEIO_RED_COLOR 1
#define IMAGEIO_GREEN_COLOR 2

using namespace Millie;

#ifndef _MILLIE_WITHOUT_SDL_

static Uint32 SDL_LireCouleurAux(const SDL_Surface* surface, int x, int y)
{
  int bpp = surface->format->BytesPerPixel;

  Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

  switch(bpp)
  {
      case 1:
      return *p;
      case 2:
      return *(Uint16 *)p;
      case 3:
      if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
        return p[0] << 16 | p[1] << 8 | p[2];
      else
        return p[0] | p[1] << 8 | p[2] << 16;
      case 4:
      return *(Uint32 *)p;
      default:
      return 0;
  }
}


static void SDL_LireCouleur(const SDL_Surface * surface, int x, int y, Uint8 * r, Uint8 * g, Uint8 * b)
{
  if (x<0 | y<0 | x>=(surface->w) | y>=(surface->h))
  {
    *r = *g = *b = 0;
  }

  SDL_GetRGB(SDL_LireCouleurAux(surface, x, y), surface->format,
             (Uint8*)   r, (Uint8*) g, (Uint8*) b);

}

void SDL_EcrireCouleurAux(SDL_Surface* surface, int x, int y, Uint32 pixel)
{
  int bpp = surface->format->BytesPerPixel;
  Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;


  switch(bpp)
  {
      case 1:
      *p = pixel;
      break;

      case 2:
      *(Uint16 *)p = pixel;
      break;

      case 3:
      if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
      {
        p[0] = (pixel >> 16) & 0xff;
        p[1] = (pixel >> 8) & 0xff;
        p[2] = pixel & 0xff;
      }
      else
      {
        p[0] = pixel & 0xff;
        p[1] = (pixel >> 8) & 0xff;
        p[2] = (pixel >> 16) & 0xff;
      }
      break;

      case 4:
      *(Uint32 *)p = pixel;
      break;
  }
}

void SDL_EcrireCouleur(SDL_Surface* surface, int x, int y, int r, int g, int b)
{
  SDL_EcrireCouleurAux(surface, x, y,
                       SDL_MapRGB(surface->format, r, g, b));
}

static inline int floatTo0_255(float f)
{
  return (int) (std::max(0.0f, std::min(255.0f, f)));
}

SDL_Surface*  imageToSDL_Surface32(const ImageRGB & imRGB)
{

  int hauteur = imRGB.getHeight();
  int largeur = imRGB.getWidth();


  SDL_Surface* destination = SDL_CreateRGBSurface(SDL_HWSURFACE, largeur, hauteur,
                             32,
                             0xff0000,
                             0x00ff00,
                             0x0000ff,
                             0x000000);
  if(destination==NULL)
  {
    std::cerr<<"ImageIO::saveBMP Erreur Memoire"<<std::endl;
    throw std::bad_alloc();
  }



  for(int j = 0; j<hauteur;j++)
  {
    //std::cerr<<"Begin colonne"<<std::endl;
    for(int i = 0; i<largeur; i++)
    {
      SDL_EcrireCouleur(destination, i, j,
                        floatTo0_255(imRGB.getRedPixel(i,j)),
                        floatTo0_255(imRGB.getGreenPixel(i,j)),
                        floatTo0_255(imRGB.getBluePixel(i,j)));
    }
  }

  return destination;
}

SDL_Surface*  imagegrayToSDL_Surface32(const ImageGray & imGray, int color, bool all)
{

  int hauteur = imGray.getHeight();
  int largeur = imGray.getWidth();


  SDL_Surface* destination = SDL_CreateRGBSurface(SDL_HWSURFACE, largeur, hauteur,
                             32,
                             0xff0000,
                             0x00ff00,
                             0x0000ff,
                             0x000000);
  if(destination==NULL)
  {
    std::cerr<<"ImageIO::saveBMP Erreur Memoire"<<std::endl;
    throw std::bad_alloc();
  }

  for(int j = 0; j<hauteur;j++)
  {
    //std::cerr<<"Begin colonne"<<std::endl;
    for(int i = 0; i<largeur; i++)
    {
      if(all)
      {
        SDL_EcrireCouleur(destination, i, j,
                          floatTo0_255(imGray.getPixel(i,j)),
                          floatTo0_255(imGray.getPixel(i,j)),
                          floatTo0_255(imGray.getPixel(i,j)));
      }
      else
      {
        if(color == IMAGEIO_BLUE_COLOR)
          SDL_EcrireCouleur(destination, i, j,
                            0,
                            0,
                            floatTo0_255(imGray.getPixel(i,j)));
        if(color == IMAGEIO_RED_COLOR)
          SDL_EcrireCouleur(destination, i, j,
                            floatTo0_255(imGray.getPixel(i,j)),
                            0,
                            0);
        if(color == IMAGEIO_BLUE_COLOR)
          SDL_EcrireCouleur(destination, i, j,
                            floatTo0_255(imGray.getPixel(i,j)),
                            0,
                            0);

      }
    }
  }

  return destination;
}

void sdl_SurfaceToImageRGB(ImageRGB & imRGB, const SDL_Surface*  origine)
{
  if(origine==NULL)
    throw NullPointer("sdl_SurfaceToImageRGB");

  int hauteur = origine->h;
  int largeur = origine->w;

  imRGB.resize(largeur, hauteur);


  Uint8 r;
  Uint8 g;
  Uint8 b;

  for(int j = 0; j<hauteur;j++)
  {
    for(int i = 0; i<largeur; i++)
    {
      SDL_LireCouleur(origine, i, j, &r, &g, &b);
      imRGB.setRedPixel(i,j, (float) r);
      imRGB.setGreenPixel(i,j, (float) g);
      imRGB.setBluePixel(i,j, (float) b);
    }
  }
}

void sdl_SurfaceToImageGray(ImageGray & imGray, const SDL_Surface*  origine, int color)
{
  if(origine==NULL)
    throw NullPointer("sdl_SurfaceToImageGray");

  if(color<0 || color>2)
    throw OutOfRange("sdl_SurfaceToImageGray : color range");

  int hauteur = origine->h;
  int largeur = origine->w;

  imGray.resize(largeur, hauteur);

  Uint8 r;
  Uint8 g;
  Uint8 b;

  for(int j = 0; j<hauteur;j++)
  {
    for(int i = 0; i<largeur; i++)
    {
      SDL_LireCouleur(origine, i, j, &r, &g, &b);

      if(color == IMAGEIO_RED_COLOR)
        imGray.setPixel(i,j, (float) r);

      if(color == IMAGEIO_GREEN_COLOR)
        imGray.setPixel(i,j, (float) g);

      if(color == IMAGEIO_BLUE_COLOR)
        imGray.setPixel(i,j, (float) b);

    }
  }

}

#endif


void ImageIO::loadJPGComponent(ImageGray & im, const char * chemin, int color)
{
#ifdef _MILLIE_WITH_SDLIMAGE_
  if(chemin ==NULL)
    throw NullPointer("ImageIO::saveBMP");

  SDL_RWops *rwop = NULL;
  rwop=SDL_RWFromFile(chemin, "rb");
  if(rwop==NULL)
   throw IOException("LoadJPG");

  SDL_Surface* imageSDL = IMG_LoadJPG_RW(rwop);

  if(imageSDL==NULL)
  {
    std::cerr<<"Load JPG : Probleme de lecture fichier"<<std::endl;
    SDL_FreeRW(rwop);
    throw IOException("LoadJPG");
  }


  sdl_SurfaceToImageGray(im, imageSDL, color);
  SDL_FreeRW(rwop);
  SDL_FreeSurface(imageSDL);
#else
 throw Exception("loadJPGComponent : Not yet implemented without SDL_Image");
#endif
}

void ImageIO::loadJPGRedComponent(ImageGray & im, const char* chemin)
{
  return ImageIO::loadJPGComponent(im, chemin, IMAGEIO_RED_COLOR);
}

void ImageIO::loadJPGGreenComponent(ImageGray & im, const char* chemin)
{
  return ImageIO::loadJPGComponent(im, chemin, IMAGEIO_GREEN_COLOR);
}

void ImageIO::loadJPGBlueComponent(ImageGray & im, const char* chemin)
{
  return ImageIO::loadJPGComponent(im, chemin, IMAGEIO_BLUE_COLOR);
}

void ImageIO::loadJPG(ImageRGB & imRGB, const char * chemin)
{
#ifdef _MILLIE_WITH_SDLIMAGE_
  if(chemin ==NULL)
    throw NullPointer("ImageIO::loadBMP");

  SDL_RWops *rwop = NULL;
  rwop=SDL_RWFromFile(chemin, "rb");
  if(rwop==NULL)
   throw IOException("LoadJPG");

  SDL_Surface* imageSDL = IMG_LoadJPG_RW(rwop);

  if(imageSDL==NULL)
  {
    std::cerr<<"Load JPG : Probleme de lecture fichier"<<std::endl;
    throw IOException("LoadJPG");
  }

  sdl_SurfaceToImageRGB(imRGB, imageSDL);
  SDL_FreeRW(rwop);
  SDL_FreeSurface(imageSDL);
#else
 throw Exception("loadJPG : Not yet implemented without SDL_Image");
#endif
}

void ImageIO::loadBMPComponent(ImageGray & im, const char* chemin, int color)
{
#ifndef _MILLIE_WITHOUT_SDL_
if(chemin ==NULL)
    throw NullPointer("ImageIO::saveBMP");

  SDL_Surface* imageSDL =SDL_LoadBMP(chemin);

  if(imageSDL==NULL)
  {
    std::cerr<<"Load BMP : Probleme de lecture fichier"<<std::endl;
    throw IOException("LoadBMP");
  }


  sdl_SurfaceToImageGray(im, imageSDL, color);
  SDL_FreeSurface(imageSDL);
#else
 throw Exception("loadBMP: Not yet implemented without SDL");
#endif
}

void ImageIO::loadBMPGreenComponent(ImageGray & im, const char* chemin)
{
  return ImageIO::loadBMPComponent(im, chemin, IMAGEIO_GREEN_COLOR);
}

void ImageIO::loadBMPBlueComponent(ImageGray & im, const char* chemin)
{
  return ImageIO::loadBMPComponent(im, chemin, IMAGEIO_BLUE_COLOR);
}

void ImageIO::loadBMPRedComponent(ImageGray & im, const char* chemin)
{
  return ImageIO::loadBMPComponent(im, chemin, IMAGEIO_RED_COLOR);
}

void       ImageIO::saveBMP(ImageGray & imGray, const char * chemin)
{
#ifndef _MILLIE_WITHOUT_SDL_
  if(chemin ==NULL)
    throw NullPointer("ImageIO::saveBMP");

  SDL_Surface* destination = imagegrayToSDL_Surface32(imGray,0 , true);

  if(SDL_SaveBMP(destination, chemin) == -1)
  {
    std::cerr<<"saveBMP : Erreur enregistrement"<<std::endl;
    throw IOException("saveBMP");
  }

  SDL_FreeSurface(destination);

  return;
#else
 throw Exception("saveBMP : Not yet implemented without SDL");
#endif
}



void ImageIO::loadBMP(ImageRGB & imRGB, const char * chemin)
{
 #ifndef _MILLIE_WITHOUT_SDL_
  if(chemin ==NULL)
    throw NullPointer("ImageIO::loadBMP");

  SDL_Surface* imageSDL =SDL_LoadBMP(chemin);

  if(imageSDL==NULL)
  {
    std::cerr<<"Load BMP : Probleme de lecture fichier"<<std::endl;
    throw IOException("LoadBMP");
  }

  sdl_SurfaceToImageRGB(imRGB, imageSDL);
  SDL_FreeSurface(imageSDL);
  return;
#else
 throw Exception("loadBMP : Not yet implemented without SDL");
#endif
}



void ImageIO::saveBMP(ImageRGB & imRGB, const char * chemin)
{
#ifndef _MILLIE_WITHOUT_SDL_
  if(chemin ==NULL)
    throw NullPointer("ImageIO::saveBMP");

  SDL_Surface* destination = imageToSDL_Surface32(imRGB);

  if(SDL_SaveBMP(destination, chemin) == -1)
  {
    std::cerr<<"saveBMP : Erreur enregistrement"<<std::endl;
    throw IOException("saveBMP");
  }

  SDL_FreeSurface(destination);

  return;
#else
 throw Exception("loadBMP : Not yet implemented without SDL");
#endif
}

---