cimg.cxx 3.6.3

package/plugins/vrml.h

@@ -0,0 +1,894 @@
+/*
+ #
+ #  File        : vrml.h
+ #                ( C++ header file - CImg plug-in )
+ #
+ #  Description : CImg plugin that provide functions to load/save VRML files.
+ #                This file is a part of the CImg Library project.
+ #                ( http://cimg.eu )
+ #
+ #  Copyright   : Greg Rami
+ #                ( greg.rami36 (at) gmail.com )
+ #
+ #  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.
+ #
+*/
+
+/*-----------------------------------------------------------------------------------
+
+ IMPORTANT NOTE :
+
+ You *need* to include the following lines in your own code to use this plugin :
+
+ #include <vector>
+ #include <string>
+ #include <sstream>
+ #include <algorithm>
+
+------------------------------------------------------------------------------------*/
+
+#ifndef cimg_plugin_vrml
+#define cimg_plugin_vrml
+
+//! Load a 3d object from a .VRML file.
+template<typename tf, typename tc>
+CImg<T>& load_vrml(const char *const filename, CImgList<tf>& primitives, CImgList<tc>& colors) {
+  return _load_vrml(0,filename,primitives,colors);
+}
+
+//! Load a 3d object from a .VRML file.
+template<typename tf, typename tc>
+static CImg<T> get_load_vrml(const char *const filename, CImgList<tf>& primitives, CImgList<tc>& colors) {
+  return CImg<T>().load_vrml(filename,primitives,colors);
+}
+
+//! Load a 3d object from a .VRML file.
+template<typename tf, typename tc>
+CImg<T>& load_vrml(std::FILE *const file, CImgList<tf>& primitives, CImgList<tc>& colors) {
+  return _load_vrml(file,0,primitives,colors);
+}
+
+//! Load a 3d object from a .VRML file.
+template<typename tf, typename tc>
+static CImg<T> get_load_vrml(std::FILE *const file, CImgList<tf>& primitives, CImgList<tc>& colors) {
+  return CImg<T>().load_vrml(file,primitives,colors);
+}
+
+//! Load a 3d object from a .VRML file (internal).
+template<typename tf, typename tc>
+CImg<T>& _load_vrml(std::FILE *const file, const char *const filename,CImgList<tf>& primitives, CImgList<tc>& colors) {
+  if (!file && !filename)
+    throw CImgArgumentException(_cimg_instance
+                                "load_vrml() : Specified filename is (null).",
+                                cimg_instance);
+  std::FILE *const nfile = file?file:cimg::fopen(filename,"r");
+
+  char line[1024] = { 0 };
+  int err;
+
+  // Skip comments, and read the first node.
+  do { err = std::fscanf(nfile,"%65535[^\n] ",line); } while (!err || (err==1 && *line=='#'));
+
+  // Check for a first valid vrml valid node.
+  if (cimg::strncasecmp(line,"Shape",5) &&
+      cimg::strncasecmp(line,"Transform",9) &&
+      cimg::strncasecmp(line,"NavigationInfo",14) &&
+      cimg::strncasecmp(line,"Billboard",9)) {
+    if (!file) cimg::fclose(nfile);
+    throw CImgIOException(_cimg_instance
+                          "load_vrml() : VRML nodes not found in file '%s'.",
+                          cimg_instance,filename?filename:"(FILE*)");
+  }
+
+  // Look for the Shape node (as we do not manage the treatment for the other nodes yet).
+  if (cimg::strncasecmp(line,"Shape",5)) {
+    while (cimg::strncasecmp(line,"Shape",5) && !std::feof(nfile)) err = std::fscanf(nfile,"%1023[^\n] ",line);
+    if (std::feof(nfile)) {
+      if (!file) cimg::fclose(nfile);
+      throw CImgIOException(_cimg_instance
+                            "load_vrml() : Shape node not found in file '%s'.",
+                            cimg_instance,filename?filename:"(FILE*)");
+    }
+  }
+
+  // Look for either geometry or appearance node.
+  while (cimg::strncasecmp(line,"geometry",8) && cimg::strncasecmp(line,"appearance",10) && !std::feof(nfile))
+    err = std::fscanf(nfile,"%1023[^\n] ",line);
+  if (std::feof(nfile)) { // If none of these nodes are defined.
+    if (!file) cimg::fclose(nfile);
+    throw CImgIOException(_cimg_instance
+                          "load_vrml() : Geometry and appearance nodes not found in file '%s'.",
+                          cimg_instance,filename?filename:"(FILE*)");
+  }
+
+  std::vector<T> listePoints; // Intermediate list containing the points of the whole object.
+  primitives.assign();
+  colors.assign();
+  // Count the number of points of the whole object and the number of primitives.
+  int nbPointsTotal = 0, nbPrimitives = 0;
+  float r = 0.78f, g = 0.78f, b = 0.78f; // RGB level of the object, the object is gray by default.
+  // Boolean used to know if a color is defined for an object,
+  // if this object has multiple colors or if the object has a texture
+  bool colorDefined = true, multipleColors = false, textureTest = false;
+  char textureFile[1024] = { 0 }; // Variable containing the name of the image used as a texture
+
+  while (!std::feof(nfile)) {
+    char type[1024] = { 0 }, textureFileTemp[1024] = { 0 };
+    colorDefined = true;
+    if (!cimg::strncasecmp(line,"geometry",8)) {       // We are at the geometry node
+      std::sscanf(line,"geometry %s",type);            // We are looking for the type of geometry to draw
+      const CImg<float> coords = CImg<float>::empty(); // CImg used for the texturization of an object
+      CImgList<tc> colorsTextured;                     // CImgList used for the texturization of the color of an object
+      CImgList<tf> primitivesTemp;  // Intermediate CImgList used to update the primitives of the whole object
+
+      if (!cimg::strncasecmp(type,"Box",3)) { // If the object to draw is a box
+        while (cimg::strncasecmp(line,"size",4) && !std::feof(nfile)) // We are looking for the size of the box
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+        if (std::feof(nfile)) { // If no size is specified
+          if (!file) cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : size of box not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        float X = 0, Y = 0, Z = 0; // The width, height and depth of the box
+        if ((err = std::sscanf(line,"size %f %f %f[^\n] ",&X,&Y,&Z))!=3 &&
+            (err = std::sscanf(line,"size %f,%f,%f[^\n] ",&X,&Y,&Z))!=3) {
+          if (!file) cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : Failed to read box size in file '%s'.",
+                                cimg_instance,filename?filename:"(FILE*)");
+        }
+        // We generate the primitives and the points of the box
+        const CImg<T> pointsTemp = CImg<T>::box3d(primitivesTemp,(T)X,(T)Y,(T)Z);
+
+        nbPrimitives = primitivesTemp.size(); // We save the number of primitives of the object
+
+        if (textureTest) { // If the object has a texture
+          // We put the image used as a texture into a CImg object
+          const CImg<float> texture(textureFile);
+          // We initialize the colorsTextured list
+          colorsTextured.insert(primitivesTemp.size(),CImg<unsigned char>::vector(0,50,250));
+          // We texturize the object
+          pointsTemp.texturize_object3d(primitivesTemp,colorsTextured,texture,coords);
+          nbPrimitives = 0;
+        }
+
+        if(nbPointsTotal) { // If there are already some objects in the scene
+          for (int j=0;j<(int)primitivesTemp.size();j++) {
+            for(int i=0;i<4;i++)
+              // We shift the indices in the primitives to designate the right points
+              primitivesTemp(j).at(i) += (tf)nbPointsTotal;
+          }
+        }
+        primitives.push_back(primitivesTemp); // We add the primitives of the box to the general primitives variable
+        for(int i=0;i<(int)pointsTemp.size()/3;++i) { // We add the points into the temporary list in the right order
+          listePoints.push_back((T)pointsTemp.at(i));
+          listePoints.push_back((T)pointsTemp.at(i + 8));
+          listePoints.push_back((T)pointsTemp.at(i + 16));
+        }
+        nbPointsTotal += pointsTemp.size()/3; // We increase the number of points of the whole object
+      }
+      else if(!cimg::strncasecmp(type,"Sphere",6)) { // If the object to draw is a sphere
+        while(cimg::strncasecmp(line,"radius",6) && !std::feof(nfile))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : radius of sphere not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        float R = 0;
+        if ((err = std::sscanf(line,"radius %f[^\n] ",&R))!=1) { // We get the radius of the sphere
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : Failed to read sphere radius in file '%s'.",
+                                cimg_instance,filename?filename:"(FILE*)");
+        }
+        // Compute the necessary points and primitives for a sphere of radius R
+        const CImg<T> pointsTemp = CImg<T>::sphere3d(primitivesTemp,(T)R);
+        // We get the number of primitives to used on the attribution of a color, in case no specific color is defined
+        nbPrimitives = primitivesTemp.size();
+
+        if(textureTest) { // If the object has a texture
+          // We put the image used as a texture into a CImg object
+          const CImg<float> texture(textureFile);
+          // We initialize the colorsTextured list
+          colorsTextured.insert(primitivesTemp.size(),CImg<unsigned char>::vector(0,50,250));
+          pointsTemp.texturize_object3d(primitivesTemp,colorsTextured,texture,coords); // We texturize the object
+          nbPrimitives = 0; // We set to 0 because there is no color to use
+        }
+
+        if(nbPointsTotal) { // If there are already some objects in the scene
+          for (int j=0;j<(int)primitivesTemp.size();j++) {
+            for(int i=0;i<3;i++)
+              primitivesTemp(j).at(i) += (tf)nbPointsTotal;
+          }
+        }
+
+        primitives.push_back(primitivesTemp);
+        for(int i=0;i<(int)pointsTemp.size()/3;++i) {
+          listePoints.push_back((T)pointsTemp.at(i));
+          listePoints.push_back((T)pointsTemp.at(i + pointsTemp.size()/3));
+          listePoints.push_back((T)pointsTemp.at(i + 2*pointsTemp.size()/3));
+        }
+        nbPointsTotal += pointsTemp.size()/3;
+      }
+      else if(!cimg::strncasecmp(type,"Cone",4)) { // If the object to draw is a cone
+        while(cimg::strncasecmp(line,"bottomRadius",12) && !std::feof(nfile) && cimg::strncasecmp(line,"height",6))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        float R = 0, H = 0;
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : bottom radius and height of cone not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+        else if(!cimg::strncasecmp(line,"bottomRadius",12)) { // We find the bottom radius of the cone first
+          if ((err = std::sscanf(line,"bottomRadius %f[^\n] ",&R))!=1) { // We get the radius into the variable R
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cone bottomRadius in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+          while(!std::feof(nfile) && cimg::strncasecmp(line,"height",6)) // We look for the height of the cone
+            err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+          if(std::feof(nfile)) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : height of cone not defined in file '%s'.",
+                                  cimg_instance, filename?filename:"(FILE*)");
+          }
+
+          if ((err = std::sscanf(line,"height %f[^\n] ",&H))!=1) { // We get the height into the variable H
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cone height in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+        }
+        else { // We find the height of the cone first
+          if ((err = std::sscanf(line,"height %f[^\n] ",&H))!=1) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cone height in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+          while(!std::feof(nfile) && cimg::strncasecmp(line,"bottomRadius",12))
+            err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+          if(std::feof(nfile)) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : bottom radius of cone not defined in file '%s'.",
+                                  cimg_instance, filename?filename:"(FILE*)");
+          }
+
+          if ((err = std::sscanf(line,"bottomRadius %f[^\n] ",&R))!=1) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cone bottom radius in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+        }
+        // Compute the necessary points and primitives for a cone of radius R and height H
+        const CImg<T> pointsTemp = CImg<T>::cone3d(primitivesTemp,(T)R,(T)H);
+
+        nbPrimitives = primitivesTemp.size();
+
+        if(textureTest) { // If the object has a texture
+          // We put the image used as a texture into a CImg object
+          const CImg<float> texture(textureFile);
+          // We initialize the colorsTextured list
+          colorsTextured.insert(primitivesTemp.size(),CImg<unsigned char>::vector(0,50,250));
+          pointsTemp.texturize_object3d(primitivesTemp,colorsTextured,texture,coords); // We texturize the object
+          nbPrimitives = 0;
+        }
+
+        if(nbPointsTotal) {
+          for (int j=0;j<(int)primitivesTemp.size();j++) {
+            for(int i=0;i<3;i++)
+              primitivesTemp(j).at(i) += (tf)nbPointsTotal;
+          }
+        }
+
+        primitives.push_back(primitivesTemp);
+        for(int i=0;i<(int)pointsTemp.size()/3;++i) {
+          listePoints.push_back((T)pointsTemp.at(i));
+          listePoints.push_back((T)pointsTemp.at(i + pointsTemp.size()/3));
+          listePoints.push_back((T)pointsTemp.at(i + 2*pointsTemp.size()/3));
+        }
+        nbPointsTotal += pointsTemp.size()/3;
+      }
+      else if(!cimg::strncasecmp(type,"Cylinder",8)) { // If the object to draw is a cylinder
+        while(cimg::strncasecmp(line,"radius",6) && !std::feof(nfile) && cimg::strncasecmp(line,"height",6))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        float R = 0, H = 0;
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : radius or height of cylinder not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+        else if(!cimg::strncasecmp(line,"radius",6)) { // If we find the radius first
+          if ((err = std::sscanf(line,"radius %f[^\n] ",&R))!=1) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cylinder radius in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+          while(!std::feof(nfile) && cimg::strncasecmp(line,"height",6)) // We now look for the height of the cylinder
+            err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+          if(std::feof(nfile)) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : height of cylinder not defined in file '%s'.",
+                                  cimg_instance, filename?filename:"(FILE*)");
+          }
+
+          if ((err = std::sscanf(line,"height %f[^\n] ",&H))!=1) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cylinder height in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+        }
+        else { // If we find the height first
+          if ((err = std::sscanf(line,"height %f[^\n] ",&H))!=1) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cylinder height in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+          while(!std::feof(nfile) && cimg::strncasecmp(line,"radius",6))// We now look for the radius of the cylinder
+            err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+          if(std::feof(nfile)) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : radius of cylinder not defined in file '%s'.",
+                                  cimg_instance, filename?filename:"(FILE*)");
+          }
+
+          if ((err = std::sscanf(line,"radius %f[^\n] ",&R))!=1) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : Failed to read cylinder radius in file '%s'.",
+                                  cimg_instance,filename?filename:"(FILE*)");
+          }
+        }
+        // Compute the necessary points and primitives for a cylinder of radius R and height H
+        const CImg<T> pointsTemp = CImg<T>::cylinder3d(primitivesTemp,(T)R,(T)H);
+
+        if(textureTest) { // If the object has a texture
+          // We put the image used as a texture into a CImg object
+          const CImg<float> texture(textureFile);
+          // We initialize the colorsTextured list
+          colorsTextured.insert(primitivesTemp.size(),CImg<unsigned char>::vector(0,50,250));
+          pointsTemp.texturize_object3d(primitivesTemp,colorsTextured,texture,coords); // We texturize the object
+          nbPrimitives = 0;
+        }
+
+        nbPrimitives = primitivesTemp.size();
+
+        if(nbPointsTotal) {
+          for (int j=0;j<(int)primitivesTemp.size();j++) {
+            for(int i=0;i<3;i++)
+              primitivesTemp(j).at(i) += (tf)nbPointsTotal;
+          }
+        }
+
+        primitives.push_back(primitivesTemp);
+        for(int i=0;i<(int)pointsTemp.size()/3;++i) {
+          listePoints.push_back((T)pointsTemp.at(i));
+          listePoints.push_back((T)pointsTemp.at(i + pointsTemp.size()/3));
+          listePoints.push_back((T)pointsTemp.at(i + 2*pointsTemp.size()/3));
+        }
+        nbPointsTotal += pointsTemp.size()/3;
+      }
+      else if(!cimg::strncasecmp(type,"PointSet",8)) { // If the object to draw is a set of points
+        while(cimg::strncasecmp(line,"point [",7) && !std::feof(nfile))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : points of pointSet node not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        err = std::fscanf(nfile,"%1023[^\n] ",line);
+        int nbPoints = 0;
+
+        while(cimg::strncasecmp(line,"]",1) && !std::feof(nfile)) {
+          // while we did not get all the points and while we are not at the end of the file
+          float X = 0, Y = 0, Z = 0;
+          if ((err = std::sscanf(line,"%f %f %f,[^\n] ",&X,&Y,&Z))==3 ||
+              (err = std::sscanf(line,"%f,%f,%f,[^\n] ",&X,&Y,&Z))==3) {
+            // We get the coordinates of all the points and store them into a list of points
+            listePoints.push_back((T)X);
+            listePoints.push_back((T)Y);
+            listePoints.push_back((T)Z);
+            ++nbPoints;
+          }
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        }
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : bad structure of pointSet node in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+        primitivesTemp.assign();
+
+        for(int i=0;i<nbPoints;++i) { // The primitive is only composed of the indice of the point itself
+          CImg<tf> temp(1,1,1,1,(tf)i);
+          primitivesTemp.push_back(temp);
+        }
+
+        if(nbPointsTotal) {
+          for (int j=0;j<(int)primitivesTemp.size();j++) {
+            for(int i=0;i<(int)primitivesTemp(j).size();i++)
+              primitivesTemp(j).at(i) += (tf)nbPointsTotal;
+          }
+        }
+        nbPrimitives = primitivesTemp.size();
+
+        primitives.push_back(primitivesTemp);
+
+        nbPointsTotal += nbPoints;
+      }
+      else if(!cimg::strncasecmp(type,"IndexedLineSet",14) ||
+              !cimg::strncasecmp(type,"IndexedFaceSet",14)) {
+        // If the object to draw is a set of lines or a set of faces
+        while(cimg::strncasecmp(line,"point [",7) && !std::feof(nfile))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : points of IndexedSet node not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        err = std::fscanf(nfile,"%1023[^\n] ",line);
+        int nbPoints = 0;
+        while(cimg::strncasecmp(line,"]",1) && !std::feof(nfile)) {
+          // As long as there are points defined we add them to the list
+          float X=0,Y=0,Z=0;
+          if ((err = std::sscanf(line,"%f %f %f,[^\n] ",&X,&Y,&Z))==3 ||
+              (err = std::sscanf(line,"%f,%f,%f,[^\n] ",&X,&Y,&Z))==3) {
+            // We get the coordinates of the points into a list of points
+            listePoints.push_back((T)X);
+            listePoints.push_back((T)Y);
+            listePoints.push_back((T)Z);
+            ++nbPoints;
+          }
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        }
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : bad structure of point vector node in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        primitivesTemp.assign();
+
+        while(cimg::strncasecmp(line,"coordIndex [",12) && !std::feof(nfile))
+          // We are looking for the index of the points
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : coordIndex not furnished for IndexedSet node in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        err = std::fscanf(nfile,"%1023[^\n] ",line);
+
+        while(cimg::strncasecmp(line,"]",1) && !std::feof(nfile)) { // As long as there are indices
+          if(*line!='#') {
+            std::vector<tf> primitiveComponents;
+            char * pch;
+            pch = std::strtok (line,",");
+
+            while (pch != NULL && std::atof(pch)!=-1) { // We extract the list of indices and store them into a vector
+              if(!(int)count(primitiveComponents.begin(),primitiveComponents.end(),(tf)std::atof(pch)))
+                primitiveComponents.push_back((tf)std::atof(pch));
+              pch = std::strtok (NULL, ",");
+            }
+            CImg<tf> temp(1,primitiveComponents.size(),1,1);
+
+            for(int i=0;i<(int)primitiveComponents.size();++i)
+              temp(0,i) = primitiveComponents.at(i);
+            primitivesTemp.push_back(temp);
+          }
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        }
+
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : bad structure of coordIndex in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+
+        if(nbPointsTotal) {
+          for (int j=0;j<(int)primitivesTemp.size();j++) {
+            for(int i=0;i<(int)primitivesTemp(j).size();i++)
+              primitivesTemp(j).at(i) += (tf)nbPointsTotal;
+          }
+        }
+
+        nbPrimitives = primitivesTemp.size();
+        primitives.push_back(primitivesTemp);
+        nbPointsTotal += nbPoints;
+
+        while(cimg::strncasecmp(line,"color [",7) && cimg::strncasecmp(line,"}",1) && !std::feof(nfile))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : bad structure of coordIndex in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+        else if(!cimg::strncasecmp(line,"color [",7)) { // If there are different colors defined for each faces
+          multipleColors = true;
+          std::vector<CImg<tc> > listColors;
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+          while(cimg::strncasecmp(line,"]",1) && !std::feof(nfile)) {
+            // We add the list of all colors defined into the vector listColors
+            if(*line!='#') {
+              if ((err = std::sscanf(line,"%f %f %f[^\n] ",&r,&g,&b))!=3) {
+                if (!file)
+                  cimg::fclose(nfile);
+                throw CImgIOException(_cimg_instance
+                                      "load_vrml() : wrong number of color furnished in file '%s'.",
+                                      cimg_instance,filename?filename:"(FILE*)");
+              }
+              CImg<tc> img(3,1,1,1,(tc)(r*255),(tc)(g*255),(tc)(b*255));
+              listColors.push_back(img);
+            }
+            err = std::fscanf(nfile,"%1023[^\n] ",line);
+          }
+          if(std::feof(nfile)) {
+            if (!file)
+              cimg::fclose(nfile);
+            throw CImgIOException(_cimg_instance
+                                  "load_vrml() : bad structure of color in file '%s'.",
+                                  cimg_instance, filename?filename:"(FILE*)");
+          }
+          else {
+            while(cimg::strncasecmp(line,"colorIndex [",12) && !std::feof(nfile))
+              err = std::fscanf(nfile,"%1023[^\n] ",line);
+            if(std::feof(nfile)) {
+              if (!file)
+                cimg::fclose(nfile);
+              throw CImgIOException(_cimg_instance
+                                    "load_vrml() : colorIndex not furnished for Color node in file '%s'.",
+                                    cimg_instance, filename?filename:"(FILE*)");
+            }
+            err = std::fscanf(nfile,"%1023[^\n] ",line);
+            while(cimg::strncasecmp(line,"]",1) && !std::feof(nfile)) {
+              // We add the colors at the right index into the vector colors
+              if(*line!='#') {
+                char * pch;
+                pch = std::strtok (line," ");
+                while (pch != NULL) {
+                  int indice = std::atoi(pch);
+                  colors.insert(CImg<tc>::vector((tc)(listColors[indice])[0],
+                                                 (tc)(listColors[indice])[1],
+                                                 (tc)(listColors[indice])[2]));
+                  pch = std::strtok (NULL, " ");
+                }
+              }
+              err = std::fscanf(nfile,"%1023[^\n] ",line);
+            }
+          }
+        }
+      }
+      else // If none of the known type of shape is defined
+        cimg::warn(_cimg_instance
+                   "load_vrml() : Failed to read type of geometry to draw from file '%s'.",
+                   cimg_instance,filename?filename:"(FILE*)");
+
+      if(textureTest) { // If the object considered is texturized
+        colors.push_back(colorsTextured);
+        *textureFile = 0;
+      }
+      while(cimg::strncasecmp(line,"appearance",10) &&
+            cimg::strncasecmp(line,"Shape",5) && !std::feof(nfile))
+        // We look for the node appearance or for another shape
+        err = std::fscanf(nfile,"%1023[^\n] ",line);
+    }
+    if(!cimg::strncasecmp(line,"appearance",10)) { // We are at the appearance node
+      while(cimg::strncasecmp(line,"texture ImageTexture",20) &&
+            cimg::strncasecmp(line,"diffuseColor",12) && !std::feof(nfile))
+        // We are looking for a valid appearance node
+        err = std::fscanf(nfile,"%1023[^\n] ",line);
+      if(!cimg::strncasecmp(line,"diffuseColor",12)) { // If the object as a unique diffuse color
+        if ((err = std::sscanf(line,"diffuseColor %f,%f,%f[^\n] ",&r,&g,&b))!=3 &&
+            (err = std::sscanf(line,"diffuseColor %f %f %f[^\n] ",&r,&g,&b))!=3) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : wrong number of color furnished in file '%s'.",
+                                cimg_instance,filename?filename:"(FILE*)");
+        }
+      }
+      else if(!cimg::strncasecmp(line,"texture ImageTexture",20)) { // If there is a texture defined in the VRML file
+        textureTest = true;
+        colorDefined = false;
+        while(cimg::strncasecmp(line,"url",3) && !std::feof(nfile))
+          err = std::fscanf(nfile,"%1023[^\n] ",line);
+        if(std::feof(nfile)) {
+          if (!file)
+            cimg::fclose(nfile);
+          throw CImgIOException(_cimg_instance
+                                "load_vrml() : texture not defined in file '%s'.",
+                                cimg_instance, filename?filename:"(FILE*)");
+        }
+        // We temporary put the name of the texture image into textureFileTemp
+        std::sscanf(line,"url [%s][^\n] ",textureFileTemp);
+        char * pch;
+        pch = std::strtok (textureFileTemp,"\"");
+        strcpy(textureFile,pch); // We put the url of the texture image into textureFile
+      }
+    }
+    else if(!cimg::strncasecmp(line,"Shape",5)) // We have another shape node
+      textureTest = false; // We reinitialize the texture boolean
+
+    if(nbPrimitives && colorDefined && !multipleColors && !textureTest) {
+      // If there is only one color defined we add it to the colors CImgList or if no color
+      // is defined for an object, we add the default color
+      CImgList<tc> colorsTemp;
+      colorsTemp.insert(nbPrimitives,CImg<tc>::vector((tc)(r*255),(tc)(g*255),(tc)(b*255)));
+      colors.push_back(colorsTemp);
+      nbPrimitives = 0;
+      r = 0.7f;
+      g = 0.7f;
+      b = 0.7f;
+    }
+    err = std::fscanf(nfile,"%1023[^\n] ",line);
+  }
+
+  assign(listePoints.size()/3,3);
+  cimg_forX(*this,l) { // We add the points coordinates to the calling object
+    (*this)(l,0) = (T)(listePoints.at(l*3));
+    (*this)(l,1) = (T)(listePoints.at(l*3 + 1));
+    (*this)(l,2) = (T)(listePoints.at(l*3 + 2));
+  }
+
+  if (!file)
+    cimg::fclose(nfile);
+
+  return *this;
+}
+
+//! Save VRML files.
+template<typename tf, typename tc>
+const CImg<T>& save_vrml(const char *const filename,const CImgList<tf>& primitives,
+                         const CImgList<tc>& colors, const char *const texturefile = 0) const {
+  return _save_vrml(0,filename,primitives,colors,texturefile);
+}
+
+//! Save VRML files.
+template<typename tf, typename tc>
+const CImg<T>& save_vrml(std::FILE *const file,const CImgList<tf>& primitives,
+                         const CImgList<tc>& colors, const char *const texturefile = 0) const {
+  return _save_vrml(file,0,primitives,colors,texturefile);
+}
+
+// Save VRML files (internal).
+template<typename tf, typename tc>
+const CImg<T>& _save_vrml(std::FILE *const file, const char *const filename, const CImgList<tf>& primitives,
+                          const CImgList<tc>& colors, const char *const texturefile) const {
+
+  // Check that the user furnished a file to save the object and that the object is not empty.
+  if (!file && !filename)
+    throw CImgArgumentException(_cimg_instance
+                                "save_vrml() : Specified filename is (null).",
+                                cimg_instance);
+  if (is_empty())
+    throw CImgInstanceException(_cimg_instance
+                                "save_vrml() : Empty instance, for file '%s'.",
+                                cimg_instance,filename?filename:"(FILE*)");
+
+  // Check that the object we want to save is a 3D object.
+  CImgList<T> opacities;
+  char error_message[1024] = {0};
+  if (!is_object3d(primitives,colors,opacities,true,error_message))
+    throw CImgInstanceException(_cimg_instance
+                                "save_vrml() : Invalid specified 3d object, for file '%s' (%s).",
+                                cimg_instance,filename?filename:"(FILE*)",error_message);
+  const CImg<tc> default_color(1,3,1,1,200);
+
+  // We open the file in which we will save the 3D object.
+  std::FILE * nfile;
+  if(file) nfile = file;
+  else nfile = cimg::fopen(filename,"w");
+
+  // We use the version 2.0 of VRML to represent the object in UTF8
+  std::fprintf(nfile,"#VRML V2.0 utf8\n");
+
+  // We copy the coordinates of all the points
+  std::fprintf(nfile,"Shape {\n\tgeometry IndexedFaceSet {\n\t\tcoord Coordinate {\n\t\t\tpoint [\n");
+  cimg_forX(*this,i)
+    std::fprintf(nfile,"\t\t\t\t%f %f %f,\n",(float)((*this)(i,0)),(float)((*this)(i,1)),(float)((*this)(i,2)));
+  std::fprintf(nfile,"\t\t\t]\n\t\t}\n\t\tcoordIndex [\n");
+  bool sameColor = true;
+
+  float r = colors[0][0]/255.0f;
+  float g = colors[0][1]/255.0f;
+  float b = colors[0][2]/255.0f;
+
+  std::vector<std::string> listColor;
+  std::string listColorPerFace("");
+  for(int i=0;i<(int)colors.size();++i) {// Test if the object is composed of only one color
+    float valR = (colors[i][0])/255.0f;
+    float valG = (colors[i][1])/255.0f;
+    float valB = (colors[i][2])/255.0f;
+
+    if (r!=valR || g!=valG || b!=valB) { // If the object has different colors
+      sameColor = false;
+      i = colors.size();
+    }
+  }
+
+  cimglist_for(primitives,l) { // For each primitive
+    const CImg<tc>& color = l<colors.width()?colors[l]:default_color;
+    const unsigned int psiz = primitives[l].size(), csiz = color.size();
+    float r = color[0]/255.0f;
+    float g, b;
+    if (csiz > 1) g = color[1]/255.0f;
+    else g = r/255.0f;
+    if (csiz > 2) b = color[2]/255.0f;
+    else b = g/255.0f;
+
+    switch (psiz) {
+    case 1 :
+      std::fprintf(nfile,"\t\t\t%u,-1\n",(unsigned int)primitives(l,0));
+      break;
+    case 2 :
+      std::fprintf(nfile,"\t\t\t%u,%u,-1\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,1));
+      break;
+    case 3 :
+      std::fprintf(nfile,"\t\t\t%u,%u,%u,-1\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,2),
+                   (unsigned int)primitives(l,1));
+      break;
+    case 4 :
+      std::fprintf(nfile,"\t\t\t%u,%u,%u,%u,-1\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,3),
+                   (unsigned int)primitives(l,2),(unsigned int)primitives(l,1));
+      break;
+    case 6 : {
+      const unsigned int xt = (unsigned int)primitives(l,2), yt = (unsigned int)primitives(l,3);
+      r = color.atXY(xt,yt,0)/255.0f;
+      g = (csiz>1?color.atXY(xt,yt,1):r)/255.0f;
+      b = (csiz>2?color.atXY(xt,yt,2):g)/255.0f;
+      std::fprintf(nfile,"\t\t\t%u,%u,-1\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,1));
+    } break;
+    case 9 : {
+      const unsigned int xt = (unsigned int)primitives(l,3), yt = (unsigned int)primitives(l,4);
+      r = color.atXY(xt,yt,0)/255.0f;
+      g = (csiz>1?color.atXY(xt,yt,1):r)/255.0f;
+      b = (csiz>2?color.atXY(xt,yt,2):g)/255.0f;
+      std::fprintf(nfile,"\t\t\t%u,%u,%u,-1\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,2),
+                   (unsigned int)primitives(l,1));
+    } break;
+    case 12 : {
+      const unsigned int xt = (unsigned int)primitives(l,4), yt = (unsigned int)primitives(l,5);
+      r = color.atXY(xt,yt,0)/255.0f;
+      g = (csiz>1?color.atXY(xt,yt,1):r)/255.0f;
+      b = (csiz>2?color.atXY(xt,yt,2):g)/255.0f;
+      std::fprintf(nfile,"\t\t\t%u,%u,%u,%u,-1\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,3),
+                   (unsigned int)primitives(l,2),(unsigned int)primitives(l,1));
+    } break;
+    }
+    if (!sameColor) { // If there are different colors we store on every loop the RGB values into the vector listColor
+      std::ostringstream oss;
+      oss << r << " " << g << " " << b << "\n";
+      if (listColor.size() == 0) {
+        listColor.push_back(oss.str());
+        listColorPerFace += "0"; // We store the indice of the color
+      }
+      else {
+        std::vector<std::string>::iterator it;
+        it = find (listColor.begin(), listColor.end(), oss.str());
+        std::ostringstream oss2;
+        if(it==listColor.end()) {
+          oss2 << " " << listColor.size();
+          listColorPerFace += oss2.str();
+          listColor.push_back(oss.str());
+        }
+        else {
+          int n = 0;
+          for (std::vector<std::string>::iterator iter = listColor.begin(); iter != it; iter++) ++n;
+          oss2 << " " << n;
+          listColorPerFace += oss2.str();
+        }
+      }
+    }
+  }
+  std::fprintf(nfile,"\t\t]\n");
+
+  if (texturefile) // If we have a texture instead of a color
+    std::fprintf(nfile,"\n\t}\n\tappearance DEF theTexture Appearance "
+                 "{\n\t\ttexture ImageTexture {\n\t\t\turl [\"%s\"]\n\t\t}\n\t}\n}",
+                 texturefile);
+  else {
+    if(!sameColor) { // If there are different colors we add all of them
+      std::fprintf(nfile,"\tcolorPerVertex FALSE\n\tcolor Color {\n\t\tcolor [\n");
+      while(!listColor.empty()) {
+        std::fprintf(nfile,"\t\t\t%s",(listColor.back()).c_str());
+        listColor.pop_back();
+      }
+      std::fprintf(nfile,"\t\t]\n\t}\n\tcolorIndex [\n\t\t");
+      std::fprintf(nfile,"%s",listColorPerFace.c_str());
+      std::fprintf(nfile,"\n\t]\n\t}\n}");
+    }
+    else { // If there is only one color we add it with the Material node
+      std::fprintf(nfile,"\t}\n\tappearance Appearance "
+                   "{\n\t\tmaterial Material {\n\t\t\tdiffuseColor %f,%f,%f\n\t\t}\n\t}\n}",
+                   colors[0][0]/255.0f,colors[0][1]/255.0f,colors[0][2]/255.0f);
+    }
+  }
+  if (!file) cimg::fclose(nfile);
+  return *this;
+}
+
+#endif /* cimg_plugin_vrml */