cimg.cxx 3.6.3

package/README.txt

@@ -0,0 +1,180 @@
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+                            ____  _   _  ____
+                           (_  _)( )_( )( ___)
+                             )(   ) _ (  )__)
+                            (__) (_) (_)(____)
+    ___  ____  __  __  ___     __    ____  ____  ____    __    ____  _  _
+   / __)(_  _)(  \/  )/ __)   (  )  (_  _)(  _ \(  _ \  /__\  (  _ \( \/ )
+  ( (__  _)(_  )    (( (_-.    )(__  _)(_  ) _ < )   / /(__)\  )   / \  /
+   \___)(____)(_/\/\_)\___/   (____)(____)(____/(_)\_)(__)(__)(_)\_) (__)
+
+
+                    C++ Template Image Processing Toolkit
+
+                             ( http://cimg.eu )
+
+                                   _cimg_version
+
+--------------------------------------------------------------------------------
+
+# Summary
+#---------
+
+  The CImg Library is a small and open-source C++ toolkit for image processing.
+  It consists in a single header file 'CImg.h' providing a minimal set of C++
+  classes and methods that can be used in your own sources, to load/save,
+  process and display images. Very portable (Unix/X11,Windows, MacOS X, FreeBSD, .. ),
+  efficient, easy to use, it's a pleasant library for developing image processing
+  algorithms in C++.
+
+# Authors and contributors :
+#----------------------------
+
+  - David Tschumperlé (project leader) ( http://tschumperle.users.greyc.fr/ )
+
+  - Maksim Aizenshtein
+  - Alberto Albiol
+  - Antonio Albiol
+  - Simon Barthelme
+  - Neil Brown
+  - Haz-Edine Assemlal
+  - Vincent Barra
+  - Wolf Blecher
+  - Romain Blei
+  - Yohan Bentolila
+  - Jerome Boulanger
+  - Pierre Buyssens
+  - Sebastien Coudert
+  - Frederic Devernay
+  - Olivier D'Hondt
+  - Francois-Xavier Dupe
+  - Gerd von Egidy
+  - Eric Fausett
+  - Jean-Marie Favreau
+  - Sebastien Fourey
+  - Alexandre Fournier
+  - Hon-Kwok Fung
+  - Vincent Garcia
+  - David Grimbichler
+  - Jinwei Gu
+  - Jean-Daniel Guyot
+  - Cedric Hammiche
+  - Matt Hanson
+  - Sebastien Hanel
+  - Michael Holroyd
+  - Christoph Hormann
+  - Werner Jainek
+  - Daniel Kondermann
+  - Pierre Kornprobst
+  - Jan W. Krieger
+  - Orges Leka
+  - Francois Lauze
+  - Xie Long
+  - Thomas Martin
+  - Cesar Martinez
+  - Jean Martinot
+  - Arnold Meijster (Center for High Performance Computing and Visualization, University of Groningen/The Netherlands)
+  - Nikita Melnichenko
+  - Julien Morat
+  - Baptiste Mougel
+  - Jovana Milutinovich
+  - Guillaume Nee
+  - Adam Newgas
+  - Francisco Oliveira
+  - Andrea Onofri
+  - Renaud Peteri
+  - Martin Petricek
+  - Paolo Prete
+  - Adrien Reboisson
+  - Klaus Schneider
+  - Jakob Schluttig
+  - Jamie Smith
+  - Veronique Souchaud
+  - Konstantin Spirin
+  - David G. Starkweather
+  - Rainer Steffens
+  - Grzegorz Szwoch
+  - Thierry Thomas
+  - Yu-En-Yun
+  - Vo Duc Khanh
+  - Phillip Wood
+  - Bug Zhao
+  - Haibo Zheng
+
+# Institution
+#-------------
+
+ GREYC Image / CNRS UMR 6072 / FRANCE
+
+ The CImg Library project started in 2000, at the INRIA-Sophia
+ Antipolis/France ( http://www-sop.inria.fr/ ), in the ROBOTVIS / ODYSSEE Team.
+ Since October 2004, it is maintained and developed in the Image team of
+ the GREYC Lab (CNRS, UMR 6072), in Caen/France.
+ Team web page : http://www.greyc.fr/image
+
+# Licenses
+#----------
+
+ The source code of the CImg Library is distributed under
+ two distinct licenses :
+
+ - The main library file 'CImg.h' is *dual-licensed* :
+   It can be either distributed under the CeCILL-C or CeCILL license.
+   (see files 'Licence_CeCILL-C_V1-en.txt' and 'Licence_CeCILL_V2-en.txt').
+   Both are Free-Software licenses :
+
+     * CeCILL-C is adapted to the distribution of
+       library components, and is close in its terms to the well known GNU LGPL license
+       (the 'CImg.h' file can thus be used in closed-source products under certain
+       conditions, please read carefully the license file).
+
+     * CeCILL is close to (and even compatible with) the GNU GPL license.
+
+ - Most of the other files are distributed under the CeCiLL license
+   (file 'Licence_CeCILL_V2-en.txt'). See each file header to see what license applies.
+
+ These two CeCiLL licenses ( http://www.cecill.info/index.en.html ) have been
+ created under the supervision of the three biggest research institutions on
+ computer sciences in France :
+
+   - CNRS  ( http://www.cnrs.fr/ )
+   - CEA   ( http://www.cea.fr/ )
+   - INRIA ( http://www.inria.fr/ )
+
+ You have to RESPECT these licenses. More particularly, please carefully read
+ the license terms before using the CImg library in commercial products.
+
+# Package structure :
+#--------------------
+
+  The main package directory CImg/ is organized as follows :
+
+  - README.txt                 : This file.
+  - Licence_CeCILL-C_V1-en.txt : A copy of the CeCiLL-C license file.
+  - Licence_CeCILL_V2-en.txt   : A copy of the CeCiLL license.
+  - CImg.h                     : The single header file that constitutes the library itself.
+  - examples/                  : A directory containing a lot of example programs performing
+                                 various things, using the CImg library.
+  - html/                      : A directory containing a copy of the CImg web page in html
+                                 format. The reference documentation is generated
+              		         automatically with the tool 'doxygen' (http://www.doxygen.org).
+  - resources/                 : A directory containing some resources files for compiling
+                                 CImg examples or packages with various C++ compilers and OS.
+  - plugins/                   : A directory containing CImg plug-ins files that can be used to
+                                 add specific extra functionalities to the CImg library.
+
+# Getting started
+#-----------------
+
+  If you are new to CImg, you should first try to compile the different examples
+  provided in the 'examples/' directory, to see what CImg is capable of
+  (as CImg is a template-based library, no prior compilation of the library is mandatory).
+  Look at the 'resources/' directory to ease this compilation on different platforms.
+
+  Then, you can look at the documentation 'html/reference/' to learn more about CImg
+  functions and classes. Finally, you can participate to the 'Forum' section
+  of the CImg web page and ask for help if needed.
+
+# End of file
+#------------

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "cimg.cxx",
+  "version": "3.6.3",
+  "description": "The CImg Library is a small and open-source C++ toolkit for image processing; GREYC (2018).",
+  "keywords": ["c", "library", "image", "processing", "cimg"],
+  "license": "CeCILL",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodef/cimg.cxx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nodef/cimg.cxx/issues"
+  },
+  "homepage": "https://github.com/nodef/cimg.cxx#readme"
+}

package/plugins/add_fileformat.h

@@ -0,0 +1,79 @@
+/*
+ #
+ #  File        : add_fileformat.h
+ #                ( C++ header file - CImg plug-in )
+ #
+ #  Description : CImg plug-in that adds loading/saving support for a personalized
+ #                file format (determined by its extension, here ".foo").
+ #                This file is a part of the CImg Library project.
+ #                ( http://cimg.eu )
+ #
+ #  Copyright   : David Tschumperlé
+ #                ( http://tschumperle.users.greyc.fr/ )
+ #
+ #  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_addfileformat
+#define cimg_plugin_addfileformat
+
+// These functions load ".foo" filenames
+//---------------------------------------
+static CImg<T> get_load_foo(const char *filename) {
+  std::fprintf(stderr,"Load '%s' here..\n",filename);
+  return CImg<T>(512,512,1,3,0).noise(30);
+}
+
+CImg& load_foo(const char *filename) {
+  return get_load_foo(filename).swap(*this);
+}
+
+// This function saves the instance image into a ".foo" file.
+//-----------------------------------------------------------
+const CImg& save_foo(const char *filename) const {
+  std::fprintf(stderr,"Save '%s' here..\n",filename);
+  return *this;
+}
+
+// The code below allows to add the support for the specified extension.
+//---------------------------------------------------------------------
+#ifndef cimg_load_plugin
+#define cimg_load_plugin(filename) \
+  if (!cimg::strncasecmp(cimg::split_filename(filename),"foo",3)) return load_foo(filename);
+#endif
+#ifndef cimg_save_plugin
+#define cimg_save_plugin(filename) \
+  if (!cimg::strncasecmp(cimg::split_filename(filename),"foo",3)) return save_foo(filename);
+#endif
+
+// End of the plugin.
+//-------------------
+#endif /* cimg_plugin_addfileformat */

package/plugins/bayer.h

@@ -0,0 +1,212 @@
+/*
+ #
+ #  File        : bayer.h
+ #                ( C++ header file - CImg plug-in )
+ #
+ #  Description : CImg plugin that implements the conversion of a color image to a
+ #                Bayer-coded matrix, and its reverse transform.
+ #
+ #  Copyright   : David Tschumperlé
+ #                ( https://tschumperle.users.greyc.fr/ )
+ #
+ #  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_bayer
+#define cimg_plugin_bayer
+
+//! Convert RGB color image to a Bayer-coded scalar image.
+/**
+   \note First (upper-left) pixel if the red component of the pixel color.
+**/
+CImg<T>& RGBtoBayer() {
+  return get_RGBtoBayer().move_to(*this);
+}
+
+//! Convert RGB color image to a Bayer-coded scalar image \newinstance.
+CImg<T> get_RGBtoBayer() const {
+  if (_spectrum!=3)
+    throw CImgInstanceException(_cimg_instance
+                                "RGBtoBayer(): Instance is not a RGB image.",
+                                cimg_instance);
+
+  CImg<T> res(_width,_height,_depth,1);
+  const T *ptr_r = data(0,0,0,0), *ptr_g = data(0,0,0,1), *ptr_b = data(0,0,0,2);
+  T *ptrd = res._data;
+  cimg_forXYZ(*this,x,y,z) {
+    if (y%2) {
+      if (x%2) *(ptrd++) = *ptr_b;
+      else *(ptrd++) = *ptr_g;
+    } else {
+      if (x%2) *(ptrd++) = *ptr_g;
+      else *(ptrd++) = *ptr_r;
+    }
+    ++ptr_r; ++ptr_g; ++ptr_b;
+  }
+  return res;
+}
+
+//! Convert Bayer-coded scalar image to a RGB color image.
+CImg<T>& BayertoRGB(const unsigned int interpolation_type=3) {
+  return get_BayertoRGB(interpolation_type).move_to(*this);
+}
+
+//! Convert Bayer-coded scalar image to a RGB color image \newinstance.
+CImg<Tuchar> get_BayertoRGB(const unsigned int interpolation_type=3) const {
+  if (_spectrum!=1)
+    throw CImgInstanceException(_cimg_instance
+                                "BayertoRGB(): Instance is not a Bayer image.",
+                                cimg_instance);
+
+  CImg<Tuchar> res(_width,_height,_depth,3);
+  CImg_3x3(I,T);
+  Tuchar *ptr_r = res.data(0,0,0,0), *ptr_g = res.data(0,0,0,1), *ptr_b = res.data(0,0,0,2);
+  switch (interpolation_type) {
+  case 3 : { // Edge-directed
+    CImg_3x3(R,T);
+    CImg_3x3(G,T);
+    CImg_3x3(B,T);
+    cimg_forXYZ(*this,x,y,z) {
+      const int _p1x = x?x - 1:1, _p1y = y?y - 1:1, _n1x = x<width() - 1?x + 1:x - 1, _n1y = y<height() - 1?y + 1:y - 1;
+      cimg_get3x3(*this,x,y,z,0,I,T);
+      if (y%2) {
+        if (x%2) {
+          const Tfloat
+            alpha = cimg::sqr((Tfloat)Inc - Ipc),
+            beta = cimg::sqr((Tfloat)Icn - Icp),
+            cx = 1/(1 + alpha), cy = 1/(1 + beta);
+          *ptr_g = (Tuchar)((cx*(Inc + Ipc) + cy*(Icn + Icp))/(2*(cx + cy)));
+        } else *ptr_g = (Tuchar)Icc;
+      } else {
+        if (x%2) *ptr_g = (Tuchar)Icc;
+        else {
+          const Tfloat
+            alpha = cimg::sqr((Tfloat)Inc - Ipc),
+            beta = cimg::sqr((Tfloat)Icn - Icp),
+            cx = 1/(1 + alpha), cy = 1/(1 + beta);
+          *ptr_g = (Tuchar)((cx*(Inc + Ipc) + cy*(Icn + Icp))/(2*(cx + cy)));
+        }
+      }
+      ++ptr_g;
+    }
+    cimg_forXYZ(*this,x,y,z) {
+      const int _p1x = x?x - 1:1, _p1y = y?y - 1:1, _n1x = x<width() - 1?x + 1:x - 1, _n1y = y<height() - 1?y + 1:y - 1;
+      cimg_get3x3(*this,x,y,z,0,I,T);
+      cimg_get3x3(res,x,y,z,1,G,T);
+      if (y%2) {
+        if (x%2) *ptr_b = (Tuchar)Icc;
+        else { *ptr_r = (Tuchar)((Icn + Icp)/2); *ptr_b = (Tuchar)((Inc + Ipc)/2); }
+      } else {
+        if (x%2) { *ptr_r = (Tuchar)((Inc + Ipc)/2); *ptr_b = (Tuchar)((Icn + Icp)/2); }
+        else *ptr_r = (Tuchar)Icc;
+      }
+      ++ptr_r; ++ptr_b;
+    }
+    ptr_r = res.data(0,0,0,0);
+    ptr_g = res.data(0,0,0,1);
+    ptr_b = res.data(0,0,0,2);
+    cimg_forXYZ(*this,x,y,z) {
+      const int _p1x = x?x - 1:1, _p1y = y?y - 1:1, _n1x = x<width() - 1?x + 1:x - 1, _n1y = y<height() - 1?y + 1:y - 1;
+      cimg_get3x3(res,x,y,z,0,R,T);
+      cimg_get3x3(res,x,y,z,1,G,T);
+      cimg_get3x3(res,x,y,z,2,B,T);
+      if (y%2) {
+        if (x%2) {
+          const float
+            alpha = (float)cimg::sqr(Rnc - Rpc),
+            beta = (float)cimg::sqr(Rcn - Rcp),
+            cx = 1/(1 + alpha), cy = 1/(1 + beta);
+          *ptr_r = (Tuchar)((cx*(Rnc + Rpc) + cy*(Rcn + Rcp))/(2*(cx + cy)));
+        }
+      } else {
+        if (!(x%2)) {
+          const float
+            alpha = (float)cimg::sqr(Bnc - Bpc),
+            beta = (float)cimg::sqr(Bcn - Bcp),
+            cx = 1/(1 + alpha), cy = 1/(1 + beta);
+          *ptr_b = (Tuchar)((cx*(Bnc + Bpc) + cy*(Bcn + Bcp))/(2*(cx + cy)));
+        }
+      }
+      ++ptr_r; ++ptr_g; ++ptr_b;
+    }
+  } break;
+  case 2 : { // Linear interpolation
+    cimg_forXYZ(*this,x,y,z) {
+      const int _p1x = x?x - 1:1, _p1y = y?y - 1:1, _n1x = x<width() - 1?x + 1:x - 1, _n1y = y<height() - 1?y + 1:y - 1;
+      cimg_get3x3(*this,x,y,z,0,I,T);
+      if (y%2) {
+        if (x%2) {
+          *ptr_r = (Tuchar)((Ipp + Inn + Ipn + Inp)/4);
+          *ptr_g = (Tuchar)((Inc + Ipc + Icn + Icp)/4);
+          *ptr_b = (Tuchar)Icc;
+        } else { *ptr_r = (Tuchar)((Icp + Icn)/2); *ptr_g = (Tuchar)Icc; *ptr_b = (Tuchar)((Inc + Ipc)/2); }
+      } else {
+        if (x%2) { *ptr_r = (Tuchar)((Ipc + Inc)/2); *ptr_g = (Tuchar)Icc; *ptr_b = (Tuchar)((Icn + Icp)/2); }
+        else {
+          *ptr_r = (Tuchar)Icc;
+          *ptr_g = (Tuchar)((Inc + Ipc + Icn + Icp)/4);
+          *ptr_b = (Tuchar)((Ipp + Inn + Ipn + Inp)/4);
+        }
+      }
+      ++ptr_r; ++ptr_g; ++ptr_b;
+    }
+  } break;
+  case 1 : { // Nearest neighbor interpolation
+    cimg_forXYZ(*this,x,y,z) {
+      const int _p1x = x?x - 1:1, _p1y = y?y - 1:1, _n1x = x<width() - 1?x + 1:x - 1, _n1y = y<height() - 1?y + 1:y - 1;
+      cimg_get3x3(*this,x,y,z,0,I,T);
+      if (y%2) {
+        if (x%2) {
+          *ptr_r = (Tuchar)cimg::min(Ipp,Inn,Ipn,Inp);
+          *ptr_g = (Tuchar)cimg::min(Inc,Ipc,Icn,Icp);
+          *ptr_b = (Tuchar)Icc;
+        } else { *ptr_r = (Tuchar)cimg::min(Icn,Icp); *ptr_g = (Tuchar)Icc; *ptr_b = (Tuchar)cimg::min(Inc,Ipc); }
+      } else {
+        if (x%2) { *ptr_r = (Tuchar)cimg::min(Inc,Ipc); *ptr_g = (Tuchar)Icc; *ptr_b = (Tuchar)cimg::min(Icn,Icp); }
+        else {
+          *ptr_r = (Tuchar)Icc;
+          *ptr_g = (Tuchar)cimg::min(Inc,Ipc,Icn,Icp);
+          *ptr_b = (Tuchar)cimg::min(Ipp,Inn,Ipn,Inp);
+        }
+      }
+      ++ptr_r; ++ptr_g; ++ptr_b;
+    }
+  } break;
+  default : { // 0-filling interpolation
+    const T *ptrs = _data;
+    res.fill(0);
+    cimg_forXYZ(*this,x,y,z) {
+      const T val = *(ptrs++);
+      if (y%2) { if (x%2) *ptr_b = val; else *ptr_g = val; } else { if (x%2) *ptr_g = val; else *ptr_r = val; }
+      ++ptr_r; ++ptr_g; ++ptr_b;
+    }
+  }
+  }
+  return res;
+}
+
+#endif /* cimg_plugin_bayer */