[c#] Inverser (retourner) une image jPG

extern "C"{
  #include <stdlib.h>
}
#include <cassert>
#include <iostream>

class image_t{
  protected:
  typdef unsigned int pixel_t;
  pixel_t **data; // les valeurs des pixels
  std::size_t largeur; // la largeur de l'image en nb de pixel
  std::size_t hauteur; // la hauteur de l'image en nb de pixel

  public:

  // Constructeur par défaut
  image(){}

  // Constructeur
  image(std::size_t hauteur0,std::size_t largeur0):
    hauteur(hauteur0),largeur(largeur0)
  {
    data = (pixel_t **)malloc(hauteur*sizeof(pixel_t *));
    for(std::size_t i=0;i<hauteur;++i)
      data[i] = (pixel_t *)calloc(hauteur,sizeof(pixel_t));
  }  

  // Destructeur
  ~image(){
    for(std::size_t i=0;i<hauteur;++i) free(data[i]);
    free(data);
  }

  // Accesseur hauteur
  inline std::size_t get_hauteur() const{
    return hauteur;
  }

  // Accesseur largeur
  inline std::size_t get_largeur() const{
    return largeur;
  }

  // Accesseur pixel
  inline pixel_t get_pixel(std::size_t ligne,std::size_t colonne) const{
    assert(ligne<hauteur);
    assert(colonne<largeur);
    return pixel[i][j];
  }

  // Accesseur pixel
  inline void set_pixel(std::size_t ligne,std::size_t colonne,const pixel_t & p){
    assert(ligne<hauteur);
    assert(colonne<largeur);
    pixel[i][j] = p;
  }

  // Renversement horizontal
  inline image_t retournement_horizontal() const{
    image_t img(hauteur,largeur);
    for(std::size_t i=0;i<hauteur;++i){
      for(std::size_t j=0;j<largeur;++j){
        img.set_pixel(i,largeur-j,this->get_pixel(i,j));
      }
    }
    return img;
  }

  // Renversement vertical
  inline image_t retournement_horizontal() const{
    image_t img(hauteur,largeur);
    for(std::size_t i=0;i<hauteur;++i){
      for(std::size_t j=0;j<largeur;++j){
        img.set_pixel(hauteur-i,j,this->get_pixel(i,j));
      }
    }
    return img;
  }

  // Rotation +90°
  inline image_t retournement_horizontal() const{
    image_t img(largeur,hauteur);
    for(std::size_t i=0;i<hauteur;++i){
      for(std::size_t j=0;j<largeur;++j){
        img.set_pixel(j,i,this->get_pixel(i,j));
      }
    }
    return img;
  }
};

// Operateur d'affichage
template <typename Tstream>
Tstream operator << (Tstream & out,const image_t & img){
  std::size_t largeur = img.get_largeur();
  std::size_t hauteur = img.get_hauteur();
  for(std::size_t i=0;i<hauteur;++i){
    for(std::size_t j=0;j<largeur;++j){
      out << img.get_pixel(i,j);
    }
    out << std::endl;
  }
  return out;  
}

int main(){
  image_t img(5,4);
  img.set_pixel(0,0,1);
  img.set_pixel(1,2,5);
  img.set_pixel(2,1,4);
  img.set_pixel(3,3,6);
  std::cout << img << std::endl;
  image_t img2 = img.retournement_horizontal();
  std::cout << img2 << std::endl;
  getchar(); // pour les windowsiens
  return 0;
}