path: root/inc/NIS_Triangulated.hxx

// File:      NIS_Triangulated.hxx
// Created:   17.07.07 08:42
// Author:    Alexander GRIGORIEV
// Copyright: Open Cascade 2007


#ifndef NIS_Triangulated_HeaderFile
#define NIS_Triangulated_HeaderFile

#include <NIS_InteractiveObject.hxx>
#include <Quantity_Color.hxx>

#ifdef WNT
// Disable the warning "operator new unmatched by delete"
#pragma warning (push)
#pragma warning (disable:4291)
#endif

class Handle_NIS_TriangulatedDrawer;
class NCollection_BaseAllocator;
class Handle_NCollection_BaseAllocator;
class NIS_TriangulatedDrawer;

/**
 * Interactive object that consists of triangles, lines and polygons without
 * normals. Particularly can be used to render planar 2D shapes.
 *
 * @par 2D and 3D model
 * Vertices are stored in an array of float numbers, 2 or 3 numbers per vertex.
 * The number of dimensions is defined in the constructor, see the parameter
 * 'is2D'. When 2D is defined then for all vertices the Z coordinate is 0.
 * To display planar objects in a plane different from XOY you should subclass
 * this type together with the correponding Drawer and store the transformation
 * parameters. In Drawer subclass either in method BeforeDraw() or in method
 * Draw() you would call glTranslate() or glMultMatrix() so that all vertices
 * should be located in their proper positions.
 *
 * @par Compressed storage
 * For efficient memory utilization, indice (triangles, segments, polygons) are
 * 8-bit, 16-bit or 32-bit numbers. The width of this numeric representation is
 * chosen automatically when the total number of nodes is passed in the
 * constructor or in any Set* method. For example, if this number of nodes is
 * smaller than 256 then 8-bit representation is selected. The choice is stored
 * in 'myIndexType' data member.
 */

class NIS_Triangulated : public NIS_InteractiveObject
{
 protected:
  /**
   * Constants defining the mode (type) of presentation. They allow mixed type,
   * e.g., Triangulation+Line. Line and Segments are not mixable, their mix is
   * treated as Line only.
   */
  enum {
    Type_None          =  0,
    Type_Loop          =  1,  //!< modifier to Line
    Type_Line          =  2,
    Type_Segments      =  4,
    Type_Triangulation =  8,
    Type_Polygons      = 16
  };

 public:
  /**
   * Enumerated type of polygon rendering.
   */
  enum PolygonType {
    Polygon_Default  = 0,  //!< Polygon as LINE, Triangulation as FILL
    Polygon_Line     = 1,  //!< Both Polygon and Triangulation as LINE
    Polygon_Fill     = 2   //!< Both Polygon and Triangulation as FILL
  };

 public:
  // ---------- PUBLIC METHODS ----------


  /**
   * Constructor. Optionally defines the number of nodes that will be allocated
   * (this number may be defined later in methods Set*Prs) as well as the
   * memory allocator where the nodes, lines and triangles will be stored by
   * this instance.
   * @param nNodes
   *   Total number of nodes that will be initialized for this object
   * @param is2D
   *   If true then the nodes will be 2D in plane Z=0, otherwise normal 3D.
   * @param theAlloc
   *   Allocator for internal data
   */
  Standard_EXPORT NIS_Triangulated(const Standard_Integer nNodes = 0,
                                   const Standard_Boolean is2D = Standard_False,
                                   const Handle_NCollection_BaseAllocator&
                                   theAlloc = 0L);

  /**
   * Define the polygonal presentration.
   * @param nPolygons
   *   Number of separate polygons. If set to 0, polygons are cancelled
   * @param nNodes
   *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
   *   allocation is used, otherwise a new allocation is created.
   */ 
  Standard_EXPORT void              SetPolygonsPrs
                                        (const Standard_Integer nPolygons,
                                         const Standard_Integer nNodes = 0);

  /**
   * Define the triangulated presentration.
   * @param nTriangles
   *   Number of triangles. If set to 0, triangulation is cancelled
   * @param nNodes
   *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
   *   allocation is used, otherwise a new allocation is created.
   */ 
  Standard_EXPORT void              SetTriangulationPrs
                                        (const Standard_Integer nTriangles,
                                         const Standard_Integer nNodes = 0);

  /**
   * Define the line presentration (polygon through points)
   * @param nPoints
   *   Number of nodes defining the line. If set to 0, line is cancelled
   * @param isClosed
   *   True if the polygon is closed, so the segment between the first and
   *   the last points is created automatically.
   * @param nNodes
   *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
   *   allocation is used, otherwise a new allocation is created.
   */ 
  Standard_EXPORT void              SetLinePrs
                                        (const Standard_Integer nPoints,
                                         const Standard_Boolean isClosed,
                                         const Standard_Integer nNodes = 0);

  /**
   * Define the segments presentration. Each segment is defined by 2 nodes
   * @param nSegments
   *   Number of segments. If set to 0, segments presentation is cancelled
   * @param nNodes
   *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
   *   allocation is used, otherwise a new allocation is created.
   */ 
  Standard_EXPORT void              SetSegmentPrs
                                        (const Standard_Integer nSegments,
                                         const Standard_Integer nNodes = 0);

  /**
   * Query if there is Triangulation component in the presentation.
   */
  inline Standard_Boolean           IsTriangulation () const
  { return (myType & Type_Triangulation) != 0; }

  /**
   * Query if there is Polygons component in the presentation.
   */
  inline Standard_Boolean           IsPolygons  () const
  { return (myType & Type_Polygons) != 0; }

  /**
   * Query if there is Line component in the presentation.
   */
  inline Standard_Boolean           IsLine      (Standard_Boolean& isLoop) const
  { isLoop = (myType & Type_Loop) != 0; return (myType & Type_Line) != 0; }

  /**
   * Query if there is Segments component in the presentation.
   */
  inline Standard_Boolean           IsSegments  () const
  { return (myType & Type_Segments) != 0; }

  /**
   * Reset all data memebers and free all allocated memory.
   * Called from the destructor, also can be usedto re-initialize a given
   * Interactive Objects. 
   */
  Standard_EXPORT void              Clear       ();

  /**
   * Destructor.
   */
  Standard_EXPORT virtual ~NIS_Triangulated     ();

  /**
   * Create a default drawer instance.
   */
  Standard_EXPORT virtual NIS_Drawer *
                                    DefaultDrawer (NIS_Drawer *) const;

  /**
   * Define the coordinates of node [ind].
   */
  Standard_EXPORT void              SetNode   (const Standard_Integer  ind,
                                               const gp_XYZ&           thePnt);

  /**
   * Define the coordinates of node [ind]. Z coordinate is assigned to 0.
   */
  Standard_EXPORT void              SetNode   (const Standard_Integer  ind,
                                               const gp_XY&            thePnt);

  /**
   * Define the triangle [ind] by indices of its three nodes.
   */
  Standard_EXPORT void              SetTriangle(const Standard_Integer  ind,
                                                const Standard_Integer  iNode0,
                                                const Standard_Integer  iNode1,
                                                const Standard_Integer  iNode2);

  /**
   * Allocate a single polygon, should be called for each polygon following
   * the call SetPolygonsPrs(). The polygon can be filled by node indices using
   * the method SetPolygonNode().
   * @param ind
   *   Index of the polygon, should be [0..Npolygons-1]
   * @param theSz
   *   Number of points (segments) in the polygon.
   */
  Standard_EXPORT void              SetPolygon (const Standard_Integer  ind,
                                                const Standard_Integer  theSz);

  /**
   * Define the line node by index.
   */
  Standard_EXPORT void              SetLineNode(const Standard_Integer ind,
                                                const Standard_Integer iNode);

  /**
   * Query the number of nodes.
   */
  inline Standard_Integer           NNodes    () const
  { return myNNodes; }

  /**
   * Query the number of triangles.
   */
  inline Standard_Integer           NTriangles() const
  { return myNTriangles; }

  /**
   * Query the number of line points.
   */
  inline Standard_Integer           NLineNodes() const
  { return myNLineNodes; }

  /**
   * Query the number of polygons.
   */
  inline Standard_Integer           NPolygons () const
  { return static_cast<Standard_Integer>(myNPolygons); }

  /**
   * Query the node by its index.
   * @return
   *   pointer to array of 2 or 3 Standard_ShortReal values {X,Y(,Z) coord}
   */
  inline const Standard_ShortReal * Node      (const Standard_Integer ind) const
  { return &mypNodes[ind * myNodeCoord]; }

  /**
   * Define the node of a polygon by index.
   * @param indPoly
   *   Index of the Polygon, should be less than the number of polygons that is
   *   defined in SetPolygonsPrs() and can be returned by NPOlygons().
   * @param ind
   *   Index of the node in the Polygon. Should be less than the parameter theSz
   *   in the corresponding previous SetPolygon() call.
   * @param iNode
   *   Index of the node in the given position of the Polygon. 
   */
  Standard_EXPORT void              SetPolygonNode
                                              (const Standard_Integer indPoly,
                                               const Standard_Integer ind,
                                               const Standard_Integer iNode);

  /**
   * Get the node with index 'ind' from the polygon number 'indPoly'.
   */
  Standard_EXPORT Standard_Integer PolygonNode(const Standard_Integer indPoly,
                                               const Standard_Integer ind)const;

  /**
   * Get the number of nodes for the polygon number 'indPoly'.
   */
  Standard_EXPORT Standard_Integer NPolygonNodes
                                         (const Standard_Integer indPoly)const;

  /**
   * Set the boolean flag defining if the polygons or the triangulation
   * should be drawn. This method does not affect the presentation of
   * Line/Segments.
   * @param isDrawPolygons
   *   True defines that no triangulation is drawn, only polygons are. False
   *   defines that only triangulation is drawn, no polygons.
   */
  Standard_EXPORT void              SetDrawPolygons
                                        (const Standard_Boolean isDrawPolygons);
  /**
   * Set the type of polygon rendering.
   */
  Standard_EXPORT void              SetPolygonType
                                        (const PolygonType      theType);

  /**
   * Set the normal color for presentation.
   * @param theColor
   *   New color to use for the presentation.
   */
  Standard_EXPORT void              SetColor  (const Quantity_Color&  theColor);

  /**
   * Get Normal, Transparent or Hilighted color of the presentation.
   * @param theDrawType
   *   The draw type, for which the color is retrieved.
   */
  Standard_EXPORT Quantity_Color GetColor  
                          (const NIS_Drawer::DrawType theDrawType) const;

  /**
   * Set the color for hilighted presentation.
   * @param theColor
   *   New color to use for the presentation.
   */
  Standard_EXPORT void      SetHilightColor   (const Quantity_Color&  theColor);

  /**
   * Set the color for dynamic hilight presentation.
   * @param theColor
   *   New color to use for the presentation.
   */
  Standard_EXPORT void      SetDynHilightColor(const Quantity_Color&  theColor);

  /**
   * Set the width of line presentations in pixels.
   * @param theWidth
   *   New line width to use for the presentation.
   */
  Standard_EXPORT void      SetLineWidth      (const Standard_Real    theWidth);

  /**
   * Create a copy of theObject except its ID.
   * @param theAll
   *   Allocator where the Dest should store its private data.
   * @param theDest
   *   <tt>[in-out]</tt> The target object where the data are copied. If
   *   passed NULL then the target should be created.
   */
  Standard_EXPORT virtual void
                          Clone (const Handle_NCollection_BaseAllocator& theAll,
                                 Handle_NIS_InteractiveObject& theDest) const;

  /**
   * Intersect the InteractiveObject geometry with a line/ray.
   * @param theAxis
   *   The line or ray in 3D space.
   * @param theOver
   *   Half-thickness of the selecting line.
   * @return
   *   If the return value is more than 0.1*RealLast() then no intersection is
   *   detected. Otherwise returns the coordinate of thePnt on the ray. May be
   *   negative.
   */
  Standard_EXPORT virtual Standard_Real
                            Intersect       (const gp_Ax1&       theAxis,
                                             const Standard_Real theOver) const;

  /**
   * Intersect the InteractiveObject geometry with an oriented box.
   * @param theBox
   *   3D box of selection
   * @param theTrf
   *   Position/Orientation of the box.
   * @param isFull
   *   True if full inclusion is required, False - if partial.
   * @return
   *   True if the InteractiveObject geometry intersects the box or is inside it
   */
  Standard_EXPORT virtual Standard_Boolean
                             Intersect     (const Bnd_B3f&         theBox,
                                            const gp_Trsf&         theTrf,
                                            const Standard_Boolean isFull)const;

  /**
   * Intersect the InteractiveObject geometry with a selection polygon.
   * @param thePolygon
   *   the list of vertices of a free-form closed polygon without
   *   self-intersections. The last point should not coincide with the first
   *   point of the list. Any two neighbor points should not be confused.
   * @param theTrf
   *   Position/Orientation of the polygon.
   * @param isFullIn
   *   True if full inclusion is required, False - if partial.
   * @return
   *   True if the InteractiveObject geometry intersects the polygon or is
   *   inside it
   */
  Standard_EXPORT virtual Standard_Boolean Intersect
                    (const NCollection_List<gp_XY> &thePolygon,
                     const gp_Trsf                 &theTrf,
                     const Standard_Boolean         isFullIn) const;

  Standard_EXPORT static int tri_line_intersect  (const double      start[3],
                                                  const double      dir[3],
                                                  const float       V0[3],
                                                  const float       V1[3],
                                                  const float       V2[3],
                                                  double            * tInter);

  Standard_EXPORT static int tri2d_line_intersect(const double      start[3],
                                                  const double      dir[3],
                                                  const float       V0[2],
                                                  const float       V1[2],
                                                  const float       V2[2],
                                                  double            * tInter);

  Standard_EXPORT static int seg_line_intersect  (const gp_XYZ&     aStart,
                                                  const gp_XYZ&     aDir,
                                                  const double      over2,
                                                  const float       V0[3],
                                                  const float       V1[3],
                                                  double            * tInter);

  Standard_EXPORT static int seg2d_line_intersect(const gp_XYZ&     aStart,
                                                  const gp_XYZ&     aDir,
                                                  const double      over2,
                                                  const float       V0[2],
                                                  const float       V1[2],
                                                  double            * tInter);

  Standard_EXPORT static int seg_box_intersect  (const Bnd_B3f&    theBox,
                                                 const gp_Pnt      thePnt[2]);

  Standard_EXPORT static int seg_box_included   (const Bnd_B3f&    theBox,
                                                 const gp_Pnt      thePnt[2]);

  Standard_EXPORT static int seg_polygon_intersect
                              (const NCollection_List<gp_XY> &thePolygon,
                               const gp_XY                    thePnt[2]);

  Standard_EXPORT static int seg_polygon_included
                              (const NCollection_List<gp_XY> &thePolygon,
                               const gp_XY                    thePnt[2]);

  Standard_EXPORT static void ComputeBox    (Bnd_B3f&                  theBox,
                                             const Standard_Integer    nNodes,
                                             const Standard_ShortReal* pNodes,
                                             const Standard_Integer    nCoord);

  /**
   * Classification of thePoint with respect to thePolygon.
   * @param thePolygon
   *   the list of vertices of a free-form closed polygon without
   *   self-intersections. The last point should not coincide with the first
   *   point of the list. Any two neighbor points should not be confused.
   * @param thePoint
   *   the point to be classified.
   * @return
   *   Standard_True if thePoint in inside thePolygon or lies on its boundary.
   */
  Standard_EXPORT static Standard_Boolean
                 IsIn (const NCollection_List<gp_XY> &thePolygon,
                       const gp_XY                   &thePoint);

  /**
   * Implements deallocation of the object instance
   */
  Standard_EXPORT virtual void Delete () const; 

  /**
   * Operator new for memory allocation uses Open CASCADE memory manager
   */
  void* operator new    (size_t size)
  {
    return Standard::Allocate(size);
  }

 protected:

  /**
   * Allocator-based operator new for dynamic allocations in method Clone()
   */
  void* operator new    (Standard_Size theSz,
                         const Handle(NCollection_BaseAllocator)& theAllocator)
  {
    return theAllocator->Allocate(theSz);
  }

  /**
   * Create a 3D bounding box of the object.
   */
  Standard_EXPORT virtual void computeBox     ();

  /**
   * Create the memory buffer for the declared number of nodes, old nodes
   * are deallocated.
   */
  Standard_EXPORT void         allocateNodes  (const Standard_Integer nNodes);

  /**
   * Get the node pointed by the i-th index in the array.
   */
  Standard_EXPORT gp_Pnt       nodeAtInd      (const Standard_Integer * theArr,
                                               const Standard_Integer i) const;

  /**
   * Get the node pointed by the i-th index in the array.
   */
  Standard_EXPORT float*       nodeArrAtInd   (const Standard_Integer * theArr,
                                               const Standard_Integer i) const;

 protected:
  // ---------- PROTECTED FIELDS ----------

  NCollection_BaseAllocator  * myAlloc; //!< Usually from InteractiveContext
  Standard_Integer           myType;    //!< Combination of Type_* constants
  Standard_ShortReal         *  mypNodes;
  Standard_Integer           *  mypTriangles;
  Standard_Integer           *  mypLines;
  Standard_Integer           ** mypPolygons;
  Standard_Integer           myNNodes;
  Standard_Integer           myNTriangles;
  Standard_Integer           myNLineNodes;
  unsigned int               myNPolygons      : 24;
  Standard_Boolean           myIsDrawPolygons : 1;
  Standard_Boolean           myIsCloned       : 1; //!< How it is allocated
  unsigned int               myIndexType      : 2; //!< 0:8bit, 1:16bit, 2:32bit
  unsigned int               myNodeCoord      : 2; //!< 2 or 3 coordinates
  unsigned int               myPolygonType    : 2;

 public:
// Declaration of CASCADE RTTI
DEFINE_STANDARD_RTTI (NIS_Triangulated)

  friend class NIS_TriangulatedDrawer;
};

// Definition of HANDLE object using Standard_DefineHandle.hxx
DEFINE_STANDARD_HANDLE (NIS_Triangulated, NIS_InteractiveObject)

#ifdef WNT
#pragma warning (pop)
#endif

#endif