9c318cc2e086aa783ef143f28d362847fc25940d
[occt.git] / src / SelectMgr / SelectMgr_TriangularFrustum.cxx
1 // Created on: 2014-11-21
2 // Created by: Varvara POSKONINA
3 // Copyright (c) 2005-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 #include <SelectMgr_TriangularFrustum.hxx>
17
18 IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_TriangularFrustum,Standard_Transient)
19
20 SelectMgr_TriangularFrustum::~SelectMgr_TriangularFrustum()
21 {
22   Clear();
23 }
24
25 namespace
26 {
27   void computeFrustumNormals (const gp_Vec* theEdges, gp_Vec* theNormals)
28   {
29     // V0V1
30     theNormals[0] = theEdges[0].Crossed (theEdges[1]);
31     // V1V2
32     theNormals[1] = theEdges[1].Crossed (theEdges[2]);
33     // V0V2
34     theNormals[2] = theEdges[0].Crossed (theEdges[2]);
35     // Near
36     theNormals[3] = theEdges[3].Crossed (theEdges[5]);
37     // Far
38     theNormals[4] = -theNormals[3];
39   }
40 }
41
42 // =======================================================================
43 // function : cacheVertexProjections
44 // purpose  : Caches projection of frustum's vertices onto its plane directions
45 //            and {i, j, k}
46 // =======================================================================
47 void SelectMgr_TriangularFrustum::cacheVertexProjections (SelectMgr_TriangularFrustum* theFrustum) const
48 {
49   for (Standard_Integer aPlaneIdx = 0; aPlaneIdx < 5; ++aPlaneIdx)
50   {
51     Standard_Real aMax = -DBL_MAX;
52     Standard_Real aMin =  DBL_MAX;
53     const gp_XYZ& aPlane = theFrustum->myPlanes[aPlaneIdx].XYZ();
54     for (Standard_Integer aVertIdx = 0; aVertIdx < 6; ++aVertIdx)
55     {
56       Standard_Real aProjection = aPlane.Dot (theFrustum->myVertices[aVertIdx].XYZ());
57       aMax = Max (aMax, aProjection);
58       aMin = Min (aMin, aProjection);
59     }
60     theFrustum->myMaxVertsProjections[aPlaneIdx] = aMax;
61     theFrustum->myMinVertsProjections[aPlaneIdx] = aMin;
62   }
63
64   for (Standard_Integer aDim = 0; aDim < 3; ++aDim)
65   {
66     Standard_Real aMax = -DBL_MAX;
67     Standard_Real aMin =  DBL_MAX;
68     for (Standard_Integer aVertIdx = 0; aVertIdx < 6; ++aVertIdx)
69     {
70       Standard_Real aProjection = theFrustum->myVertices[aVertIdx].XYZ().GetData()[aDim];
71       aMax = Max (aMax, aProjection);
72       aMin = Min (aMin, aProjection);
73     }
74     theFrustum->myMaxOrthoVertsProjections[aDim] = aMax;
75     theFrustum->myMinOrthoVertsProjections[aDim] = aMin;
76   }
77 }
78
79 //=======================================================================
80 // function : SelectMgr_TriangularFrustum
81 // purpose  : Creates new triangular frustum with bases of triangles with
82 //            vertices theP1, theP2 and theP3 projections onto near and
83 //            far view frustum planes
84 //=======================================================================
85 void SelectMgr_TriangularFrustum::Build (const gp_Pnt2d& theP1,
86                                          const gp_Pnt2d& theP2,
87                                          const gp_Pnt2d& theP3)
88 {
89   // V0_Near
90   myVertices[0] = myBuilder->ProjectPntOnViewPlane (theP1.X(), theP1.Y(), 0.0);
91   // V1_Near
92   myVertices[1] = myBuilder->ProjectPntOnViewPlane (theP2.X(), theP2.Y(), 0.0);
93   // V2_Near
94   myVertices[2] = myBuilder->ProjectPntOnViewPlane (theP3.X(), theP3.Y(), 0.0);
95   // V0_Far
96   myVertices[3] = myBuilder->ProjectPntOnViewPlane (theP1.X(), theP1.Y(), 1.0);
97   // V1_Far
98   myVertices[4] = myBuilder->ProjectPntOnViewPlane (theP2.X(), theP2.Y(), 1.0);
99   // V2_Far
100   myVertices[5] = myBuilder->ProjectPntOnViewPlane (theP3.X(), theP3.Y(), 1.0);
101
102   // V0_Near - V0_Far
103   myEdgeDirs[0] = myVertices[0].XYZ() - myVertices[3].XYZ();
104   // V1_Near - V1_Far
105   myEdgeDirs[1] = myVertices[1].XYZ() - myVertices[4].XYZ();
106   // V2_Near - V1_Far
107   myEdgeDirs[2] = myVertices[2].XYZ() - myVertices[5].XYZ();
108   // V1_Near - V0_Near
109   myEdgeDirs[3] = myVertices[1].XYZ() - myVertices[0].XYZ();
110   // V2_Near - V1_Near
111   myEdgeDirs[4] = myVertices[2].XYZ() - myVertices[1].XYZ();
112   // V1_Near - V0_Near
113   myEdgeDirs[5] = myVertices[2].XYZ() - myVertices[0].XYZ();
114
115   computeFrustumNormals (myEdgeDirs, myPlanes);
116
117   cacheVertexProjections (this);
118 }
119
120 //=======================================================================
121 // function : ScaleAndTransform
122 // purpose  : IMPORTANT: Scaling makes sense only for frustum built on a single point!
123 //            Note that this method does not perform any checks on type of the frustum.
124 //            Returns a copy of the frustum resized according to the scale factor given
125 //            and transforms it using the matrix given.
126 //            There are no default parameters, but in case if:
127 //                - transformation only is needed: @theScaleFactor must be initialized
128 //                  as any negative value;
129 //                - scale only is needed: @theTrsf must be set to gp_Identity.
130 //=======================================================================
131 Handle(SelectMgr_BaseFrustum) SelectMgr_TriangularFrustum::ScaleAndTransform (const Standard_Integer /*theScale*/,
132                                                                               const gp_GTrsf& theTrsf) const
133 {
134   Handle(SelectMgr_TriangularFrustum) aRes = new SelectMgr_TriangularFrustum();
135
136   for (Standard_Integer anIt = 0; anIt < 6; anIt++)
137   {
138     gp_Pnt aPoint = myVertices[anIt];
139     theTrsf.Transforms (aPoint.ChangeCoord());
140     aRes->myVertices[anIt] = aPoint;
141   }
142
143   aRes->myIsOrthographic = myIsOrthographic;
144
145   // V0_Near - V0_Far
146   aRes->myEdgeDirs[0] = aRes->myVertices[0].XYZ() - aRes->myVertices[3].XYZ();
147   // V1_Near - V1_Far
148   aRes->myEdgeDirs[1] = aRes->myVertices[1].XYZ() - aRes->myVertices[4].XYZ();
149   // V2_Near - V1_Far
150   aRes->myEdgeDirs[2] = aRes->myVertices[2].XYZ() - aRes->myVertices[5].XYZ();
151   // V1_Near - V0_Near
152   aRes->myEdgeDirs[3] = aRes->myVertices[1].XYZ() - aRes->myVertices[0].XYZ();
153   // V2_Near - V1_Near
154   aRes->myEdgeDirs[4] = aRes->myVertices[2].XYZ() - aRes->myVertices[1].XYZ();
155   // V1_Near - V0_Near
156   aRes->myEdgeDirs[5] = aRes->myVertices[2].XYZ() - aRes->myVertices[0].XYZ();
157
158   computeFrustumNormals (aRes->myEdgeDirs, aRes->myPlanes);
159
160   cacheVertexProjections (aRes.get());
161
162   return aRes;
163 }
164
165 //=======================================================================
166 // function : Overlaps
167 // purpose  : SAT intersection test between defined volume and
168 //            given axis-aligned box
169 //=======================================================================
170 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& theMinPt,
171                                                         const SelectMgr_Vec3& theMaxPt,
172                                                         Standard_Real& /*theDepth*/)
173 {
174   return hasOverlap (theMinPt, theMaxPt);
175 }
176
177 // =======================================================================
178 // function : Overlaps
179 // purpose  : Returns true if selecting volume is overlapped by
180 //            axis-aligned bounding box with minimum corner at point
181 //            theMinPt and maximum at point theMaxPt
182 // =======================================================================
183 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& theMinPt,
184                                                         const SelectMgr_Vec3& theMaxPt,
185                                                         Standard_Boolean* /*theInside*/)
186 {
187   return hasOverlap (theMinPt, theMaxPt, NULL);
188 }
189
190 // =======================================================================
191 // function : Overlaps
192 // purpose  : Intersection test between defined volume and given point
193 // =======================================================================
194 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt,
195                                                         Standard_Real& /*theDepth*/)
196 {
197   return hasOverlap (thePnt);
198 }
199
200 // =======================================================================
201 // function : Overlaps
202 // purpose  : SAT intersection test between defined volume and given
203 //            ordered set of points, representing line segments. The test
204 //            may be considered of interior part or boundary line defined
205 //            by segments depending on given sensitivity type
206 // =======================================================================
207 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
208                                                         Select3D_TypeOfSensitivity theSensType,
209                                                         Standard_Real& /*theDepth*/)
210 {
211   if (theSensType == Select3D_TOS_BOUNDARY)
212   {
213     const Standard_Integer aLower  = theArrayOfPnts.Lower();
214     const Standard_Integer anUpper = theArrayOfPnts.Upper();
215     for (Standard_Integer aPtIdx = aLower; aPtIdx <= anUpper; ++aPtIdx)
216     {
217       const gp_Pnt& aStartPt = theArrayOfPnts.Value (aPtIdx);
218       const gp_Pnt& aEndPt   = theArrayOfPnts.Value (aPtIdx == anUpper ? aLower : (aPtIdx + 1));
219       if (!hasOverlap (aStartPt, aEndPt))
220       {
221         return Standard_False;
222       }
223     }
224   }
225   else if (theSensType == Select3D_TOS_INTERIOR)
226   {
227     gp_Vec aNorm (gp_XYZ (RealLast(), RealLast(), RealLast()));
228     return hasOverlap (theArrayOfPnts, aNorm);
229   }
230
231   return Standard_False;
232 }
233
234 // =======================================================================
235 // function : Overlaps
236 // purpose  : Checks if line segment overlaps selecting frustum
237 // =======================================================================
238 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt1,
239                                                         const gp_Pnt& thePnt2,
240                                                         Standard_Real& /*theDepth*/)
241 {
242   return hasOverlap (thePnt1, thePnt2);
243 }
244
245 // =======================================================================
246 // function : Overlaps
247 // purpose  : SAT intersection test between defined volume and given
248 //            triangle. The test may be considered of interior part or
249 //            boundary line defined by triangle vertices depending on
250 //            given sensitivity type
251 // =======================================================================
252 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt1,
253                                                         const gp_Pnt& thePnt2,
254                                                         const gp_Pnt& thePnt3,
255                                                         Select3D_TypeOfSensitivity theSensType,
256                                                         Standard_Real& theDepth)
257 {
258   if (theSensType == Select3D_TOS_BOUNDARY)
259   {
260     const gp_Pnt aPntsArrayBuf[3] = { thePnt1, thePnt2, thePnt3 };
261     const TColgp_Array1OfPnt aPntsArray (aPntsArrayBuf[0], 1, 3);
262     return Overlaps (aPntsArray, Select3D_TOS_BOUNDARY, theDepth);
263   }
264   else if (theSensType == Select3D_TOS_INTERIOR)
265   {
266     gp_Vec aNorm (gp_XYZ (RealLast(), RealLast(), RealLast()));
267     return hasOverlap (thePnt1, thePnt2, thePnt3, aNorm);
268   }
269
270   return Standard_True;
271 }
272
273 // =======================================================================
274 // function : Clear
275 // purpose  : Nullifies the handle for corresponding builder instance to prevent
276 //            memory leaks
277 // =======================================================================
278 void SelectMgr_TriangularFrustum::Clear()
279 {
280   myBuilder.Nullify();
281 }