---

image_file.h

Go to the documentation of this file.

#ifndef __IMAGE_FILE__
#define __IMAGE_FILE__

#include <algorithm>
#include <functional>
#include <stdexcept>

#include <qcolor.h> // Must be linked with QT with correct include paths.
#include <qimage.h>
#include <qstring.h>

#include "msg_stream.h"
#include "tools.h"


namespace Image_file{
  
  template<typename Image_container>
  void load(const char* file_name,
            Image_container* const target);
  
  template<typename Image_container>
  void save(const char* file_name,
            const Image_container& source);


  template<typename Source_container,typename Target_container>
  inline void convert(const Source_container& source,
                      Target_container* const target);

  inline std::string guess_format(const std::string filename);
  
  
  template<typename Image_container>
  inline void reverse_x(Image_container* target);


  template<typename Image_container>
  inline void reverse_y(Image_container* target);


    
/*
  
  #############################################
  #############################################
  #############################################
  ######                                 ######
  ######   I M P L E M E N T A T I O N   ######
  ######                                 ######
  #############################################
  #############################################
  #############################################
  
*/


  namespace Image_container_traits{}


  
  template<typename Image_container>
  void load(const char*      file_name,
            Image_container* const target){
    
    QImage qt_image = QImage(QString(file_name));

    if (qt_image.isNull()){
      
      Message::warning<<"failure while loading \""<<file_name<<"\""
                      <<Message::done;
      
      throw std::invalid_argument("error during image loading");
    }
    
    // A few typedefs to ease the following code.
    typedef unsigned int size_type;

    const size_type width  = qt_image.width();
    const size_type height = qt_image.height();    

    Image_container_traits::set_size(target,width,height);

    for(size_type x=0;x<width;x++){
      for(size_type y=0;y<height;y++){
        
        QRgb rgb       = qt_image.pixel(x,height-1-y);
        
        Image_container_traits::
          set_value(target,x,y,
                    static_cast<double>(qRed(rgb))   / 255.0,
                    static_cast<double>(qGreen(rgb)) / 255.0,
                    static_cast<double>(qBlue(rgb))  / 255.0); 
      }
    }
  }


  template<typename Image_container>
  void save(const char* file_name,
            const Image_container& source){
   
    typedef unsigned int size_type;

    const size_type width  = Image_container_traits::get_width(source);
    const size_type height = Image_container_traits::get_height(source);    

    // create a QImage
    QImage image(width,height,32);

    for(size_type x=0;x<width;x++){
      for(size_type y=0;y<height;y++){
        double r,g,b;
        
        Image_container_traits::get_value(source,x,height-1-y,&r,&g,&b);
        
        image.setPixel(x,y,qRgb(static_cast<char>(r*255),
                                static_cast<char>(g*255),
                                static_cast<char>(b*255)));
      }
    }

    // Try to guess the file format.
    const std::string format = guess_format(file_name);

    if (format == std::string()) {
      // If format not found, use the default and save however.
      char* escape_format = strdup(QImage::outputFormats().first());

      Message::warning<<"output format not recognized. "
                      <<"image written ("<<file_name<<") in format: "
                      <<escape_format<<Message::done;

      image.save(QString(file_name),escape_format);

      free(escape_format);

    }
    else{ // If format is guessed.
      image.save(QString(file_name),format.c_str());
    }
  }



  
  template<typename Source_container,typename Target_container>
  void convert(const Source_container& source,
               Target_container* const target){

    typedef unsigned int size_type;

    const size_type width  = Image_container_traits::get_width(source);
    const size_type height = Image_container_traits::get_height(source);    

    Image_container_traits::set_size(target,width,height);

    for(size_type x=0;x<width;x++){
      for(size_type y=0;y<height;y++){
        
        double r,g,b;
        
        Image_container_traits::get_value(source,x,y,&r,&g,&b);
        Image_container_traits::set_value(target,x,y,r,g,b);
      }
    }

  }


  
  std::string guess_format(const std::string filename){

    using namespace std;
    
    // Conversion into a STL data stricture.
    list<string> valid_answers;
    QStrList qlist = QImage::outputFormats();
    for(char* c=qlist.first();c!=NULL;c=qlist.next()){
      valid_answers.push_back(c);
    }
    
    // Add some more if needed.
    const bool has_JPG =
      (find(valid_answers.begin(),valid_answers.end(),"JPG")
       !=valid_answers.end());
    
    const bool has_JPEG =
      (find(valid_answers.begin(),valid_answers.end(),"JPEG")
       !=valid_answers.end());
    
    if (has_JPG&&(!has_JPEG)){
      valid_answers.push_back("JPEG");
    }
    
    if (has_JPEG&&(!has_JPG)){
      valid_answers.push_back("JPG");
    }

    // Look for the extensions.
    const string query = Tools::to_upper_case(filename);
    const unsigned int query_length = query.length();
    for(list<string>::iterator f=valid_answers.begin();
        f!=valid_answers.end();f++){

      if (query.find(*f)<query_length){
        if ((*f=="JPG")&&(!has_JPG)){
          return "JPEG";
        }
        if ((*f=="JPEG")&&(!has_JPEG)){
          return "JPG";
        }
        return *f;
      }
    }
    
    return string();

  }


  template<typename Image_container>
  void reverse_x(Image_container* target){
    
    typedef unsigned int size_type;

    const size_type width  = Image_container_traits::get_width(*target);
    const size_type height = Image_container_traits::get_height(*target);    

    for(size_type x=0;x<(width+1)/2;x++){
      for(size_type y=0;y<height;y++){
        double r1,g1,b1,r2,g2,b2;
        Image_container_traits::get_value(*target,width-1-x,y,&r1,&g1,&b1);
        Image_container_traits::get_value(*target,x,y,&r2,&g2,&b2);
        Image_container_traits::set_value(target,x,y,r1,g1,b1);
        Image_container_traits::set_value(target,width-1-x,y,r2,g2,b2);
      }
    }
  }

  
  template<typename Image_container>
  void reverse_y(Image_container* target){
    
    typedef unsigned int size_type;

    const size_type width  = Image_container_traits::get_width(*target);
    const size_type height = Image_container_traits::get_height(*target);    

    for(size_type x=0;x<width;x++){
      for(size_type y=0;y<(height+1)/2;y++){
        double r1,g1,b1,r2,g2,b2;
        Image_container_traits::get_value(*target,x,height-1-y,&r1,&g1,&b1);
        Image_container_traits::get_value(*target,x,y,&r2,&g2,&b2);
        Image_container_traits::set_value(target,x,y,r1,g1,b1);
        Image_container_traits::set_value(target,x,height-1-y,r2,g2,b2);
      }
    }
  }

  
/*

  ##########################
  # image_container_traits #
  ##########################

 */

  //set_value() adapted to the used data structure. See the example on
  //the main page.
  namespace Image_container_traits{    
  } //END OF namespace Image_container_traits
 
} //END OF namespace Image_file

#endif

---