cimg.cxx 3.6.3

package/plugins/chlpca.h

@@ -0,0 +1,323 @@
+/*
+ #
+ #  File        : chlpca.cpp
+ #                ( C++ source file )
+ #
+ #  Description : Example of use for the CImg plugin 'plugins/chlpca.h'.
+ #                This file is a part of the CImg Library project.
+ #                ( http://cimg.eu )
+ #
+ #  Copyright  : Jerome Boulanger
+ #               ( http://www.irisa.fr/vista/Equipe/People/Jerome.Boulanger.html )
+ #
+ #
+ #  License     : CeCILL v2.0
+ #                ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )
+ #
+ #  This software is governed by the CeCILL  license under French law and
+ #  abiding by the rules of distribution of free software.  You can  use,
+ #  modify and/ or redistribute the software under the terms of the CeCILL
+ #  license as circulated by CEA, CNRS and INRIA at the following URL
+ #  "http://www.cecill.info".
+ #
+ #  As a counterpart to the access to the source code and  rights to copy,
+ #  modify and redistribute granted by the license, users are provided only
+ #  with a limited warranty  and the software's author,  the holder of the
+ #  economic rights,  and the successive licensors  have only  limited
+ #  liability.
+ #
+ #  In this respect, the user's attention is drawn to the risks associated
+ #  with loading,  using,  modifying and/or developing or reproducing the
+ #  software by the user in light of its specific status of free software,
+ #  that may mean  that it is complicated to manipulate,  and  that  also
+ #  therefore means  that it is reserved for developers  and  experienced
+ #  professionals having in-depth computer knowledge. Users are therefore
+ #  encouraged to load and test the software's suitability as regards their
+ #  requirements in conditions enabling the security of their systems and/or
+ #  data to be ensured and,  more generally, to use and operate it in the
+ #  same conditions as regards security.
+ #
+ #  The fact that you are presently reading this means that you have had
+ #  knowledge of the CeCILL license and that you accept its terms.
+ #
+*/
+
+#ifndef cimg_plugin_chlpca
+#define cimg_plugin_chlpca
+
+// Define some useful macros.
+
+//! Some loops
+#define cimg_for_step1(bound,i,step) for (int i = 0; i<(int)(bound); i+=step)
+#define cimg_for_stepX(img,x,step) cimg_for_step1((img)._width,x,step)
+#define cimg_for_stepY(img,y,step) cimg_for_step1((img)._height,y,step)
+#define cimg_for_stepZ(img,z,step) cimg_for_step1((img)._depth,z,step)
+#define cimg_for_stepXY(img,x,y,step) cimg_for_stepY(img,y,step) cimg_for_stepX(img,x,step)
+#define cimg_for_stepXYZ(img,x,y,step) cimg_for_stepZ(img,z,step) cimg_for_stepY(img,y,step) cimg_for_stepX(img,x,step)
+
+//! Loop for point J(xj,yj) in the neighborhood of a point I(xi,yi) of size (2*rx+1,2*ry+1)
+/**
+   Point J is kept inside the boundaries of the image img.
+   example of summing the pixels values in a neighborhood 11x11
+   cimg_forXY(img,xi,yi) cimg_for_windowXY(img,xi,yi,xj,yj,5,5) dest(yi,yi) += src(xj,yj);
+**/
+#define cimg_forXY_window(img,xi,yi,xj,yj,rx,ry)                        \
+for (int yi0 = std::max(0,yi-ry), yi1=std::min(yi + ry,(int)img.height() - 1), yj=yi0;yj<=yi1;++yj) \
+for (int xi0 = std::max(0,xi-rx), xi1=std::min(xi + rx,(int)img.width() - 1), xj=xi0;xj<=xi1;++xj)
+
+#define cimg_forXYZ_window(img,xi,yi,zi,xj,yj,zj,rx,ry,rz)                                      \
+for (int zi0 = std::max(0,zi-rz), zi1=std::min(zi + rz,(int)img.depth() - 1) , zj=zi0;zj<=zi1;++zj) \
+for (int yi0 = std::max(0,yi-ry), yi1=std::min(yi + ry,(int)img.height() - 1), yj=yi0;yj<=yi1;++yj) \
+for (int xi0 = std::max(0,xi-rx), xi1=std::min(xi + rx,(int)img.width() - 1) , xj=xi0;xj<=xi1;++xj)
+
+//! Crop a patch in the image around position x,y,z and return a column vector
+/**
+   \param x x-coordinate of the center of the patch
+   \param y y-coordinate of the center of the patch
+   \param z z-coordinate of the center of the patch
+   \param px the patch half width
+   \param px the patch half height
+   \param px the patch half depth
+   \return img.get_crop(x0,y0,z0,x1,y1,z1).unroll('y');
+**/
+CImg<T> get_patch(int x, int y, int z,
+                  int px, int py, int pz) const {
+  if (depth() == 1){
+    const int x0 = x - px, y0 = y - py, x1 = x + px, y1 = y + py;
+    return get_crop(x0, y0, x1, y1).unroll('y');
+  } else {
+    const int
+      x0 = x - px, y0 = y - py, z0 = z - pz,
+      x1 = x + px, y1 = y + py, z1 = z + pz;
+    return get_crop(x0, y0, z0, x1, y1, z1).unroll('y');
+  }
+}
+
+//! Extract a local patch dictionnary around point xi,yi,zi
+CImg<T> get_patch_dictionnary(const int xi, const int yi, const int zi,
+			      const int px, const int py, const int pz,
+			      const int wx, const int wy, const int wz,
+			      int & idc) const {
+  const int
+    n = (2*wx + 1) * (2*wy + 1) * (2 * (depth()==1?0:wz) + 1),
+    d = (2*px + 1) * (2*py + 1) * (2 * (depth()==1?0:px) + 1) * spectrum();
+  CImg<> S(n, d);
+  int idx = 0;
+  if (depth() == 1) {
+    cimg_forXY_window((*this), xi, yi, xj, yj, wx, wy){
+      CImg<T> patch = get_patch(xj, yj, 0, px, py, 1);
+      cimg_forY(S,y) S(idx,y) = patch(y);
+      if (xj==xi && yj==yi) idc = idx;
+      idx++;
+    }
+  } else  {
+    cimg_forXYZ_window((*this), xi,yi,zi,xj,yj,zj,wx,wy,wz){
+      CImg<T> patch = get_patch(xj, yj, zj, px, py, pz);
+      cimg_forY(S,y) S(idx,y) = patch(y);
+      if (xj==xi && yj==yi && zj==zi) idc = idx;
+      idx++;
+    }
+  }
+  S.columns(0, idx - 1);
+  return S;
+}
+
+//! Add a patch to the image
+/**
+   \param x x-coordinate of the center of the patch
+   \param y y-coordinate of the center of the patch
+   \param z z-coordinate of the center of the patch
+   \param img the patch as a 1D column vector
+   \param px the patch half width
+   \param px the patch half height
+   \param px the patch half depth
+**/
+CImg<T> & add_patch(const int xi, const int yi, const int zi,
+		    const CImg<T> & patch,
+		    const int px, const int py, const int pz) {
+  const int
+    x0 = xi - px, y0 = yi - py, z0 = (depth() == 1 ? 0 : zi - pz),
+    sx = 2 * px + 1, sy = 2 * py + 1, sz = (depth() == 1 ? 1 : 2 * pz +1);
+  draw_image(x0, y0, z0, 0, patch.get_resize(sx, sy, sz, spectrum(), -1), -1);
+  return (*this);
+}
+
+//! Add a constant patch to the image
+/**
+   \param x x-coordinate of the center of the patch
+   \param y y-coordinate of the center of the patch
+   \param z z-coordinate of the center of the patch
+   \param value in the patch
+   \param px the patch half width
+   \param px the patch half height
+   \param px the patch half depth
+**/
+CImg<T> & add_patch(const int xi, const int yi, const int zi, const T value,
+		    const int px, const int py, const int pz) {
+  const int
+    x0 = xi - px, y0 = yi - py, z0 = (depth() == 1 ? 0 : zi - pz),
+    x1 = xi + px, y1 = yi + py, z1 = (depth() == 1 ? 0 : zi + pz);
+  draw_rectangle(x0, y0, z0, 0, x1, y1, z1, spectrum()-1, value, -1);
+return (*this);
+}
+
+//! CHLPCA denoising from the PhD thesis of Hu Haijuan
+/**
+   \param px the patch half width
+   \param py the patch half height
+   \param pz the patch half depth
+   \param wx the training region half width
+   \param wy the training region half height
+   \param wz the training region half depth
+   \param nstep the subsampling of the image domain
+   \param nsim the number of patches used for training as a factor of the patch size
+   \param lambda_min the threshold on the eigen values of the PCA for dimension reduction
+   \param threshold the threshold on the value of the coefficients
+   \param pca_use_svd if true use the svd approach to perform the pca otherwise use the covariance method
+   \note please cite the PhD thesis of Hu Haijuan http://www.univ-ubs.fr/soutenance-de-these-hu-haijuan-337653.kjsp?RH=1318498222799
+ **/
+CImg<T> get_chlpca(const int px, const int py, const int pz,
+		       const int wx, const int wy, const int wz,
+		       const int nstep, const float nsim,
+		       const float lambda_min, const float threshold,
+		       const float noise_std,  const bool pca_use_svd) const {
+  const int
+    nd = (2*px + 1) * (2*py + 1) * (depth()==1?1:2*pz + 1) * spectrum(),
+    K = (int)(nsim * nd);
+#ifdef DEBUG
+  fprintf(stderr,"chlpca: p:%dx%dx%d,w:%dx%dx%d,nd:%d,K:%d\n",
+	  2*px + 1,2*py + 1,2*pz + 1,2*wx + 1,2*wy + 1,2*wz + 1,nd,K);
+#endif
+  float sigma;
+  if (noise_std<0) sigma = (float)std::sqrt(variance_noise());
+  else sigma = noise_std;
+  CImg<T> dest(*this), count(*this);
+  dest.fill(0);
+  count.fill(0);
+  cimg_for_stepZ(*this,zi,(depth()==1||pz==0)?1:nstep){
+#ifdef cimg_use_openmp
+
+    cimg_pragma_openmp(parallel for)
+#endif
+      cimg_for_stepXY((*this),xi,yi,nstep){
+      // extract the training region X
+      int idc = 0;
+      CImg<T> S = get_patch_dictionnary(xi,yi,zi,px,py,pz,wx,wy,wz,idc);
+      // select the K most similar patches within the training set
+      CImg<T> Sk(S);
+      CImg<unsigned int> a_index(S.width());
+      if (K < Sk.width() - 1){
+	CImg<T> mse(S.width());
+	CImg<unsigned int> perms;
+	cimg_forX(S,x) { mse(x) = (T)S.get_column(idc).MSE(S.get_column(x)); }
+	mse.sort(perms,true);
+	cimg_foroff(perms,i) {
+	  cimg_forY(S,j) Sk(i,j) = S(perms(i),j);
+	  a_index(perms(i)) = i;
+	}
+	Sk.columns(0, K);
+	perms.threshold(K);
+      } else {
+	cimg_foroff(a_index,i) a_index(i)=i;
+      }
+      // centering the patches
+      CImg<T> M(1, Sk.height(), 1, 1, 0);
+      cimg_forXY(Sk,x,y) { M(y) += Sk(x,y); }
+      M /= (T)Sk.width();
+      cimg_forXY(Sk,x,y) { Sk(x,y) -= M(y); }
+      // compute the principal component of the training set S
+      CImg<T> P, lambda;
+      if (pca_use_svd) {
+	CImg<T> V;
+	Sk.get_transpose().SVD(V,lambda,P,true,100);
+      } else {
+	(Sk * Sk.get_transpose()).symmetric_eigen(lambda, P);
+	lambda.sqrt();
+      }
+      // dimension reduction
+      int s = 0;
+      const T tx = (T)(std::sqrt((double)Sk.width()-1.0) * lambda_min * sigma);
+      while((lambda(s) > tx) && (s < ((int)lambda.size() - 1))) { s++; }
+      P.columns(0,s);
+      // project all the patches on the basis (compute scalar product)
+      Sk = P.get_transpose() * Sk;
+      // threshold the coefficients
+      if (threshold > 0) { Sk.threshold(threshold, 1); }
+      // project back to pixel space
+      Sk =  P * Sk;
+      // recenter the patches
+      cimg_forXY(Sk,x,y) { Sk(x,y) += M(y); }
+      int j = 0;
+      cimg_forXYZ_window((*this),xi,yi,zi,xj,yj,zj,wx,wy,wz){
+	const int id = a_index(j);
+	if (id < Sk.width()) {
+	  dest.add_patch(xj, yj, zj, Sk.get_column(id), px, py, pz);
+	  count.add_patch(xj, yj, zj, (T)1, px, py, pz);
+	}
+	j++;
+      }
+    }
+  }
+  cimg_foroff(dest, i) {
+    if(count(i) != 0) { dest(i) /= count(i); }
+    else { dest(i) = (*this)(i); }
+  }
+  return dest;
+}
+
+//! CHLPCA denoising from the PhD thesis of Hu Haijuan
+/**
+   \param px the patch half width
+   \param px the patch half height
+   \param px the patch half depth
+   \param wx the training region half width
+   \param wy the training region half height
+   \param wz the training region half depth
+   \param nstep the subsampling of the image domain
+   \param nsim the number of patches used for training as a factor of the patch size
+   \param lambda_min the threshold on the eigen values of the PCA for dimension reduction
+   \param threshold the threshold on the value of the coefficients
+   \param pca_use_svd if true use the svd approach to perform the pca otherwise use the covariance method
+   \note please cite the PhD thesis of Hu Haijuan http://www.univ-ubs.fr/soutenance-de-these-hu-haijuan-337653.kjsp?RH=1318498222799
+ **/
+CImg<T> & chlpca(const int px, const int py, const int pz,
+		 const int wx, const int wy, const int wz,
+		 const int nstep, const float nsim,
+		 const float lambda_min, const float threshold,
+		 const float noise_std,  const bool pca_use_svd)  {
+  (*this) = get_chlpca(px, py, pz, wx, wy, wz, nstep, nsim, lambda_min,
+			       threshold, noise_std, pca_use_svd);
+  return (*this);
+}
+
+//! CHLPCA denoising from the PhD thesis of Hu Haijuan
+/**
+   \param p the patch half size
+   \param w the training region half size
+   \param nstep the subsampling of the image domain
+   \param nsim the number of patches used for training as a factor of the patch size
+   \param lambda_min the threshold on the eigen values of the PCA for dimension reduction
+   \param threshold the threshold on the value of the coefficients
+   \param pca_use_svd if true use the svd approach to perform the pca otherwise use the covariance method
+   \note please cite the PhD thesis of Hu Haijuan http://www.univ-ubs.fr/soutenance-de-these-hu-haijuan-337653.kjsp?RH=1318498222799
+ **/
+CImg<T> get_chlpca(const int p=3, const int w=10,
+		   const int nstep=5, const float nsim=10,
+		   const float lambda_min=2, const float threshold = -1,
+		   const float noise_std=-1, const bool pca_use_svd=true) const {
+  if (depth()==1) return get_chlpca(p, p, 0, w, w, 0, nstep, nsim, lambda_min,
+				    threshold, noise_std, pca_use_svd);
+  else return get_chlpca(p, p, p, w, w, w, nstep, nsim, lambda_min,
+			 threshold, noise_std, pca_use_svd);
+}
+
+CImg<T> chlpca(const int p=3, const int w=10,
+	       const int nstep=5, const float nsim=10,
+	       const float lambda_min=2, const float threshold = -1,
+	       const float noise_std=-1, const bool pca_use_svd=true) {
+  (*this) = get_chlpca(p, w, nstep, nsim, lambda_min,
+		       threshold, noise_std, pca_use_svd);
+  return (*this);
+}
+
+#endif /* cimg_plugin_chlpca */

package/plugins/cvMat.h

@@ -0,0 +1,350 @@
+/*
+#
+#  File        : cvMat.h
+#                ( C++ header file - CImg plug-in )
+#
+#  Description : CImg plug-in providing the CImg->cvMat and cvMat->CImg
+#                conversions for generic image types
+#                ( IPL = Intel Performance Library )
+#                This file is a part of the CImg Library project.
+#                ( http://cimg.sourceforge.net )
+#
+#  Copyright   : Alberto Albiol
+#                alalbiol@iteam.upv.es
+#
+#  How to use  : In the main program include:
+#        #include "cv.h"
+#        #include "highgui.h"
+#        #define cimg_plugin1 "cvMat.h"
+#        #include "CImg.h"
+*/
+#ifndef cimg_plugin_cvMat
+#define cimg_plugin_cvMat
+
+// Conversion IPL -> CImg (constructor)
+CImg(const cv::Mat& src):_width(0),_height(0),_depth(0),_spectrum(0),_is_shared(false),_data(0) {
+  assign(src);
+}
+
+// Conversion IPL -> CImg (in-place constructor)
+CImg<T>& assign(const cv::Mat & src) {
+  if (src.isContinuous()) {
+    switch (src.depth()) {
+        // case CV_1U: { // 1-bit int.
+        //    IplImage *src1 = cvCreateImage(cvGetSize(src),CV_8U,1);
+        //    cvConvert(src,src1);
+        //    CImg<ucharT>((unsigned char*)src1->imageData,src1->nChannels,src1.cols,src1.rows,1,true).
+        //      get_permute_axes("yzcx").move_to(*this);
+        //    cvReleaseImage(&src1);
+        //  } break;
+    case CV_8U: // 8-bit unsigned int.
+      if (src.channels()==1) {
+        CImg<ucharT>((unsigned char*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<ucharT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(uchar));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(uchar));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(uchar));
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_8S: // 8-bit signed int.
+      if (src.channels()==1) {
+        CImg<charT>((char*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<ucharT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(char));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(char));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(char));
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_16U: // 16-bit unsigned int.
+      if (src.channels()==1) {
+        CImg<ushortT>((unsigned short*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<ushortT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(unsigned short));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(unsigned short));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(unsigned short));
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_16S: // 16-bit signed int.
+      if (src.channels()==1) {
+        CImg<shortT>((short*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<shortT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(short));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(short));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(short));
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_32S: // 32-bit signed int.
+      if (src.channels()==1) {
+        CImg<intT>((int*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<intT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(int));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(int));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(int));
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_32F: // 32-bit float.
+      if (src.channels()==1) {
+        CImg<floatT>((float*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<floatT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(float));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(float));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(float));
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_64F: // 64-bit double.
+      if (src.channels()==1) {
+        CImg<doubleT>((double*)src.ptr(),src.cols,src.rows,true).move_to(*this);
+      } else {
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        CImg<doubleT>
+          tmp(src.cols,src.rows,1,3),
+          R = tmp.get_shared_channel(2),
+          G = tmp.get_shared_channel(1),
+          B = tmp.get_shared_channel(0);
+        std::memcpy(R.data(),channels[0].ptr(),src.cols*src.rows*sizeof(double));
+        std::memcpy(G.data(),channels[1].ptr(),src.cols*src.rows*sizeof(double));
+        std::memcpy(B.data(),channels[2].ptr(),src.cols*src.rows*sizeof(double));
+        tmp.move_to(*this);
+      }
+      break;
+    default:
+      throw CImgInstanceException(_cimg_instance
+                                  "assign(const cv::Mat&) : Mat depth is invalid.",
+                                  cimg_instance);
+      break;
+    }
+  } else {
+    cv::Size size = src.size();
+    switch (src.depth()) {
+    case CV_8U: // 8-bit unsigned int.
+      if (src.channels()==1) {
+        CImg<ucharT> tmp(src.cols,src.rows);
+        for (int i = 0; i<size.height; ++i) {
+          const unsigned char* row_i = src.ptr<unsigned char>(i);
+          unsigned char *row_o = tmp.data(0,i);
+          std::memcpy(row_o,row_i,size.width*sizeof(unsigned char));
+        }
+        tmp.move_to(*this);
+      } else {
+        CImg<ucharT> tmp(src.cols,src.rows,1,src.channels());
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        for (int c = 0; c<src.channels(); ++c) {
+          CImg<ucharT> plane = tmp.get_shared_channel(src.channels()-1-c);
+          for (int i = 0; i<size.height; ++i) {
+            const unsigned char* row_i = channels[c].ptr<unsigned char>(i);
+            unsigned char *row_o = plane.data(0,i);
+            std::memcpy(row_o,row_i,size.width*sizeof(unsigned char));
+          }
+        }
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_8S: // 8-bit int.
+      if (src.channels()==1) {
+        CImg<charT> tmp(src.cols,src.rows);
+        for (int i = 0; i<size.height; ++i) {
+          const char* row_i = src.ptr<char>(i);
+          char* row_o = tmp.data(0,i);
+          std::memcpy(row_o,row_i,size.width*sizeof(charT));
+        }
+        tmp.move_to(*this);
+      } else {
+        CImg<charT> tmp(src.cols,src.rows,1,src.channels());
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        for (int c = 0; c<src.channels(); ++c) {
+          CImg<charT> plane = tmp.get_shared_channel(src.channels()-1-c);
+          for (int i = 0; i<size.height; ++i) {
+            const char* row_i = channels[c].ptr<char>(i);
+            char *row_o = plane.data(0,i);
+            std::memcpy(row_o,row_i,size.width*sizeof(char));
+          }
+        }
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_16S: // 16-bit int.
+      if (src.channels()==1) {
+        CImg<shortT> tmp(src.cols,src.rows);
+        for (int i = 0; i<size.height; ++i) {
+          const short* row_i = src.ptr<short>(i);
+          short *row_o = tmp.data(0,i);
+          std::memcpy(row_o,row_i,size.width*sizeof(short));
+        }
+        tmp.move_to(*this);
+      } else {
+        CImg<shortT> tmp(src.cols,src.rows,1,src.channels());
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        for (int c = 0; c<src.channels(); ++c) {
+          CImg<shortT> plane = tmp.get_shared_channel(src.channels()-1-c);
+          for (int i = 0; i<size.height; ++i) {
+            const short* row_i = channels[c].ptr<short>(i);
+            short *row_o = plane.data(0,i);
+            std::memcpy(row_o,row_i,size.width*sizeof(short));
+          }
+        }
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_32F: // 32-bit float.float
+      if (src.channels()==1) {
+        CImg<floatT> tmp(src.cols,src.rows);
+        for (int i = 0; i<size.height; ++i) {
+          const float* row_i = src.ptr<float>(i);
+          float *row_o = tmp.data(0,i);
+          std::memcpy(row_o,row_i,size.width*sizeof(float));
+        }
+        tmp.move_to(*this);
+      } else {
+        CImg<floatT> tmp(src.cols,src.rows,1,src.channels());
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        for (int c = 0; c<src.channels(); ++c) {
+          CImg<floatT> plane = tmp.get_shared_channel(src.channels()-1-c);
+          for (int i = 0; i<size.height; ++i) {
+            const float* row_i = channels[c].ptr<float>(i);
+            float *row_o = plane.data(0,i);
+            std::memcpy(row_o,row_i,size.width*sizeof(float));
+          }
+        }
+        tmp.move_to(*this);
+      }
+      break;
+    case CV_64F: // 64-bit double.
+      if (src.channels()==1) {
+        CImg<doubleT> tmp(src.cols,src.rows);
+        for (int i = 0; i<size.height; ++i) {
+          const double* row_i = src.ptr<double>(i);
+          double *row_o = tmp.data(0,i);
+          std::memcpy(row_o,row_i,size.width*sizeof(double));
+        }
+        tmp.move_to(*this);
+      } else {
+        CImg<doubleT> tmp(src.cols,src.rows,1,src.channels());
+        std::vector<cv::Mat> channels;
+        cv::split(src,channels);
+        for (int c = 0; c<src.channels(); ++c) {
+          CImg<doubleT> plane = tmp.get_shared_channel(src.channels()-1-c);
+          for (int i = 0; i<size.height; ++i) {
+            const double* row_i = channels[c].ptr<double>(i);
+            double *row_o = plane.data(0,i);
+            std::memcpy(row_o,row_i,size.width*sizeof(double));
+          }
+        }
+        tmp.move_to(*this);
+      }
+      break;
+    default:
+      throw CImgInstanceException(_cimg_instance
+                                  "assign(const cv::Mat&) : Mat depth is invalid.",
+                                  cimg_instance);
+      break;
+    }
+  }
+
+  //  if (!std::strcmp(src->channelSeq,"BGR")) mirror('v');
+  //  else if (!std::strcmp(src->channelSeq,"BGRA")) get_shared_channels(0,2).mirror('v');
+  return *this;
+}
+
+// Conversion CImg -> MAT
+cv::Mat get_MAT(const unsigned int z=0) const {
+  if (is_empty())
+    throw CImgInstanceException(_cimg_instance
+                                "get_MAT() : instance image is empty.",
+                                cimg_instance);
+  if (z>=_depth)
+    throw CImgInstanceException(_cimg_instance
+                                "get_MAT() : specified slice %u is out of image bounds.",
+                                cimg_instance,z);
+  const CImg<T>
+    _slice = _depth>1?get_slice(z):CImg<T>(),
+    &slice = _depth>1?_slice:*this;
+  CImg<T> buf(slice,true);
+  int
+    cols = buf.width(),
+    rows = buf.height(),
+    nchannels = buf.spectrum(),
+    matType=-1;
+
+  if (!cimg::strcasecmp(buf.pixel_type(),"unsigned char")) matType = CV_8UC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"uint8")) matType = CV_8UC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"char")) matType = CV_8SC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"int8")) matType = CV_8SC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"unsigned short")) matType = CV_16UC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"uint16")) matType = CV_16UC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"short")) matType = CV_16SC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"int16")) matType = CV_16SC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"int")) matType = CV_32SC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"int32")) matType = CV_32SC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"float")) matType = CV_32FC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"float32")) matType = CV_32FC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"double")) matType = CV_64FC1;
+  if (!cimg::strcasecmp(buf.pixel_type(),"float64")) matType = CV_64FC1;
+  if (matType<0)
+    throw CImgInstanceException(_cimg_instance
+                                "get_MAT() : pixel type '%s' is not supported.",
+                                cimg_instance,buf.pixel_type());
+  cv::Mat out;
+  std::vector<cv::Mat> channels(nchannels);
+  if (nchannels>1) {
+    for (int c = 0; c<nchannels; ++c) {
+      channels[c] = cv::Mat(rows,cols,matType,const_cast<T*>(buf.data()+rows*cols*(nchannels-1-c)));
+    } // for channels
+    cv::merge(channels,out);
+  } else out = cv::Mat(rows,cols,matType,const_cast<T*>(buf.data())).clone();
+  return out;
+}
+
+#endif /* cimg_plugin_cvMat */