SoSceneWriter.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef SO_SCENE_WRITER_H
#define SO_SCENE_WRITER_H
 
 
 
#include "SoUtilsSystem.h"
#include <ThirdPartyWarningsDisable.h>
#include <Inventor/SoPrimitiveVertex.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/nodes/SoShape.h>
#include <Inventor/fields/SoFields.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/engines/SoSubEngine.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <Inventor/sensors/SoNodeSensor.h>
#include <boost/unordered_map.hpp>
#include <ThirdPartyWarningsRestore.h>
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
#ifdef WIN32
#pragma warning(disable : 4018 )
 
#endif
 
#include <vector>
#include <algorithm>
 
 
//--------------------------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------------------------
class SoSceneWriter : public SoEngine
{
  SO_ENGINE_HEADER(SoSceneWriter);
 
public:
#ifdef TGSOIV
  enum Format {
      INVENTOR_ASCII = 0,
      INVENTOR_BINARY,
      VRML_1,
      VRML_2,
      STL_ASCII,
      STL_BINARY,
      Z3D
  };
#else
  enum Format {
      INVENTOR_ASCII = 0,
      INVENTOR_BINARY,
      STL_ASCII,
      STL_BINARY,
      VRML_97
  };
 
  enum SoPrimitive {
      LINE     = 2,
      TRIANGLE = 3
  };
#endif
 
  SoSceneWriter();
 
  struct COLORED_POINT{
    SbVec3f coord;
    SbVec3f normal; // normal is only used if collecting / writing triangle information
    SbColor color;
    float   shininess;
    float   transparency;
    bool operator ==(const COLORED_POINT& cp) const
    {
      return (cp.coord == coord) &&
             (cp.color == color) &&
             (cp.normal == normal) &&
             (cp.shininess == shininess) &&
             (cp.transparency == transparency);
    }
  };
 
 
  struct hashColoredPoint
  {
    inline size_t operator()(const COLORED_POINT& cp) const
    {
      size_t seed = 0;
 
      for (int i = 0; i < 3; ++i) {
        boost::hash_combine(seed, cp.coord[i]);
        boost::hash_combine(seed, cp.normal[i]);
        boost::hash_combine(seed, cp.color[i]);
      }
      boost::hash_combine(seed, cp.shininess);
      boost::hash_combine(seed, cp.transparency);
 
      return seed;
    }
  };
 
 
 
 
  SoSFNode     sceneGraph;
  SoSFTrigger  save;
  SoSFString   filename;
  SoSFEnum     format;
 
#ifndef TGSOIV
 
  SoSFBool      bColorPerVertex;
 
  SoSFBool      bUseGlobalColor;
 
  SoSFBool      bNormalPerVertex;
 
  SoSFBool      bSaveNormals;
#endif
 
 
  static void initClass();
 
  void saveChanged();
  static void saveChangedCB(void *data, SoSensor* a);
 
  void inputChanged(SoField * /*whichField*/) override {};
  void evaluate() override {};
 
protected:
  ~SoSceneWriter() override;
 
  void formatFileExtension();
 
#ifndef TGSOIV
  void writeSimpleVRML2();
#endif
 
 
 
  void writeVecToStlFile    (SoMFVec3f *pMVec3f);
 
 
  SbVec3f const getNormal   (const SbVec3f *pVec, const int nIdx);
 
public:
  static void getTriIn(void *pData, SoCallbackAction *pAct, const SoPrimitiveVertex *pV1, const SoPrimitiveVertex *pV2,const SoPrimitiveVertex *pV3);
 
 
private:
    SoFieldSensor*  _saveSensor;
 
 
#ifndef TGSOIV
    SbMatrix _wTransMat;
    SbMatrix _wInverseTransposedMat;
    unsigned int _currentDrawStyle;
    unsigned int _currentVertexOrdering;
 
 
    void _writeVRML2Header(std::ofstream& outFile);
    void _writeVRML2PointSet(std::ofstream& outFile);
    void _writeVRML2LineSet(std::ofstream& outFile);
    void _writeVRML2FaceSet(std::ofstream& outFile);
 
    int _vecToStr(const SbVec3f& vec, char* buf, size_t numEntries=0, size_t currNum=0);
    int _vecToStr(const SbColor& col, char* buf, size_t numEntries=0, size_t currNum=0);
    void _writeIndices(std::ofstream& outFile, size_t numIndices, size_t posDelim);
    void _writeIndices(std::ofstream& outFile, std::vector<size_t> & indexList, size_t posDelim);
 
    SoCallbackAction* _callbackAction;
 
    static SoCallbackAction::Response preCB(void *userData,
                                            SoCallbackAction *action,
                                            const SoNode *node);
 
    static void pointCB   (void* userData, SoCallbackAction* action,
                           const SoPrimitiveVertex* v);
    static void lineCB    (void* userData, SoCallbackAction* action,
                           const SoPrimitiveVertex* v1,
                           const SoPrimitiveVertex* v2);
    static void triangleCB(void* userData, SoCallbackAction* action,
                           const SoPrimitiveVertex* v1,
                           const SoPrimitiveVertex* v2,
                           const SoPrimitiveVertex* v3);
 
    typedef std::vector<COLORED_POINT> pointsVec;
    typedef std::vector<COLORED_POINT> linesVec;
    typedef std::vector<COLORED_POINT> trianglesVec;
 
 
    std::vector<pointsVec> _points;
    std::vector<linesVec> _lines;
    std::vector<trianglesVec> _triangles;
 
    boost::unordered_map < COLORED_POINT, int, hashColoredPoint > _distinctColoredVertices;
#endif
 
};
 
#endif