vcglib/wrap/io_trimesh/export_off.h

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program is free software; you can redistribute it and/or modify      *   
* it under the terms of the GNU General Public License as published by      *
* the Free Software Foundation; either version 2 of the License, or         *
* (at your option) any later version.                                       *
*                                                                           *
* This program is distributed in the hope that it will be useful,           *
* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/

/**
@name Save in OFF format
*/
//@{

#ifndef __VCGLIB_EXPORT_OFF
#define __VCGLIB_EXPORT_OFF

#include <stdio.h>
#include <wrap/io_trimesh/io_mask.h>


namespace vcg {
	namespace tri {
		namespace io {
			template <class SaveMeshType>
			class ExporterOFF
			{

			public:
				typedef typename SaveMeshType::VertexPointer VertexPointer;
				typedef typename SaveMeshType::ScalarType ScalarType;
				typedef typename SaveMeshType::VertexType VertexType;
				typedef typename SaveMeshType::FaceType FaceType;
				typedef typename SaveMeshType::FacePointer FacePointer;
				typedef typename SaveMeshType::VertexIterator VertexIterator;
				typedef typename SaveMeshType::FaceIterator FaceIterator;

				static int Save(SaveMeshType &m, const char * filename, int mask=0 )
				{
					vcg::face::Pos<FaceType> he;
					vcg::face::Pos<FaceType> hei;
					FILE * fpout = fopen(filename,"w");
					if(fpout==NULL)	return false;



					if( m.HasPerVertexNormal()  && (mask & io::Mask::IOM_VERTNORMAL)) 	fprintf(fpout,"N");
					if( m.HasPerVertexColor()   && (mask & io::Mask::IOM_VERTCOLOR))		fprintf(fpout,"C");
					if( m.HasPerVertexTexture() && (mask & io::Mask::IOM_VERTTEXCOORD))	fprintf(fpout,"ST");
					fprintf(fpout,"OFF\n");
					fprintf(fpout,"%d %d 0", m.vn, m.fn);
          typename SaveMeshType::FaceIterator fi;
					
					// USeless portio of code that try tocomput the exact number of edges. 
          // OFF usually has a 0 as edge number.
          //
          //int count_e = 0;
					//int boundary_e = 0;
					//bool counted=false;
					//for(fi=m.face.begin();fi!=m.face.end();++fi)
					//	(*fi).ClearS();

					//for(fi=m.face.begin();fi!=m.face.end();fi++)
					//{
					//	(*fi).SetS();
					//	count_e +=3;								//assume that we have to increase the number of edges with three
					//	for(int j=0; j<3; j++)
					//	{
					//		if (face::IsBorder(*fi,j))			//If this edge is a border edge
					//			boundary_e++;						//  then increase the number of boundary edges
     //         else if (face::IsManifold(*fi,j))		//If this edge is manifold
					//		{
					//			if((*fi).FFp(j)->IsS()) //If the face on the other side of the edge is already selected
					//				count_e--;						//  we counted one edge twice
					//		}
					//		else											//We have a non-manifold edge
					//		{
					//			hei.Set(&(*fi), j , fi->V(j));
					//			he=hei;
					//			he.NextF();
					//			while (he.f!=hei.f)			//	so we have to iterated all faces that are connected to this edge
					//			{
					//				if (he.f->IsS()){			//  if one of the other faces was already visited than this edge was counted already.
					//					counted=true;
					//					break;
					//				}	else { he.NextF();	}
					//			}
					//			if (counted) {
					//				count_e--;
					//				counted=false;
					//			}
					//		}
					//	}
					//}	
					//fprintf(fpout,"%d\n", count_e);

					//vertices
					int j;
					std::vector<int> FlagV; 
					VertexPointer  vp;
					VertexIterator vi;
					for(j=0,vi=m.vert.begin();vi!=m.vert.end();++vi)
					{
						vp=&(*vi);
						FlagV.push_back(vp->UberFlags()); // Salva in ogni caso flag del vertice
						if( ! vp->IsD() )
						{	// ***** ASCII *****

							fprintf(fpout,"%g %g %g\n" ,vp->P()[0],vp->P()[1],vp->P()[2]);
							if( m.HasPerVertexColor()  && (mask & io::Mask::IOM_VERTCOLOR) )
								fprintf(fpout,"%d %d %d %d\n",vp->C()[0],vp->C()[1],vp->C()[2],vp->C()[3] );

							if( m.HasPerVertexNormal()  && (mask & io::Mask::IOM_VERTNORMAL) )
								fprintf(fpout,"%g %g %g\n", vp->N()[0],vp->N()[1],vp->N()[2]);

							if( m.HasPerVertexTexture()  && (mask & io::Mask::IOM_VERTTEXCOORD) )
								fprintf(fpout,"%g %g\n",vp->T().u(),vp->T().v());
						}

						vp->UberFlags()=j; // Trucco! Nascondi nei flags l'indice del vertice non deletato!
						j++;
					}

					FacePointer fp;
//					int vv[3];

					int fcnt=0;
					for(j=0,fi=m.face.begin();fi!=m.face.end();++fi)
					{
						fp=&(*fi);
						if( ! fp->IsD() )
						{ fcnt++;


						fprintf(fpout,"3 %d %d %d\n",
							fp->cV(0)->UberFlags(),	fp->cV(1)->UberFlags(), fp->cV(2)->UberFlags() );
						}
					}


					fclose(fpout);
					// Recupera i flag originali
					for(j=0,vi=m.vert.begin();vi!=m.vert.end();++vi)
						(*vi).UberFlags()=FlagV[j++]; 

					return 0;
				}

        static const char *ErrorMsg(int error)
        {
          static std::vector<std::string> off_error_msg;
          if(off_error_msg.empty())
          {
            off_error_msg.resize(2 );
            off_error_msg[0]="No errors";
	          off_error_msg[1]="Can't open file";
            }

          if(error>1 || error<0) return "Unknown error";
          else return off_error_msg[error].c_str();
        }
        /*
	        returns mask of capability one define with what are the saveable information of the format.
        */
        static int GetExportMaskCapability()
        {
	        int capability = 0;			
	        capability |= vcg::tri::io::Mask::IOM_VERTCOORD;
	        capability |= vcg::tri::io::Mask::IOM_VERTCOLOR;
          capability |= vcg::tri::io::Mask::IOM_FACEINDEX;
	        return capability;
        }

			}; // end class
		} // end namespace tri
	} // end namespace io
} // end namespace vcg
//@}
#endif