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[3]);
  31     // V1V2
  32     theNormals[1] = theEdges[1].Crossed (theEdges[4]);
  33     // V0V2
  34     theNormals[2] = theEdges[0].Crossed (theEdges[5]);
  35     // Near
  36     theNormals[3] = theEdges[3].Crossed (theEdges[4]);
  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                                                         SelectBasics_PickResult& /*thePickResult*/)
 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                                                         SelectBasics_PickResult& /*thePickResult*/)
 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                                                         SelectBasics_PickResult& /*thePickResult*/)
 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                                                         SelectBasics_PickResult& /*thePickResult*/)
 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                                                         SelectBasics_PickResult& thePickResult)
 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, thePickResult);
 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 }
 282
 283 // =======================================================================
 284 // function : GetPlanes
 285 // purpose  :
 286 // =======================================================================
 287 void SelectMgr_TriangularFrustum::GetPlanes (NCollection_Vector<SelectMgr_Vec4>& thePlaneEquations) const
 288 {
 289   SelectMgr_Vec4 aPlaneEquation;
 290   for (Standard_Integer aPlaneIdx = 0; aPlaneIdx < 5; ++aPlaneIdx)
 291   {
 292     const gp_Vec& aNorm = myPlanes[aPlaneIdx];
 293     aPlaneEquation.x() = aNorm.X();
 294     aPlaneEquation.y() = aNorm.Y();
 295     aPlaneEquation.z() = aNorm.Z();
 296     aPlaneEquation.w() = - (aNorm.XYZ().Dot (myVertices[aPlaneIdx % 2 == 0 ? aPlaneIdx : 1].XYZ()));
 297     thePlaneEquations.Append (aPlaneEquation);
 298   }
 299 }