SoVectorizeAction.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
#ifndef __SO_VECTORIZE_ACTION_
#define __SO_VECTORIZE_ACTION_
 
 
#include <SbTypes.h>
#include <stdio.h>
#include <Inventor/SbBasic.h>
#include <Inventor/SbColor.h>
#include <Inventor/SbViewportRegion.h>
#include <Inventor/actions/SoAction.h>
#include <Inventor/actions/SoSubAction.h>
#include <Inventor/actions/SoCallbackAction.h>
#include <Inventor/elements/SoAnnoText3RenderPrintElement.h>
#ifndef NO_TGS_OIV
#  include <Inventor/nodes/SoImage.h>
#endif
#include <HardCopy/SoHardCopy.h>
 
 
#define POINT_TO_MM 0.3527777778F
 
#ifndef NO_TGS_OIV
class SoMarkerSet;
#endif
 
class SoNode;
class SoPath;
class SoPathList;
class SoCallbackAction;
class SoPrimitiveVertex;
class SoHLHSRVectorize;
 
class SoVectorOutput;
 
class  SoVectorizeAction : public SoAction {
  
  SO_ACTION_HEADER_WITH_DEF(SoVectorizeAction);
 
 public:
   /*
    * Destructor
    */
   virtual ~SoVectorizeAction();
 
  enum DimensionUnit {
    INCH,  
    MM,    
    METER  
  };
 
  enum ShadeModel {
    FLAT,
 
    SMOOTH
  };
 
  enum Orientation {
    PORTRAIT,   
    LANDSCAPE   
  };
 
  enum ColorTranslationMethod {
    REVERSE_ONLY_BLACK_AND_WHITE,  
    AS_IS,                         
    REVERSE                        
  };
 
  enum JoinLineStyle {
    NO_JOIN,                
    MITERED_JOIN,           
    MITERED_BEVELED_JOIN,   
    BEVELED_JOIN,           
    TRIANGULAR_JOIN,        
    ROUNDED_JOIN            
  };
 
  enum EndLineStyle {
    BUTT_END,
    SQUARE_END,
    TRIANGULAR_END,
    ROUND_END
  };
 
 
  enum HLHSRMode {
    NO_HLHSR,             
    HLHSR_SIMPLE_PAINTER, 
    HLHSR_PAINTER,        
    HLHSR_PAINTER_SURFACE_REMOVAL,
    HLHSR_RASTER,
    HIDDEN_LINES_REMOVAL  
  };
  /*----------------------------------------------------------------------------*/
 
  virtual SoVectorOutput *getVectorOutput() const;
 
  // Apply methods
 
  virtual void apply(SoNode *node);
 
  virtual void apply(SoPath *path);
 
  virtual void apply(const SoPathList &pathList, SbBool obeysRules = FALSE);
 
  virtual void beginPage(const SbVec2f &startPagePosition, 
                         const SbVec2f &pageSize, 
                         DimensionUnit u = MM);
 
  virtual void endPage();
 
  // Drawing parameters initialisation methods
 
  virtual void setDrawingDimensions(float w, float h, DimensionUnit u = MM);
 
  virtual void setDrawingDimensions(const SbVec2f &d, DimensionUnit u = MM);
 
  virtual SbVec2f getDrawingDimensions(DimensionUnit u = MM) const;
 
  virtual void setStartPosition(float x, float y, DimensionUnit u = MM);
 
  virtual void setStartPosition(const SbVec2f &p, DimensionUnit u = MM);
 
  virtual SbVec2f getStartPosition(DimensionUnit u = MM) const;
 
  virtual void setOrientation(Orientation o);
 
  virtual Orientation getOrientation() const;
 
  virtual void setBorder(float width) {
    SbColor color = SbVec3f(1.,1.,1.);
    setBorder(width, color);
  }
 
  virtual void setBorder(float width, SbColor color);
 
  virtual void getBorder(float *w, SbColor *color) const;
 
  virtual void setBackgroundColor(SbBool bg) {
    SbColor color = SbVec3f(0.,0.,0.);
    setBackgroundColor(bg, color);
  }
 
  virtual void setBackgroundColor(SbBool bg, SbColor color);
 
  virtual SbBool getBackgroundColor(SbColor *color) const;
 
  virtual void  setNominalWidth(float w, DimensionUnit u = MM);
 
  virtual float getNominalWidth(DimensionUnit u = MM) const;
 
  virtual void setLinePatternSize(float w, DimensionUnit u = MM);
 
  virtual float getLinePatternSize(DimensionUnit u = MM) const;
 
  virtual void  setPixelImageSize(float w, DimensionUnit u = MM);
 
  virtual float getPixelImageSize(DimensionUnit u = MM) const;
 
  virtual void setColorTranslationMethod(ColorTranslationMethod method);
 
  virtual ColorTranslationMethod getColorTranslationMethod() const;
 
  virtual void setLineEndStyle(EndLineStyle style); 
 
  virtual EndLineStyle getLineEndStyle() const; 
 
  virtual void setLineJoinsStyle(JoinLineStyle style); 
 
  virtual JoinLineStyle getLineJoinsStyle() const;  
 
  virtual void setMiterLimit(float limit);
 
  virtual float getMiterLimit() const;
 
  virtual void setPenDescription(int num_pens, 
                                 const SbColor *colors = 0, 
                                 const float *widths = 0, 
                                 DimensionUnit u = MM);
 
  virtual void getPenDescription(SbColor *colors, 
                                 float *widths, 
                                 DimensionUnit u = MM) const;
 
  virtual int getPenNum() const;
 
  virtual void   setColorPriority(SbBool priority);
 
  virtual SbBool getColorPriority(void) const;
 
  virtual void setHLHSRMode(HLHSRMode mode)
    { m_HLHSRMode = mode; }
 
  HLHSRMode getHLHSRMode() const 
    { return m_HLHSRMode; }
 
 
 
  void setHLHSRRasterQuality(float quality) 
  { m_HLHSRRasterQuality = quality ; }
 
  float getHLHSRRasterQuality() const
  { return m_HLHSRRasterQuality ; }
 
 
  void setHLHSRRasterCaching(SbBool enable)
  { m_HLHSRRasterCaching = enable ; }
 
  SbBool getHLHSRRasterCaching() const
  { return m_HLHSRRasterCaching ; }
 
  virtual void enableLighting(SbBool flag)    
    { m_isLightingEnabled = flag; }  
 
  SbBool isLightingEnabled() const
    { return m_isLightingEnabled; }
 
  void setShadeModel(ShadeModel model) 
  { m_shadeModel = model ; }
 
  ShadeModel getShadeModel() 
  { return m_shadeModel ; }
 
  void setPolygonOffset( float offset )
    { m_polyOffset = offset; }
  void setLineOffset( float offset )
    { m_lineOffset = offset; }
  void setMarkerOffset( float offset )
    { m_markOffset = offset; }
  float getPolygonOffset() const
    { return m_polyOffset; }
  float getLineOffset() const
    { return m_lineOffset; }
  float getMarkerOffset() const
    { return m_markOffset; }
 
 private:
 
 
  void setHLHSRRasterTileSize(unsigned short tileSize) 
  { m_HLHSRRasterTileSize = tileSize ; }
 
  unsigned short getHLHSRRasterTileSize() const
  { return m_HLHSRRasterTileSize ; }
 
  static void initClass();
  static void exitClass();
 
  /*----------------------------------------------------------------------------*/
 private:
  SoVectorizeAction();
 
  // Output data
  SoVectorOutput *m_output;
 
  // Begin and end of traversal
  virtual void beginTraversal();
  virtual void beginTraversal(SoNode *)
    { beginTraversal(); }
  virtual void endTraversal();
  virtual void endTraversal(SoNode *)
    { endTraversal(); }
 
  virtual void writeHeader() = 0;
  virtual void writeFooter() = 0;
  
  virtual void setHardwareClip() = 0;
 
  // Compute clipping limits
  virtual SbBox2f getClippingLimits() const;
 
  // Printing methods
  virtual void printPolyMark(const SbVec4f *points, 
                             int num_points, 
                             const SbColor *colors, 
                             SbBool color_flag, 
                             float size);
#ifndef NO_TGS_OIV
  virtual void printPolyMark(const SbVec4f *points, 
                             int num_points, 
                             const SbColor *colors, 
                             SbBool color_flag,
                             SoMarkerSet *markerSet);
  virtual void printImage(const SbVec4f &origin, 
                          const unsigned char *imagePixels, 
                          SbVec2s &sourceSize, 
                          SbVec2s &requestedSize, 
                          int numComponents,
                          SoImage::HorAlignment horAlign,
                          SoImage::VertAlignment vertAlign);
#endif
 
  virtual void printPolyLine(const SbVec4f *points, 
                             int num_points, 
                             const SbColor *colors, 
                             SbBool color_flag,
                             float thickness, 
                             u_short linePattern, 
                             int linePatternScaleFactor = 1);
  virtual void printPolygon(const SbVec4f *points, 
                            int num_points, 
                            const SbColor *colors,
                            SbBool color_flag,
                            const SbString &category, 
                            const SbString &name, 
                            const unsigned char *pattern);
  virtual void printText2(const SbVec4f point, 
                          const SbColor colors,
                          const SbString& font_name, 
                          float font_size, 
                          const SbString& string, 
                          int justif, 
                          float angle);
 
  // Print the border and the background
  virtual void printBorder() = 0;
  virtual void printBackground() = 0;
 
  // To choice the good pen and the good associated width.
  virtual void penAssignment(SbColor color, float width, 
                             int *ret_ind, float *ret_width);
  // Viewport methods  
  float getViewportWidth()  const;
  float getViewportHeight() const;
  const SbViewportRegion &getViewportRegion() const;
 
  // Translate color method(depends on setColorTranslationMethod())
  SbColor translateColor(SbColor color);
 
  // Access methods in mm
  float getShiftX() const;
  float getShiftY() const;
  float getWidth()  const;
  float getHeight() const;
 
  // Get offset - Indicate the offset(x,y) to draw a primitive.
  float getOffsetX() const;
  float getOffsetY() const;
 
  // Miscellaneous methods.
  virtual void prepareAction(SoCallbackAction &action, 
                             SbBool activateSoAnnotationCB = TRUE);
  
  // Data
  // Border and background attributes
  float m_border_width;
  SbColor m_border_color;
  SbBool m_background_flag;
  SbColor m_background_color;
  
  // Nominal width(in millimeters)
  float m_nominal_width;
  // Line pattern scale factor(in millimeters)
  float m_linePatternSize;
  // Pixel image size(in millimeters)
  float m_pixelImageSize;
  
  // Pen description
  int m_num_pens;
  // Array for color in LUT.
  SbColor *m_color_tab;
  
  // End line style
  EndLineStyle m_line_ends_style;
  JoinLineStyle m_line_joins_style;
  float m_miter_limit;
  
  // Existance of a viewport
  SbBool m_isViewportRegionExist;
  
  // Page size(in millimeters)
  SbVec2f m_pageSize;
  
  // Start page position(in millimeters)
  SbVec2f m_startPagePosition;
  
  // Multiplot per page data
  SbBool m_isMultiPlotPerPage;
  SbBool m_isFirstPlotPage;
  
  /*----------------------------------------------------------------------------*/
  
 private:
  // Drawing methods
  void drawTriangle(SoCallbackAction *action,
                    SoPrimitiveVertex *v1,
                    SoPrimitiveVertex *v2,
                    SoPrimitiveVertex *v3);
  void drawLineSegment(SoCallbackAction *action,
                       SoPrimitiveVertex *v1,
                       SoPrimitiveVertex *v2);
  SoCallbackAction::Response sendPoints(SoCallbackAction *action);
  void drawPoint(SoCallbackAction *action,
                 SoPrimitiveVertex *v);
  SoCallbackAction::Response drawText2(SoCallbackAction *action,
                                       const SoNode *node, 
                                       SbBool isAnnoText3 = FALSE);
  SoCallbackAction::Response drawText3(SoCallbackAction *action,
                                       const SoNode *node, 
                                       SbBool isAnnoText3 = FALSE);
  SoCallbackAction::Response drawMarkerSet(SoCallbackAction *action, 
                                           const SoNode *node);
  SoCallbackAction::Response drawImage(SoCallbackAction *action, 
                                       const SoNode *node);
 
  // Clipping methods
  void clipImage(SoCallbackAction *action, 
                 SbVec4f *points, 
                 const SoNode *node);
  void clipText(SoCallbackAction *action, 
                SbVec4f *points, 
                SbColor color,
                SoNode *node,  
                SbBool isAnnoText3 = FALSE);
  void clipPolygon(SoCallbackAction *action,
                   SbVec4f *points, 
                   int num_points, 
                   SbColor *colors);
  void clipPolyLine(SoCallbackAction *action,
                    SbVec4f *points, 
                    int num_points, 
                    SbColor *colors);
  void clipPolyLineFar(SoCallbackAction *action,
                       SbVec4f *points, 
                       int num_points, 
                       SbColor *colors,
                       int color_flag);
  void clipPolyLineXMin(SoCallbackAction *action,
                        SbVec4f *points, 
                        int num_points, 
                        SbColor *colors,
                        int color_flag);
  void clipPolyLineXMax(SoCallbackAction *action,
                        SbVec4f *points, 
                        int num_points, 
                        SbColor *colors,
                        int color_flag);
  void clipPolyLineYMin(SoCallbackAction *action,
                        SbVec4f *points, 
                        int num_points, 
                        SbColor *colors,
                        int color_flag);
  void clipPolyLineYMax(SoCallbackAction *action,
                        SbVec4f *points, 
                        int num_points, 
                        SbColor *colors,
                        int color_flag);
  void clipPolyMark(SoCallbackAction *action,
                    SbVec4f *points, 
                    int num_points, 
                    SbColor *colors 
#ifndef NO_TGS_OIV
                    , SoMarkerSet *markerSet = NULL
#endif
                    );
 
  // HLHSR vectorize methods and members
  SoHLHSRVectorize *getHLHSRVectorize() const 
    { return m_HLHSRVectorize; }
  SoHLHSRVectorize *m_HLHSRVectorize;
 
  // Projects points on the sheet space.
  void projectPoints(SbVec4f *points, int n);
 
  // Defines the projection source used by projectPoints which defines the 2D space 
  // source used to project points on the sheet space.
  void setProjectionSource(const SbBox2f &projSrc) ;
  void setDefaultProjectionSource() ;
 
  void transformPoints(SoCallbackAction *action, SbVec4f *points, int n);
  void transformVecMCToVRC(SoCallbackAction *action, SbVec3f &point);
  void transformPointsMCToVRC(SoCallbackAction *action, 
                              SbVec4f *points, int n);
  void transformPointsVRCToNPC(SoCallbackAction *action, 
                               SbVec4f *points, int n);
  SbColor getColor(SoCallbackAction *action, 
                   int index, 
                   SbBool &isFullyTransparent);
  SbColor getLightingColor(SoCallbackAction *action, 
                           const SoPrimitiveVertex *vertex,
                           const SbVec4f &point, 
                           SbBool &isFullyTransparent);
  void  computeLightList(SoState *state);
  void  deleteLightsList();
  float getAttenuationFactor(const SoCallbackAction *action, 
                             const SbVec3f &lightLocation, 
                             const SbVec3f &vertexPoint);
  
  float getNormalizedWidth();
  float getNormalizedHeight();
  float computeFontSizeAngleViewing(SoCallbackAction *action, 
                                    float fontSize, float &angle);
 
  // Viewport methods    
  void  setViewportRegion(SoCallbackAction *action);
  void  setViewportRegion(const SbViewportRegion &vp) 
  { m_viewportRegion = vp ; }
 
  // Conversion methods
  static float unitsToMillimeters(float w, DimensionUnit u);
  static float millimetersToUnits(float w, DimensionUnit u);
 
  // Callbacks
  static void drawTriangleCB(void *object, 
                             SoCallbackAction *action, 
                             SoPrimitiveVertex *v1,
                             SoPrimitiveVertex *v2, 
                             SoPrimitiveVertex *v3);
  static void drawLineSegmentCB(void *object, 
                                SoCallbackAction *action, 
                                SoPrimitiveVertex *v1, 
                                SoPrimitiveVertex *v2);
  static void drawPointCB(void *object, 
                          SoCallbackAction *action, 
                          SoPrimitiveVertex *v);
  static SoCallbackAction::Response drawText2CB(void *object, 
                                                SoCallbackAction *action, 
                                                const SoNode *node);
  static SoCallbackAction::Response drawText3CB(void *object, 
                                                SoCallbackAction *action, 
                                                const SoNode *node);
  static SoCallbackAction::Response drawImageCB(void *object, 
                                                SoCallbackAction *action, 
                                                const SoNode *node);
  static SoCallbackAction::Response sendPointsCB(void *object, 
                                                 SoCallbackAction *action, 
                                                 const SoNode *node);
  static SoCallbackAction::Response drawAnnoText3CB(void *object, 
                                                    SoCallbackAction *action, 
                                                    const SoNode *node);
  static SoCallbackAction::Response endDrawAnnoText3CB(void *, 
                                                       SoCallbackAction *, 
                                                       const SoNode *);
  static SoCallbackAction::Response cameraCB(void *object, 
                                             SoCallbackAction *action, 
                                             const SoNode *node);
  static SoCallbackAction::Response storeAnnotationCB(void *object, 
                                                      SoCallbackAction *action, 
                                                      const SoNode *node);
  
  // Method needed to implement rendering of delayed paths
  void addDelayedPath(SoPath *path);
  void renderDelayedPaths();
 
  // Data
  // Start position(in millimeters)
  float m_shiftX, m_shiftY;
  Orientation m_orientation;  
  // Drawing dimensions(in millimeters)
  float m_width, m_height;
 
  // Viewport region
  SbViewportRegion m_viewportRegion;
  
  ColorTranslationMethod m_colorTranslationMethod;
  // Array for line width.
  float *m_pensWidth;
  SbBool m_priority;
 
  int m_numAlloc;
  int m_numVertices;
  SbVec4f *m_pointList;
  SbColor *m_colorList;
  HLHSRMode m_HLHSRMode;
  float m_HLHSRRasterQuality ;
  SbBool m_HLHSRRasterCaching ;
  unsigned short m_HLHSRRasterTileSize ;
  SbBool m_isAnnoText3Drawn;
 
  // Lighting data
  SoNodeList m_lightNodesList;
  SbPList m_lightsList;  
  SbBool m_isLightingEnabled;
 
  // Shading model
  ShadeModel m_shadeModel ;
 
  // Offset Z value (allows separating coplanar lines and polys)
  float m_polyOffset;
  float m_lineOffset;
  float m_markOffset;
 
  // Defines the projection source used by projectPoints which defines the 2D space 
  // source used to project points on the sheet space.
  SbBox2f m_projSrc ;
 
  // Stuff needed to implement rendering of delayed paths
  SoPathList m_delayedPaths; // List of paths to render
 
  // Friend classes
  friend class SoHLHSRVectorize;
  friend class SoHLHSRImageVectorizer;
};
 
class  SoVectorOutput
{
 
 public:
 
  SoVectorOutput();
 
  virtual ~SoVectorOutput();
 
 public:
 
  virtual void setFilePointer(FILE *newFP);
 
  virtual FILE *getFilePointer();
 
  SoNONUNICODE virtual SbBool openFile(const char *file_name);
 
  virtual SbBool openFile( const SbString& file_name );
 
  virtual void closeFile();
 
 private:
 
  FILE *m_out_file;
};
 
#endif //__SO_VECTORIZE_ACTION_