129abadc00d15a6b671251fa051b5d0a14e15185
[occt.git] / src / StdPrs / StdPrs_Isolines.hxx
1 // Created on: 2014-10-14
2 // Created by: Anton POLETAEV
3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef _StdPrs_Isolines_H__
17 #define _StdPrs_Isolines_H__
18
19 #include <BRepAdaptor_HSurface.hxx>
20 #include <Geom_Surface.hxx>
21 #include <Prs3d_Drawer.hxx>
22 #include <Prs3d_Presentation.hxx>
23 #include <Prs3d_LineAspect.hxx>
24 #include <Prs3d_Root.hxx>
25 #include <Prs3d_NListOfSequenceOfPnt.hxx>
26 #include <Poly_Triangulation.hxx>
27 #include <StdPrs_DeflectionCurve.hxx>
28 #include <StdPrs_ToolTriangulatedShape.hxx>
29 #include <TColStd_Array1OfInteger.hxx>
30 #include <TColgp_Array1OfPnt2d.hxx>
31 #include <TColStd_SequenceOfReal.hxx>
32
33 class Poly_Triangle;
34 class TopoDS_Face;
35 class TopLoc_Location;
36
37 //! Tool for computing isoline representation for a face or surface.
38 //! Depending on a flags set to the given Prs3d_Drawer instance, on-surface (is used
39 //! by default) or on-triangulation isoline builder algorithm will be used.
40 //! If the given shape is not triangulated, on-surface isoline builder will be applied
41 //! regardless of Prs3d_Drawer flags.
42 class StdPrs_Isolines : public Prs3d_Root
43 {
44 public:
45
46   //! Computes isolines presentation for a TopoDS face.
47   //! This method chooses proper version of isoline builder algorithm : on triangulation
48   //! or surface depending on the flag passed from Prs3d_Drawer attributes.
49   //! This method is a default way to display isolines for a given TopoDS face.
50   //! @param thePresentation [in] the presentation.
51   //! @param theFace [in] the face.
52   //! @param theDrawer [in] the display settings.
53   //! @param theDeflection [in] the deflection for isolines-on-surface version.
54   inline static void Add (const Handle(Prs3d_Presentation)& thePresentation,
55                           const TopoDS_Face&                theFace,
56                           const Handle(Prs3d_Drawer)&       theDrawer,
57                           const Standard_Real               theDeflection)
58   {
59     if (theDrawer->IsoOnTriangulation() && StdPrs_ToolTriangulatedShape::IsTriangulated (theFace))
60     {
61       AddOnTriangulation (thePresentation, theFace, theDrawer);
62     }
63     else
64     {
65       AddOnSurface (thePresentation, theFace, theDrawer, theDeflection);
66     }
67   }
68
69   //! Computes isolines presentation for a TopoDS face.
70   //! This method chooses proper version of isoline builder algorithm : on triangulation
71   //! or surface depending on the flag passed from Prs3d_Drawer attributes.
72   //! This method is a default way to display isolines for a given TopoDS face.
73   //! @param theFace [in] the face.
74   //! @param theDrawer [in] the display settings.
75   //! @param theDeflection [in] the deflection for isolines-on-surface version.
76   static void Add (const TopoDS_Face&          theFace,
77                    const Handle(Prs3d_Drawer)& theDrawer,
78                    const Standard_Real         theDeflection,
79                    Prs3d_NListOfSequenceOfPnt& theUPolylines,
80                    Prs3d_NListOfSequenceOfPnt& theVPolylines)
81   {
82     if (theDrawer->IsoOnTriangulation() && StdPrs_ToolTriangulatedShape::IsTriangulated (theFace))
83     {
84       AddOnTriangulation (theFace, theDrawer, theUPolylines, theVPolylines);
85     }
86     else
87     {
88       AddOnSurface (theFace, theDrawer, theDeflection, theUPolylines, theVPolylines);
89     }
90   }
91
92   //! Computes isolines on triangulation and adds them to a presentation.
93   //! @param thePresentation [in] the presentation.
94   //! @param theFace [in] the face.
95   //! @param theDrawer [in] the display settings.
96   Standard_EXPORT static void AddOnTriangulation (const Handle(Prs3d_Presentation)& thePresentation,
97                                                   const TopoDS_Face&                theFace,
98                                                   const Handle(Prs3d_Drawer)&       theDrawer);
99
100   //! Computes isolines on triangulation.
101   //! @param theFace [in] the face.
102   //! @param theDrawer [in] the display settings.
103   //! @param theUPolylines [out] the sequence of result polylines
104   //! @param theVPolylines [out] the sequence of result polylines
105   Standard_EXPORT static void AddOnTriangulation (const TopoDS_Face&          theFace,
106                                                   const Handle(Prs3d_Drawer)& theDrawer,
107                                                   Prs3d_NListOfSequenceOfPnt& theUPolylines,
108                                                   Prs3d_NListOfSequenceOfPnt& theVPolylines);
109
110   //! Computes isolines on triangulation and adds them to a presentation.
111   //! @param thePresentation [in] the presentation.
112   //! @param theTriangulation [in] the triangulation.
113   //! @param theSurface [in] the definition of triangulated surface. The surface
114   //!        adapter is used to precisely evaluate isoline points using surface
115   //!        law and fit them on triangulation. If NULL is passed, the method will
116   //!        use linear interpolation of triangle node's UV coordinates to evaluate
117   //!        isoline points.
118   //! @param theLocation [in] the location transformation defined for triangulation (surface).
119   //! @param theDrawer [in] the display settings.
120   //! @param theUIsoParams [in] the parameters of u isolines to compute.
121   //! @param theVIsoParams [in] the parameters of v isolines to compute.
122   Standard_EXPORT static void AddOnTriangulation (const Handle(Prs3d_Presentation)& thePresentation,
123                                                   const Handle(Poly_Triangulation)& theTriangulation,
124                                                   const Handle(Geom_Surface)&       theSurface,
125                                                   const TopLoc_Location&            theLocation,
126                                                   const Handle(Prs3d_Drawer)&       theDrawer,
127                                                   const TColStd_SequenceOfReal&     theUIsoParams,
128                                                   const TColStd_SequenceOfReal&     theVIsoParams);
129
130   //! Computes isolines on surface and adds them to presentation.
131   //! @param thePresentation [in] the presentation.
132   //! @param theFace [in] the face.
133   //! @param theDrawer [in] the display settings.
134   //! @param theDeflection [in] the deflection value.
135   Standard_EXPORT static void AddOnSurface (const Handle(Prs3d_Presentation)& thePresentation,
136                                             const TopoDS_Face&                theFace,
137                                             const Handle(Prs3d_Drawer)&       theDrawer,
138                                             const Standard_Real               theDeflection);
139
140   //! Computes isolines on surface and adds them to presentation.
141   //! @param theFace [in] the face
142   //! @param theDrawer [in] the display settings
143   //! @param theDeflection [in] the deflection value
144   //! @param theUPolylines [out] the sequence of result polylines
145   //! @param theVPolylines [out] the sequence of result polylines
146   Standard_EXPORT static void AddOnSurface (const TopoDS_Face&          theFace,
147                                             const Handle(Prs3d_Drawer)& theDrawer,
148                                             const Standard_Real         theDeflection,
149                                             Prs3d_NListOfSequenceOfPnt& theUPolylines,
150                                             Prs3d_NListOfSequenceOfPnt& theVPolylines);
151
152   //! Computes isolines on surface and adds them to presentation.
153   //! @param thePresentation [in] the presentation.
154   //! @param theSurface [in] the surface.
155   //! @param theDrawer [in] the display settings.
156   //! @param theDeflection [in] the deflection value.
157   //! @param theUIsoParams [in] the parameters of u isolines to compute.
158   //! @param theVIsoParams [in] the parameters of v isolines to compute.
159   Standard_EXPORT static void AddOnSurface (const Handle(Prs3d_Presentation)&   thePresentation,
160                                             const Handle(BRepAdaptor_HSurface)& theSurface,
161                                             const Handle(Prs3d_Drawer)&         theDrawer,
162                                             const Standard_Real                 theDeflection,
163                                             const TColStd_SequenceOfReal&       theUIsoParams,
164                                             const TColStd_SequenceOfReal&       theVIsoParams);
165
166   //! Evalute sequence of parameters for drawing uv isolines for a given face.
167   //! @param theFace [in] the face.
168   //! @param theNbIsoU [in] the number of u isolines.
169   //! @param theNbIsoV [in] the number of v isolines.
170   //! @param theUVLimit [in] the u, v parameter value limit.
171   //! @param theUIsoParams [out] the sequence of u isoline parameters.
172   //! @param theVIsoParams [out] the sequence of v isoline parameters.
173   Standard_EXPORT static void UVIsoParameters (const TopoDS_Face&      theFace,
174                                                const Standard_Integer  theNbIsoU,
175                                                const Standard_Integer  theNbIsoV,
176                                                const Standard_Real     theUVLimit,
177                                                TColStd_SequenceOfReal& theUIsoParams,
178                                                TColStd_SequenceOfReal& theVIsoParams);
179
180 public:
181
182   //! Auxiliary structure defining 3D point on isoline.
183   struct PntOnIso
184   {
185     gp_Pnt Pnt;   //!< 3D point
186     double Param; //!< parameter along the line (for sorting)
187   };
188
189   //! Auxiliary structure defining segment of isoline.
190   struct SegOnIso
191   {
192
193     PntOnIso Pnts[2];
194
195     operator       PntOnIso*()       { return Pnts; }
196     operator const PntOnIso*() const { return Pnts; }
197
198     bool operator< (const SegOnIso& theOther) const
199     {
200       return Pnts[1].Param < theOther.Pnts[0].Param;
201     }
202
203   };
204
205 private:
206
207   //! Computes isolines on surface.
208   //! @param theSurface [in] the surface
209   //! @param theDrawer [in] the display settings
210   //! @param theDeflection [in] the deflection value
211   //! @param theUIsoParams [in] the parameters of u isolines to compute
212   //! @param theVIsoParams [in] the parameters of v isolines to compute
213   //! @param theUPolylines [out] the sequence of result polylines
214   //! @param theVPolylines [out] the sequence of result polylines
215   Standard_EXPORT static void addOnSurface (const Handle(BRepAdaptor_HSurface)& theSurface,
216                                             const Handle(Prs3d_Drawer)&         theDrawer,
217                                             const Standard_Real                 theDeflection,
218                                             const TColStd_SequenceOfReal&       theUIsoParams,
219                                             const TColStd_SequenceOfReal&       theVIsoParams,
220                                             Prs3d_NListOfSequenceOfPnt&         theUPolylines,
221                                             Prs3d_NListOfSequenceOfPnt&         theVPolylines);
222
223   //! Computes isolines on triangulation.
224   //! @param thePresentation [in] the presentation
225   //! @param theTriangulation [in] the triangulation
226   //! @param theSurface [in] the definition of triangulated surface. The surface
227   //!        adapter is used to precisely evaluate isoline points using surface
228   //!        law and fit them on triangulation. If NULL is passed, the method will
229   //!        use linear interpolation of triangle node's UV coordinates to evaluate
230   //!        isoline points
231   //! @param theLocation [in] the location transformation defined for triangulation (surface)
232   //! @param theDrawer [in] the display settings
233   //! @param theUIsoParams [in] the parameters of u isolines to compute
234   //! @param theVIsoParams [in] the parameters of v isolines to compute
235   //! @param theUPolylines [out] the sequence of result polylines
236   //! @param theVPolylines [out] the sequence of result polylines
237   Standard_EXPORT static void addOnTriangulation (const Handle(Poly_Triangulation)& theTriangulation,
238                                                   const Handle(Geom_Surface)&       theSurface,
239                                                   const TopLoc_Location&            theLocation,
240                                                   const TColStd_SequenceOfReal&     theUIsoParams,
241                                                   const TColStd_SequenceOfReal&     theVIsoParams,
242                                                   Prs3d_NListOfSequenceOfPnt&       theUPolylines,
243                                                   Prs3d_NListOfSequenceOfPnt&       theVPolylines);
244
245   //! Find isoline segment on a triangle.
246   //! @param theSurface [in] the surface.
247   //! @param theIsU     [in] when true than U isoline is specified, V isoline otherwise
248   //! @param theIsoline [in] the isoline in uv coordinates.
249   //! @param theNodesXYZ [in] the XYZ coordinates of triangle nodes.
250   //! @param theNodesUV [in] the UV coordinates of triangle nodes.
251   //! @param theSegment [out] the XYZ points of crossed triangle's links.
252   //!                         with U cross point parameter for V isoline
253   //!                         or V parameters for U isoline (depending on theIsU)
254   //! @return TRUE if the isoline passes through the triangle.
255   Standard_EXPORT static Standard_Boolean findSegmentOnTriangulation (const Handle(Geom_Surface)& theSurface,
256                                                                       const bool                  theIsU,
257                                                                       const gp_Lin2d&             theIsoline,
258                                                                       const gp_Pnt*               theNodesXYZ,
259                                                                       const gp_Pnt2d*             theNodesUV,
260                                                                       SegOnIso&                   theSegment);
261 };
262
263 #endif // _StdPrs_Isolines_H__