/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/img

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_img
#define inlib_img

#ifdef INLIB_MEM
#include "mem"
#endif

#include <string> //memcpy
#include <cstring> //memcpy
#include "mnmx"
#include "math" //for power<T>

#include <vector> //concatenate

namespace inlib {

template <class T>
class img {
  static const std::string& s_class() {
    static const std::string s_v("inlib::img");
    return s_v;
  }
public:
  img(unsigned int a_n)
  :m_w(0),m_h(0),m_n(a_n)
  ,m_buffer(0)
  ,m_owner(false)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  img(unsigned int a_w,unsigned int a_h,unsigned int a_n,
             T* a_buffer,bool a_owner)
  :m_w(a_w),m_h(a_h),m_n(a_n)
  ,m_buffer(a_buffer)
  ,m_owner(a_owner)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  virtual ~img() {
    if(m_owner) delete [] m_buffer;
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
public:
  img(const img& a_from)
  :m_w(a_from.m_w),m_h(a_from.m_h),m_n(a_from.m_n)
  ,m_buffer(0)
  ,m_owner(a_from.m_owner)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    if(m_owner) {
      unsigned int sz = m_w*m_h*m_n;
      if(!sz) return;
      m_buffer = new T[sz];
      if(!m_buffer) {
        m_w = 0;m_h = 0;m_owner = false;
        return; //throw
      }
      ::memcpy(m_buffer,a_from.m_buffer,sz*sizeof(T));
    } else {
      m_buffer = a_from.m_buffer;
    }
  }
  img& operator=(const img& a_from){
    if(m_owner) delete [] m_buffer;
    m_buffer = 0;
    m_w = a_from.m_w;
    m_h = a_from.m_h;
    m_n = a_from.m_n;
    m_owner = a_from.m_owner;
    if(m_owner) {
      unsigned int sz = m_w*m_h*m_n;
      if(!sz) return *this;
      m_buffer = new T[sz];
      if(!m_buffer) {
        m_w = 0;m_h = 0;m_owner = false;
        return *this;  //throw
      }
      ::memcpy(m_buffer,a_from.m_buffer,sz*sizeof(T));
    } else {
      m_buffer = a_from.m_buffer;
    }
    return *this;
  }
public:
  bool operator==(const img& a_from) const {return equal(a_from);}
  bool operator!=(const img& a_from) const {return !operator==(a_from);}
public:
  void transfer(img& a_from) {
    if(m_owner) delete [] m_buffer;
    m_w = a_from.m_w;
    m_h = a_from.m_h;
    //don't touch m_n
    m_buffer = a_from.m_buffer;
    m_owner = a_from.m_owner;
    // empty a_from :
    a_from.m_w = 0;
    a_from.m_h = 0;
    a_from.m_buffer = 0;
    a_from.m_owner = false;
  }

  void clear() {
    if(m_owner) delete [] m_buffer;
    m_w = 0;
    m_h = 0;
    m_buffer = 0;
    m_owner = false;
  }
  void set(unsigned int a_w,unsigned int a_h,
                  T* a_buffer,bool a_owner) {
    if(m_owner) delete [] m_buffer;
    m_w = a_w;
    m_h = a_h;
    //don't touch m_n
    m_buffer = a_buffer;
    m_owner = a_owner;
  }
  bool copy(const img& a_from){
    if(m_owner) delete [] m_buffer;
    m_buffer = 0;
    m_w = a_from.m_w;
    m_h = a_from.m_h;
    m_n = a_from.m_n;
    unsigned int sz = m_w*m_h*m_n;
    if(!sz) {
      m_w = 0;m_h = 0;m_owner = false;
      return false;
    }
    m_buffer = new T[sz];
    if(!m_buffer) {
      m_w = 0;m_h = 0;m_owner = false;
      return false;
    }
    ::memcpy(m_buffer,a_from.m_buffer,sz*sizeof(T));
    m_owner = true;
    return true;
  }
  bool allocate(unsigned int a_w,unsigned int a_h){
    if(m_owner) delete [] m_buffer;
    m_buffer = 0;
    unsigned int sz = a_w*a_h*m_n;
    if(!sz) {
      m_w = 0;m_h = 0;m_owner = false;
      return false;
    }
    m_w = a_w;
    m_h = a_h;
    m_buffer = new T[sz];
    if(!m_buffer) {
      m_w = 0;m_h = 0;m_owner = false;
      return false;
    }
    m_owner = true;
    return true;
  }
  void make_empty() {
    if(m_owner) delete [] m_buffer;
    m_w = 0;
    m_h = 0;
    //don't touch m_n
    m_buffer = 0;
    m_owner = false;
  }
  bool equal(const img& a_from) const {
    if(m_w!=a_from.m_w) return false;
    if(m_h!=a_from.m_h) return false;
    if(m_n!=a_from.m_n) return false;
    //don't test ownership.
    unsigned int sz = m_w*m_h*m_n;
    T* pos = m_buffer;
    T* fpos = a_from.m_buffer;
    for(unsigned int index=0;index<sz;index++,pos++,fpos++) {
      if((*pos)!=(*fpos)) return false;
    }
    return true;
  }
  unsigned int width() const {return m_w;}
  unsigned int height() const {return m_h;}
  unsigned int bytes_per_pixel() const {return m_n;}
  unsigned int bpp() const {return m_n;}
  T* buffer() const {return m_buffer;}
  bool owner() const {return m_owner;}
  unsigned int size() const {return m_w*m_h*m_n*sizeof(T);} //bytes.
public:
  bool expand(unsigned int a_factor,img<T>& a_res) const {
    if(a_res.m_n!=m_n) {
      a_res.make_empty();
      return false;
    }
    if(a_factor==1) {
      a_res.set(m_w,m_h,m_buffer,false);
      return true;
    }
  
    unsigned int nw = m_w*a_factor;
    unsigned int nh = m_h*a_factor;
    unsigned int sz = nh*nw*m_n;
    if(!sz) {
      a_res.make_empty();
      return false;
    }
  
    T* nb = new T[sz];
    if(!nb) {
      a_res.make_empty();
      return false;
    }
  
    for(unsigned int j=0;j<m_h;j++) {
      for(unsigned int i=0;i<m_w;i++) {
        //position in the original image.
        T* pos = m_buffer + j * (m_w * m_n) + i*m_n;
  
        for(unsigned int fr=0;fr<a_factor;fr++) {
          for(unsigned int fc=0;fc<a_factor;fc++) {
            //position in the new image.
            T* npos = nb + (j*a_factor+fr) * (nw * m_n) + (i*a_factor+fc)*m_n;
            for(unsigned int ipix=0;ipix<m_n;ipix++) {
              *(npos+ipix) = *(pos+ipix);
            }
          }
        }
  
      }
    }
  
    a_res.set(nw,nh,nb,true);
    return true;
  }

  bool contract(unsigned int a_factor,img<T>& a_res) const {
    // a_factor pixels are contracted in one.
    if(a_res.m_n!=m_n) {
      a_res.make_empty();
      return false;
    }
    if(a_factor==1) {
      a_res.set(m_w,m_h,m_buffer,false);
      return true;
    }
    if(!a_factor) {
      a_res.make_empty();
      return false;
    }
  
    unsigned int nw = m_w/a_factor;
    unsigned int nh = m_h/a_factor;
    unsigned int sz = nh*nw*m_n;
    if(!sz) {
      a_res.make_empty();
      return false;
    }
  
    T* nb = new T[sz];
    if(!nb) {
      a_res.make_empty();
      return false;
    }

    //T* npos = nb;
    //for(unsigned int ipix=0;ipix<sz;ipix++) {*npos = 125;npos++;}

    double* pixels = new double[m_n]; //for mean value.
    if(!pixels) {
      delete [] nb;
      a_res.make_empty();
      return false;
    }
    unsigned int nfac = a_factor*a_factor;

    for(unsigned int j=0;j<nh;j++) {
      for(unsigned int i=0;i<nw;i++) {

        // take mean value of a_factor*a_factor pixels :  
        for(unsigned int ipix=0;ipix<m_n;ipix++) pixels[ipix] = 0;
            
        for(unsigned int fr=0;fr<a_factor;fr++) {
          for(unsigned int fc=0;fc<a_factor;fc++) {
            T* pos = m_buffer + (j*a_factor+fr)*(m_w*m_n) +(i*a_factor+fc)*m_n;
            for(unsigned int ipix=0;ipix<m_n;ipix++) {
              pixels[ipix] += double(*pos);pos++;
            }
          }
        }
        for(unsigned int ipix=0;ipix<m_n;ipix++) {
          pixels[ipix] /= double(nfac);
        }

        //position in the result image.
        T* npos = nb + j * (nw * m_n) + i*m_n;
        for(unsigned int ipix=0;ipix<m_n;ipix++) {
          *npos = T(pixels[ipix]);npos++;
        }
      }
    }

    delete [] pixels;

    a_res.set(nw,nh,nb,true);
    return true;
  }

  bool get_part(unsigned int a_sx,unsigned int a_sy,
                       unsigned int a_sw,unsigned int a_sh,
                       img<T>& a_res) const {

    if(a_res.m_n!=m_n) {
      a_res.make_empty();
      return false;
    }

    if((a_sx>=m_w)||(a_sy>=m_h)){
      a_res.make_empty();
      return false;
    }
  
    // 012345
    unsigned int rw = inlib::mn<unsigned int>(m_w-a_sx,a_sw); 
    unsigned int rh = inlib::mn<unsigned int>(m_h-a_sy,a_sh); 
    unsigned int sz = rh*rw*m_n;
    if(!sz) {
      a_res.make_empty();
      return false;
    }
  
    //printf("debug : %d %d\n",a_rw,a_rh);
  
    T* rb = new T[sz];
    if(!rb) {
      a_res.make_empty();
      return false;
    }
  
    unsigned int rstride = rw * m_n;
    T* rpos = rb;

    unsigned int stride = m_w * m_n;
    T* pos = m_buffer+a_sy*stride+a_sx*m_n;

    for(unsigned int j=0;j<rh;j++,rpos+=rstride,pos+=stride) {//j=0 -> bottom.
      ::memcpy(rpos,pos,rstride*sizeof(T));
    }

    a_res.set(rw,rh,rb,true);  
    return true;
  }

  bool to_texture(bool a_expand,
                         T a_pixel[], //size shoulde be a_img.m_n.
                         img<T>& a_res) const {

    //NOTE : pixels of the original image are not expanded or shrinked.

    if(a_res.m_n!=m_n) {
      a_res.make_empty();
      return false;
    }
    if((!m_w)||(!m_h)) {
      a_res.make_empty();
      return false;
    }

    // in case (m_w==1)||(m_h==1), expand the pixel
    // up to the closest power of 2 ?

    if((m_w==1)||(m_h==1)||a_expand) {
      // find closest power of two upper than m_w, m_h :
      unsigned int rw = 2;
      while(true) {if(rw>=m_w) break;rw *=2;}
      unsigned int rh = 2;
      while(true) {if(rh>=m_h) break;rh *=2;}
    
      if((rw==m_w)&&(rh==m_h)) { //exact match.
        a_res.set(m_w,m_h,m_buffer,false); //WARNING owner=false.
        return true;
      }
    
      // we expand the image and fill new spaces with rgb.
  
      T* rb = new T[rh*rw*m_n];
      if(!rb) {
        a_res.make_empty();
        return false;
      }
    
      // initialize with given color :
      for(unsigned int j=0;j<rh;j++) {  //j=0 -> bottom.
        T* pos = rb + j * (rw * m_n);
        for(unsigned int i=0;i<rw;i++) {
          for(unsigned int n=0;n<m_n;n++) {
            *pos = a_pixel[n];pos++; //memcpy ?
          }
        }
      }
    
      // center :
      unsigned int col = (rw-m_w)/2;  
      unsigned int row = (rh-m_h)/2;  
    
      // copy original image in a centered part of the new one :
      for(unsigned int j=0;j<m_h;j++) {
        T* pos = m_buffer + j * (m_w * m_n);
        T* rpos = rb + (j+row) * (rw * m_n) + col*m_n;
        ::memcpy(rpos,pos,m_w*m_n*sizeof(T));
      }

      a_res.set(rw,rh,rb,true);
    
      return true;
    } else {
      // then m_w>=2 and m_h>=2
  
      // find closest power of two lower than m_w, m_h :
      unsigned int sw = 2;
      while(true) {if((sw*2)>m_w) break;sw *=2;}
      unsigned int sh = 2;
      while(true) {if((sh*2)>m_h) break;sh *=2;}
  
      if((sw==m_w)&&(sh==m_h)) { //exact match.
        a_res.set(m_w,m_h,m_buffer,false); //WARNING owner=false.
        return true;
      }
  
      unsigned int sx = (m_w-sw)/2;
      unsigned int sy = (m_h-sh)/2;
  
      return get_part(sx,sy,sw,sh,a_res);
    }
  
  }

/*
  bool tex_match() const {
    if((!m_w)||(!m_h)) return false;

    ::printf("debug : tex_match : begin %d %d\n",m_w,m_h);

    // pixel expansion :

    // find closest power of two upper than m_w, m_h :
   {unsigned int rw = 2;
    unsigned int pw = 1;
    while(rw<m_w) {rw *=2;pw++;}

    for(unsigned int ipw=pw;ipw<30;ipw++) {
      unsigned int factor = 1;
      while(true) {
        unsigned int rw = power<unsigned int>(2,ipw);
        unsigned int n = rw/(m_w*factor);     
        unsigned int n1 = rw/(m_w*(factor+1));     
        if(n&&!n1) break;
        factor++;
      }
      unsigned int lost = (m_w*(factor+1)-rw)/(factor+1);      
      ::printf("debug : %d : %d lost %d w %d\n",
         ipw,factor+1,lost,m_w*(factor+1));
    }
    ::printf("debug : tex_match : exp end %d %d\n",
        pw,power<unsigned int>(2,pw));
    }

    // pixel contraction :
    if((m_w==1)||(m_h==1)) return false;

   {// closest w,h power of two below m_w,m_h :
    unsigned int sw = 2;
    unsigned int pw = 1;
    while((sw*2)<=m_w) {sw *=2;pw++;}

    for(unsigned int ipw=1;ipw<=pw;ipw++) {
      bool found = false;
      unsigned int factor = 1; //contraction factor.    
      while(true) {
        unsigned int sw = power<unsigned int>(2,ipw);
        unsigned int cw = m_w/factor; //width after contraction by factor.
        //unsigned int w = cw*factor;
        unsigned int cw1 = m_w/(factor+1);
        //unsigned int w1 = cw1*(factor+1);
        if((cw>=sw)&&(cw1<sw)) {found = true;break;}
        factor++;
      }
      if(!found) {
        ::printf("debug : ctrct : %d : not found\n",ipw);
      } else {
        unsigned int sw = power<unsigned int>(2,ipw);
        unsigned int cw = m_w/factor; //width after contraction by factor.
        unsigned int lost = cw-sw;
        ::printf("debug : ctrct : %d : %d lost %d w %d\n",
            ipw,factor,lost,(unsigned int)(m_w/factor));
      }
    }
    ::printf("debug : tex_match : contract end %d %d\n",
        pw,power<unsigned int>(2,pw));

    }

    return false;
  }

  enum to_tex_method { 
    to_tex_in_up_power_two,
    to_tex_expand_pixels_and_get_part,
    to_tex_get_part,
    to_tex_contract_pixels_and_get_part
  };
  
  bool guess_to_tex_method(to_tex_method& a_method) const {
    if((!m_w)||(!m_h)) {
      //any method is ok since to_texture() will do nothing.
      a_method = to_tex_in_up_power_two;
      return false;
    }

   {unsigned int rw = 2;
    while(true) {if(rw>=m_w) break;rw *=2;}
    unsigned int rh = 2;
    while(true) {if(rh>=m_h) break;rh *=2;}
    if((rw==m_w)&&(rh==m_h)) { //exact match.
      //any method is ok since to_texture() will do nothing.
      a_method = to_tex_in_up_power_two;
      return true;
    }}

    if((m_w==1)||(m_h==1)) {
      a_method = to_tex_in_up_power_two;
      return true;
    }

    // no exact match. Evaluate the best strategy
    // to minimize the number of pixels in the original image that
    // we can loose.

    // method = to_tex_in_up_power_two : no loose but new background pixel.

    unsigned int lost_expand_pixels_and_get_part_w = 0;
    unsigned int lost_expand_pixels_and_get_part_h = 0; 
    unsigned int lost_get_part_w = 0;
    unsigned int lost_get_part_h = 0; 
    unsigned int lost_contract_pixels_and_get_part_w = 0;
    unsigned int lost_contract_pixels_and_get_part_h = 0; 

   {//  method = expand_pixels_and_get_part;
    // closest power of two upper than m_w, mh :
    unsigned int rw = 2;
    while(true) {if(rw>=m_w) break;rw *=2;}
    unsigned int rh = 2;
    while(true) {if(rh>=m_h) break;rh *=2;}

    unsigned int fw = rw/m_w;
    if((fw*m_w)!=rw) fw++;    //to cover rw.
    unsigned int fh = rh/m_h;
    if((fh*m_h)!=rh) fh++;    //to cover rh.
    unsigned int factor = mx<unsigned int>(fw,fh); //pixel expansion factor.
    lost_expand_pixels_and_get_part_w = (factor*m_w-rw)/factor;
    lost_expand_pixels_and_get_part_h = (factor*m_h-rh)/factor;}

   {// closest w,h power of two below m_w,m_h :
    unsigned int sw = 2;
    while(true) {if((sw*2)>m_w) break;sw *=2;}
    unsigned int sh = 2;
    while(true) {if((sh*2)>m_h) break;sh *=2;}
    // method = get_part;
    lost_get_part_w = m_w-sw; 
    lost_get_part_h = m_h-sh; 
    // method = contract_and_get_part;
    unsigned int factor = 2; //=1 always pass the below with factor=1 !
    // exa m_[w,h] = 7. s[w,h] = 4.
    // 7/2=3<4 => 7/3=2<4 => 7/[4,5,6,7]=1<4 => 7/8=0.

    //  2**n <= w < 2**(n+1)
    //  2**n <= w/f
    //    f  <= w
    // f=1 ok.
    // for f not 1, if :
    //  w=p*f+q
    //  0<=q<f
    // same as :
    //  2**n <= p*f+q < (2**n)*2
    //  2**n <= p
    //  q < f
    // induces :
    //  (2**n)*f <= p*f <= p*f+q < (2**n)*2
    // induces :
    //  f < 2
    // not possible.

    while(true) {
      unsigned int nw = m_w/factor;
      unsigned int nh = m_h/factor;
      if((!nw)||(!nh)) {
        //enforce  method = expand_pix_and_get_part;
        return false;
      }
      if((nw>=sw)&&(nh>=sh)) break;          
      factor++;
    }
    unsigned int nw = m_w/factor;
    unsigned int nh = m_h/factor;
    // not in contracted image
    //  m_w-nw*factor 
    //  m_h-nh*factor 
    // not from contracted image :
    //  nw-sw
    //  nh-sh
    lost_contract_pixels_and_get_part_w = (nw-sw)+(m_w-nw*factor); 
    lost_contract_pixels_and_get_part_h = (nh-sh)+(m_h-nh*factor);}

    if(lost_get_part_h <=
                mn<unsigned int>(lost_expand_pixels_and_get_part_h,
                                 lost_contract_pixels_and_get_part_h)) {
      a_method = to_tex_get_part;

    } else if(lost_expand_pixels_and_get_part_h <=
         mn<unsigned int>(lost_get_part_h,
                          lost_contract_pixels_and_get_part_h)){
      a_method = to_tex_expand_pixels_and_get_part;

    } else if(lost_contract_pixels_and_get_part_h <=
         mn<unsigned int>(lost_expand_pixels_and_get_part_h,
                          lost_get_part_h)) {
      a_method = to_tex_contract_pixels_and_get_part;
    }

    return true;
  }

  bool to_texture2(to_tex_method a_method,
                         T a_pixel[], //size shoulde be m_n.
                         img<T>& a_res) const {
    if(a_res.m_n!=m_n) {
      a_res.make_empty();
      return false;
    }
    if((!m_n)||(!m_w)||(!m_h)) {
      a_res.make_empty();
      return false;
    }
    // we have a valid image to work with.

    // exact match ?
   {// closest power of two upper than m_w, mh :
    unsigned int rw = 2;
    while(true) {if(rw>=m_w) break;rw *=2;}
    unsigned int rh = 2;
    while(true) {if(rh>=m_h) break;rh *=2;}
    if((rw==m_w)&&(rh==m_h)) {
      a_res.set(m_w,m_h,m_buffer,false); //WARNING owner=false.
      return true;
    }}

    if((m_w==1)||(m_h==1)||(a_method==to_tex_in_up_power_two)) {
      // closest power of two upper than m_w, mh :
      unsigned int rw = 2;
      while(true) {if(rw>=m_w) break;rw *=2;}
      unsigned int rh = 2;
      while(true) {if(rh>=m_h) break;rh *=2;}
    
      // we create a rw*rh image, init with given rgb
      // and copy original image at center of it.
  
      T* rb = new T[rh*rw*m_n];
      if(!rb) {
        a_res.make_empty();
        return false;
      }
    
      // initialize with given color :
      for(unsigned int j=0;j<rh;j++) {  //j=0 -> bottom.
        T* pos = rb + j * (rw * m_n);
        for(unsigned int i=0;i<rw;i++) {
          for(unsigned int n=0;n<m_n;n++) {
            *pos = a_pixel[n];pos++; //memcpy ?
          }
        }
      }
    
      // center :
      unsigned int col = (rw-m_w)/2;  
      unsigned int row = (rh-m_h)/2;  
    
      // copy original image in a centered part of the new one :
      for(unsigned int j=0;j<m_h;j++) {
        T* pos = m_buffer + j * (m_w * m_n);
        T* rpos = rb + (j+row) * (rw * m_n) + col*m_n;
        ::memcpy(rpos,pos,m_w*m_n*sizeof(T));
      }

      a_res.set(rw,rh,rb,true);
      return true;

   } else if(a_method==to_tex_expand_pixels_and_get_part) {
      // closest power of two upper than m_w, mh :
      unsigned int rw = 2;
      while(true) {if(rw>=m_w) break;rw *=2;}
      unsigned int rh = 2;
      while(true) {if(rh>=m_h) break;rh *=2;}
    
      // we expand original image pixels to cover a rw*rh image
      // and we take a centered part matching rw*rh.

      unsigned int fw = rw/m_w;
      if((fw*m_w)!=rw) fw++;    //to cover rw.
      unsigned int fh = rh/m_h;
      if((fh*m_h)!=rh) fh++;    //to cover rh.
      unsigned int factor = mx<unsigned int>(fw,fh);
      img<T> tmp(m_n);
      if(!expand(factor,tmp)) {
        a_res.make_empty();
        return false;
      }
      unsigned int sx = (tmp.width()-rw)/2;
      unsigned int sy = (tmp.height()-rh)/2;
      return tmp.get_part(sx,sy,rw,rh,a_res);

    } else if(a_method==to_tex_get_part) {
  
      // closest w,h power of two below m_w,m_h :
      unsigned int sw = 2;
      while(true) {if((sw*2)>m_w) break;sw *=2;}
      unsigned int sh = 2;
      while(true) {if((sh*2)>m_h) break;sh *=2;}
  
      // we take a centered part of original image matching sw*sh.
      unsigned int sx = (m_w-sw)/2;
      unsigned int sy = (m_h-sh)/2;
      return get_part(sx,sy,sw,sh,a_res);

    } else if(a_method==to_tex_contract_pixels_and_get_part) {

      // closest w,h power of two below m_w,m_h :
      unsigned int sw = 2;
      while(true) {if((sw*2)>m_w) break;sw *=2;}
      unsigned int sh = 2;
      while(true) {if((sh*2)>m_h) break;sh *=2;}
  
      unsigned int factor = 1;
      while(true) {
        unsigned int nw = m_w/factor;
        unsigned int nh = m_h/factor;
        if((!nw)||(!nh)) {
          a_res.make_empty();
          return false;
        }
        if((nw>=sw)&&(nh>=sh)) break;          
        factor++;
      }
      img<T> tmp(m_n);
      if(!contract(factor,tmp)) {
        a_res.make_empty();
        return false;
      }
      unsigned int sx = (tmp.width()-sw)/2;
      unsigned int sy = (tmp.height()-sh)/2;
      return tmp.get_part(sx,sy,sw,sh,a_res);

    } else { //unknown method.
      a_res.make_empty();
      return false;
    }
  
  }
*/
public:
  static bool concatenate(const std::vector< img<T> >& a_imgs,
                                 unsigned int a_cols,unsigned int a_rows,
                                 unsigned int a_bw,unsigned int a_bh,
                                 T a_bc, //border grey level.
                                 img<T>& a_res){
    //not tested yet.
  
    // We assume that size of a_imgs is a_cols*a_rows

    // We should check that all a_imgs are consistents.
    
    unsigned int num = a_cols*a_rows;
    if(!num) {a_res.make_empty();return false;}

    unsigned int a_w = a_imgs[0].m_w;
    unsigned int a_h = a_imgs[0].m_h;
    unsigned int a_n = a_imgs[0].m_n;

    if(a_res.m_n!=a_n) {
      a_res.make_empty();
      return false;
    }
 
    for(unsigned int index=1;index<num;index++) {
      if(a_imgs[index].m_n!=a_n) {
        a_res.make_empty();
        return false;
      }
      if(a_imgs[index].m_w!=a_w) {
        a_res.make_empty();
        return false;
      }
      if(a_imgs[index].m_h!=a_h) {
        a_res.make_empty();
        return false;
      }
    }
  
    unsigned wbw = a_w + 2*a_bw;
    unsigned hbh = a_h + 2*a_bh;
  
    unsigned int rw = wbw * a_cols;
    unsigned int rh = hbh * a_rows;
  
    //printf("debug : %d %d\n",rw,rh);
  
    // on big concatenated image the below may fail :
    T* rb = new T[rh*rw*a_n];
    if(!rb) {
      a_res.make_empty();
      return false;
    }
  
    unsigned int wbwn = wbw*a_n;
    unsigned int awn = a_w*a_n;
    
    //copy tiles :  
    unsigned int index = 0;
    for(unsigned int j=0;j<a_rows;j++) {
      for(unsigned int i=0;i<a_cols;i++) {
        T* tile = a_imgs[index].buffer();
  
        for(unsigned int r=0;r<hbh;r++) {
          T* pos = rb + (j*hbh+r)*rw*a_n + i*wbw*a_n;
          ::memset(pos,a_bc,wbwn*sizeof(T));
        }
  
        for(unsigned int r=0;r<a_h;r++) {
          T* pos = rb + (j*hbh+r+a_bh)*rw*a_n + (i*wbw+a_bw)*a_n;
          T* ptile = tile+r*awn;        
          for(unsigned int c=0;c<awn;c++) *pos++ = *ptile++;
        }
  
        index++;
      }
    }
  
    a_res.set(rw,rh,rb,true);
    return true;
  }

protected:
  unsigned int m_w;
  unsigned int m_h;
  unsigned int m_n;
  T* m_buffer;
  bool m_owner;
private:
  static void check_instantiation() {
    img<float> dummy(3);
    //dummy.width();
  }
};


typedef img<unsigned char> img_byte;

// NOTE : img_byte is ready for OpenGL glTexImage2D UNSIGNED_BYTE RGB.
//        For glTexImage2D, first row in m_buffer is bottom of image.

}

#endif