Xargon/ES-DE
1
0
Fork 0
mirror of https://github.com/RetroDECK/ES-DE.git synced 2024-11-23 22:55:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ES-DE/external/CImg/plugins/vrml.h

895 lines
40 KiB
C++
Raw Blame History

/*
#
# 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 */
Reference in a new issue View git blame Copy permalink