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)
  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 NCollection_Handle<SelectMgr_BaseFrustum> SelectMgr_TriangularFrustum::ScaleAndTransform (const Standard_Integer /*theScale*/,
 132                                                                                           const gp_Trsf& theTrsf)
 133 {
 134   SelectMgr_TriangularFrustum* aRes = new SelectMgr_TriangularFrustum();
 135
 136   // V0_Near
 137   aRes->myVertices[0] = myVertices[0].Transformed (theTrsf);
 138   // V1_Near
 139   aRes->myVertices[1] = myVertices[1].Transformed (theTrsf);
 140   // V2_Near
 141   aRes->myVertices[2] = myVertices[2].Transformed (theTrsf);
 142   // V0_Far
 143   aRes->myVertices[3] = myVertices[3].Transformed (theTrsf);
 144   // V1_Far
 145   aRes->myVertices[4] = myVertices[4].Transformed (theTrsf);
 146   // V2_Far
 147   aRes->myVertices[5] = myVertices[5].Transformed (theTrsf);
 148
 149   aRes->myIsOrthographic = myIsOrthographic;
 150
 151   // V0_Near - V0_Far
 152   aRes->myEdgeDirs[0] = aRes->myVertices[0].XYZ() - aRes->myVertices[3].XYZ();
 153   // V1_Near - V1_Far
 154   aRes->myEdgeDirs[1] = aRes->myVertices[1].XYZ() - aRes->myVertices[4].XYZ();
 155   // V2_Near - V1_Far
 156   aRes->myEdgeDirs[2] = aRes->myVertices[2].XYZ() - aRes->myVertices[5].XYZ();
 157   // V1_Near - V0_Near
 158   aRes->myEdgeDirs[3] = aRes->myVertices[1].XYZ() - aRes->myVertices[0].XYZ();
 159   // V2_Near - V1_Near
 160   aRes->myEdgeDirs[4] = aRes->myVertices[2].XYZ() - aRes->myVertices[1].XYZ();
 161   // V1_Near - V0_Near
 162   aRes->myEdgeDirs[5] = aRes->myVertices[2].XYZ() - aRes->myVertices[0].XYZ();
 163
 164   computeFrustumNormals (aRes->myEdgeDirs, aRes->myPlanes);
 165
 166   cacheVertexProjections (aRes);
 167
 168   return NCollection_Handle<SelectMgr_BaseFrustum> (aRes);
 169 }
 170
 171 //=======================================================================
 172 // function : Overlaps
 173 // purpose  : SAT intersection test between defined volume and
 174 //            given axis-aligned box
 175 //=======================================================================
 176 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& theMinPt,
 177                                                         const SelectMgr_Vec3& theMaxPt,
 178                                                         Standard_Real& /*theDepth*/)
 179 {
 180   return hasOverlap (theMinPt, theMaxPt);
 181 }
 182
 183 // =======================================================================
 184 // function : Overlaps
 185 // purpose  : Returns true if selecting volume is overlapped by
 186 //            axis-aligned bounding box with minimum corner at point
 187 //            theMinPt and maximum at point theMaxPt
 188 // =======================================================================
 189 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& theMinPt,
 190                                                         const SelectMgr_Vec3& theMaxPt,
 191                                                         Standard_Boolean* /*theInside*/)
 192 {
 193   return hasOverlap (theMinPt, theMaxPt, NULL);
 194 }
 195
 196 // =======================================================================
 197 // function : Overlaps
 198 // purpose  : Intersection test between defined volume and given point
 199 // =======================================================================
 200 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt,
 201                                                         Standard_Real& /*theDepth*/)
 202 {
 203   return hasOverlap (thePnt);
 204 }
 205
 206 // =======================================================================
 207 // function : Overlaps
 208 // purpose  : SAT intersection test between defined volume and given
 209 //            ordered set of points, representing line segments. The test
 210 //            may be considered of interior part or boundary line defined
 211 //            by segments depending on given sensitivity type
 212 // =======================================================================
 213 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
 214                                                         Select3D_TypeOfSensitivity theSensType,
 215                                                         Standard_Real& /*theDepth*/)
 216 {
 217   if (theSensType == Select3D_TOS_BOUNDARY)
 218   {
 219     const Standard_Integer aLower  = theArrayOfPnts.Lower();
 220     const Standard_Integer anUpper = theArrayOfPnts.Upper();
 221     for (Standard_Integer aPtIdx = aLower; aPtIdx <= anUpper; ++aPtIdx)
 222     {
 223       const gp_Pnt& aStartPt = theArrayOfPnts.Value (aPtIdx);
 224       const gp_Pnt& aEndPt   = theArrayOfPnts.Value (aPtIdx == anUpper ? aLower : (aPtIdx + 1));
 225       if (!hasOverlap (aStartPt, aEndPt))
 226       {
 227         return Standard_False;
 228       }
 229     }
 230   }
 231   else if (theSensType == Select3D_TOS_INTERIOR)
 232   {
 233     gp_Vec aNorm (gp_XYZ (RealLast(), RealLast(), RealLast()));
 234     return hasOverlap (theArrayOfPnts, aNorm);
 235   }
 236
 237   return Standard_False;
 238 }
 239
 240 // =======================================================================
 241 // function : Overlaps
 242 // purpose  : Checks if line segment overlaps selecting frustum
 243 // =======================================================================
 244 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt1,
 245                                                         const gp_Pnt& thePnt2,
 246                                                         Standard_Real& /*theDepth*/)
 247 {
 248   return hasOverlap (thePnt1, thePnt2);
 249 }
 250
 251 // =======================================================================
 252 // function : Overlaps
 253 // purpose  : SAT intersection test between defined volume and given
 254 //            triangle. The test may be considered of interior part or
 255 //            boundary line defined by triangle vertices depending on
 256 //            given sensitivity type
 257 // =======================================================================
 258 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt1,
 259                                                         const gp_Pnt& thePnt2,
 260                                                         const gp_Pnt& thePnt3,
 261                                                         Select3D_TypeOfSensitivity theSensType,
 262                                                         Standard_Real& theDepth)
 263 {
 264   if (theSensType == Select3D_TOS_BOUNDARY)
 265   {
 266     const gp_Pnt aPntsArrayBuf[3] = { thePnt1, thePnt2, thePnt3 };
 267     const TColgp_Array1OfPnt aPntsArray (aPntsArrayBuf[0], 1, 3);
 268     return Overlaps (aPntsArray, Select3D_TOS_BOUNDARY, theDepth);
 269   }
 270   else if (theSensType == Select3D_TOS_INTERIOR)
 271   {
 272     gp_Vec aNorm (gp_XYZ (RealLast(), RealLast(), RealLast()));
 273     return hasOverlap (thePnt1, thePnt2, thePnt3, aNorm);
 274   }
 275
 276   return Standard_True;
 277 }
 278
 279 // =======================================================================
 280 // function : Clear
 281 // purpose  : Nullifies the handle for corresponding builder instance to prevent
 282 //            memory leaks
 283 // =======================================================================
 284 void SelectMgr_TriangularFrustum::Clear()
 285 {
 286   myBuilder.Nullify();
 287 }