// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#include <StdSelect_ViewerSelector3d.ixx>
+#include <StdSelect_ViewerSelector3d.hxx>
#include <StdSelect.hxx>
#include <SelectBasics_SensitiveEntity.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <gp_Pln.hxx>
#include <Select3D_SensitiveEntity.hxx>
#include <Graphic3d_ArrayOfPolylines.hxx>
+#include <Graphic3d_Group.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
+#include <Graphic3d_Structure.hxx>
#include <SelectMgr_SelectableObject.hxx>
-#include <SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive.hxx>
-#include <SelectBasics_ListOfBox2d.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_HArray1OfPnt2d.hxx>
#include <Select3D_SensitiveCurve.hxx>
#include <Select3D_SensitiveSegment.hxx>
#include <Select3D_SensitiveTriangulation.hxx>
#include <Select3D_SensitiveTriangle.hxx>
#include <Select3D_SensitiveWire.hxx>
-#include <Select3D_SensitiveEntitySequence.hxx>
-#include <Select3D_ListOfSensitiveTriangle.hxx>
#include <Select3D_SensitiveBox.hxx>
-#include <Select3D_ListIteratorOfListOfSensitiveTriangle.hxx>
+#include <SelectMgr_Selection.hxx>
+#include <SelectMgr_EntityOwner.hxx>
-#include <SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation.hxx>
#include <Aspect_Grid.hxx>
#include <Aspect_TypeOfMarker.hxx>
+#include <Aspect_Window.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_ArrayOfPoints.hxx>
-#include <SelectBasics_ListIteratorOfListOfBox2d.hxx>
#include <Poly_Connect.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <V3d_Viewer.hxx>
#include <TColgp_SequenceOfPnt.hxx>
+#include <OSD_Timer.hxx>
+
+
static Standard_Integer StdSel_NumberOfFreeEdges (const Handle(Poly_Triangulation)& Trg)
{
Standard_Integer nFree = 0;
// Function : Constructor
// Purpose :
//=======================================================================
-StdSelect_ViewerSelector3d::StdSelect_ViewerSelector3d()
-: myProjector (new Select3D_Projector()),
- myPrevFOV (0.0),
- myPrevScale (0.0),
- myPrevOrthographic (Standard_True),
- mySensMode (StdSelect_SM_WINDOW),
- myPixelTolerance (2),
- myToUpdateTolerance (Standard_True)
-{
- myPrevAt[0] = 0.0;
- myPrevAt[1] = 0.0;
- myPrevAt[2] = 0.0;
- myPrevUp[0] = 0.0;
- myPrevUp[1] = 0.0;
- myPrevUp[2] = 0.0;
- myPrevProj[0] = 0.0;
- myPrevProj[1] = 0.0;
- myPrevProj[2] = 0.0;
- myPrevAxialScale[0] = 0.0;
- myPrevAxialScale[1] = 0.0;
- myPrevAxialScale[2] = 0.0;
-}
-
-//=======================================================================
-// Function : Constructor
-// Purpose :
-//=======================================================================
-StdSelect_ViewerSelector3d::StdSelect_ViewerSelector3d (const Handle(Select3D_Projector)& theProj)
-: myProjector (theProj),
- myPrevFOV (0.0),
- myPrevScale (0.0),
- myPrevOrthographic (Standard_True),
- mySensMode (StdSelect_SM_WINDOW),
- myPixelTolerance (2),
- myToUpdateTolerance (Standard_True)
-{
- myPrevAt[0] = 0.0;
- myPrevAt[1] = 0.0;
- myPrevAt[2] = 0.0;
- myPrevUp[0] = 0.0;
- myPrevUp[1] = 0.0;
- myPrevUp[2] = 0.0;
- myPrevProj[0] = 0.0;
- myPrevProj[1] = 0.0;
- myPrevProj[2] = 0.0;
- myPrevAxialScale[0] = 0.0;
- myPrevAxialScale[1] = 0.0;
- myPrevAxialScale[2] = 0.0;
-}
-
-//=======================================================================
-// Function: Convert
-// Purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::Convert (const Handle(SelectMgr_Selection)& theSel)
-{
- for (theSel->Init(); theSel->More(); theSel->Next())
- {
- if (theSel->Sensitive()->NeedsConversion())
- {
- Handle(Select3D_SensitiveEntity) aSE = *((Handle(Select3D_SensitiveEntity)*) &(theSel->Sensitive()));
- aSE->Project (myProjector);
- if (!tosort)
- {
- tosort = Standard_True;
- }
- }
- }
-}
-
-//=======================================================================
-// Function: Set
-// Purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::Set (const Handle(Select3D_Projector)& theProj)
-{
- myProjector = theProj;
- toupdate = Standard_True;
-}
-
-//=======================================================================
-// Function: SetSensitivityMode
-// Purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::SetSensitivityMode (const StdSelect_SensitivityMode theMode)
-{
- mySensMode = theMode;
- toupdate = Standard_True;
-}
+StdSelect_ViewerSelector3d::StdSelect_ViewerSelector3d() {}
//=======================================================================
// Function: SetPixelTolerance
// Purpose :
//=======================================================================
-void StdSelect_ViewerSelector3d::SetPixelTolerance (const Standard_Integer theTolerance)
+void StdSelect_ViewerSelector3d::SetPixelTolerance (const Standard_Real theTolerance)
{
- if (myPixelTolerance != theTolerance)
+ if (mytolerance != theTolerance)
{
- myPixelTolerance = theTolerance;
+ if (theTolerance < 0.0)
+ myTolerances.ResetDefaults();
+ else
+ myTolerances.SetCustomTolerance (theTolerance);
+ mytolerance = myTolerances.Tolerance();
myToUpdateTolerance = Standard_True;
}
}
const Handle(V3d_View)& theView)
{
SetClipping (theView->GetClipPlanes());
- UpdateProj (theView);
- Standard_Real aPnt3d[3];
- theView->Convert (theXPix, theYPix,
- aPnt3d[0], aPnt3d[1], aPnt3d[2]);
- gp_Pnt2d aPnt2d;
- myProjector->Project (gp_Pnt (aPnt3d[0], aPnt3d[1], aPnt3d[2]), aPnt2d);
+ if(myToUpdateTolerance)
+ {
+ mySelectingVolumeMgr.SetPixelTolerance (mytolerance);
+ myToUpdateTolerance = Standard_False;
+ }
+
+ mySelectingVolumeMgr.SetCamera (theView->Camera());
+ mySelectingVolumeMgr.SetActiveSelectionType (SelectMgr_SelectingVolumeManager::Point);
+ Standard_Integer aWidth = 0, aHeight = 0;
+ theView->Window()->Size (aWidth, aHeight);
+ mySelectingVolumeMgr.SetWindowSize (aWidth, aHeight);
+ gp_Pnt2d aMousePos (static_cast<Standard_Real> (theXPix),
+ static_cast<Standard_Real> (theYPix));
+ mySelectingVolumeMgr.BuildSelectingVolume (aMousePos);
- InitSelect (aPnt2d.X(), aPnt2d.Y());
+ TraverseSensitives();
}
//=======================================================================
const Standard_Integer theYPMax,
const Handle(V3d_View)& theView)
{
- if (myToUpdateTolerance && SensitivityMode() == StdSelect_SM_WINDOW)
- {
- SetSensitivity (theView->Convert (myPixelTolerance));
- myToUpdateTolerance = Standard_False;
- }
-
- UpdateProj (theView);
-
- Standard_Real aX1 = 0.0;
- Standard_Real aY1 = 0.0;
- Standard_Real aZ1 = 0.0;
- Standard_Real aX2 = 0.0;
- Standard_Real aY2 = 0.0;
- Standard_Real aZ2 = 0.0;
- gp_Pnt2d aP2d1;
- gp_Pnt2d aP2d2;
-
- theView->Convert (theXPMin, theYPMin, aX1, aY1, aZ1);
- theView->Convert (theXPMax, theYPMax, aX2, aY2, aZ2);
- myProjector->Project (gp_Pnt (aX1, aY1, aZ1), aP2d1);
- myProjector->Project (gp_Pnt (aX2, aY2, aZ2), aP2d2);
-
- InitSelect (Min (aP2d1.X(), aP2d2.X()),
- Min (aP2d1.Y(), aP2d2.Y()),
- Max (aP2d1.X(), aP2d2.X()),
- Max (aP2d1.Y(), aP2d2.Y()));
+ mySelectingVolumeMgr.SetCamera (theView->Camera());
+ mySelectingVolumeMgr.SetActiveSelectionType (SelectMgr_SelectingVolumeManager::Box);
+ Standard_Integer aWidth = 0, aHeight = 0;
+ theView->Window()->Size (aWidth, aHeight);
+ mySelectingVolumeMgr.SetWindowSize (aWidth, aHeight);
+ gp_Pnt2d aMinMousePos (static_cast<Standard_Real> (theXPMin),
+ static_cast<Standard_Real> (theYPMin));
+ gp_Pnt2d aMaxMousePos (static_cast<Standard_Real> (theXPMax),
+ static_cast<Standard_Real> (theYPMax));
+ mySelectingVolumeMgr.BuildSelectingVolume (aMinMousePos,
+ aMaxMousePos);
+
+ TraverseSensitives();
}
//=======================================================================
void StdSelect_ViewerSelector3d::Pick (const TColgp_Array1OfPnt2d& thePolyline,
const Handle(V3d_View)& theView)
{
- if (myToUpdateTolerance && SensitivityMode() == StdSelect_SM_WINDOW)
- {
- SetSensitivity (theView->Convert (myPixelTolerance));
- myToUpdateTolerance = Standard_False;
- }
-
- UpdateProj (theView);
-
- Standard_Integer aNbPix = thePolyline.Length();
-
- // Convert pixel
- Handle(TColgp_HArray1OfPnt2d) aP2d = new TColgp_HArray1OfPnt2d (1, aNbPix);
-
- for (Standard_Integer aPntIt = 1; aPntIt <= aNbPix; ++aPntIt)
- {
- Standard_Integer aXP = (Standard_Integer)(thePolyline (aPntIt).X());
- Standard_Integer aYP = (Standard_Integer)(thePolyline (aPntIt).Y());
-
- Standard_Real aX = 0.0;
- Standard_Real aY = 0.0;
- Standard_Real aZ = 0.0;
- gp_Pnt2d aPnt2d;
-
- theView->Convert (aXP, aYP, aX, aY, aZ);
- myProjector->Project (gp_Pnt (aX, aY, aZ), aPnt2d);
-
- aP2d->SetValue (aPntIt, aPnt2d);
- }
-
- const TColgp_Array1OfPnt2d& aPolyConvert = aP2d->Array1();
-
- InitSelect (aPolyConvert);
+ mySelectingVolumeMgr.SetCamera (theView->Camera());
+ mySelectingVolumeMgr.SetActiveSelectionType (SelectMgr_SelectingVolumeManager::Polyline);
+ Standard_Integer aWidth = 0, aHeight = 0;
+ theView->Window()->Size (aWidth, aHeight);
+ mySelectingVolumeMgr.SetWindowSize (aWidth, aHeight);
+ mySelectingVolumeMgr.BuildSelectingVolume (thePolyline);
+
+ TraverseSensitives();
}
-//=======================================================================
-// Function: DisplayAreas
-// Purpose : display the activated areas...
-//=======================================================================
-void StdSelect_ViewerSelector3d::DisplayAreas (const Handle(V3d_View)& theView)
-{
- if (myToUpdateTolerance && SensitivityMode() == StdSelect_SM_WINDOW)
- {
- SetSensitivity (theView->Convert (myPixelTolerance));
- myToUpdateTolerance = Standard_False;
- }
-
- UpdateProj (theView);
- UpdateSort(); // Updates the activated areas
-
- if (mystruct.IsNull())
- {
- mystruct = new Graphic3d_Structure (theView->Viewer()->Viewer());
- }
-
- if (myareagroup.IsNull())
- {
- myareagroup = mystruct->NewGroup();
- }
-
- SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive anIt (myentities);
- Handle(Select3D_Projector) aProjector = StdSelect::GetProjector (theView);
- aProjector->SetView (theView);
-
- Standard_Real aXmin = 0.0;
- Standard_Real aYmin = 0.0;
- Standard_Real aXmax = 0.0;
- Standard_Real aYmax = 0.0;
- gp_Pnt aPbid;
- SelectBasics_ListOfBox2d aBoxList;
-
- TColgp_SequenceOfPnt aSeqLines;
- for (; anIt.More(); anIt.Next())
- {
- anIt.Value()->Areas (aBoxList);
-
- for (SelectBasics_ListIteratorOfListOfBox2d aBoxIt (aBoxList); aBoxIt.More(); aBoxIt.Next())
- {
- aBoxIt.Value().Get (aXmin, aYmin, aXmax, aYmax);
-
- aPbid.SetCoord (aXmin - mytolerance, aYmin - mytolerance, 0.0);
- aProjector->Transform (aPbid, aProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
-
- aPbid.SetCoord (aXmax + mytolerance, aYmin - mytolerance, 0.0);
- aProjector->Transform (aPbid, aProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
-
- aPbid.SetCoord (aXmax + mytolerance, aYmax + mytolerance, 0.0);
- aProjector->Transform (aPbid, aProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
-
- aPbid.SetCoord (aXmin - mytolerance, aYmax + mytolerance, 0.0);
- aProjector->Transform (aPbid, aProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
- }
- }
-
- if (aSeqLines.Length())
- {
- Standard_Integer aN = 0;
- Standard_Integer aNp = 0;
- const Standard_Integer aNbl = aSeqLines.Length() / 4;
-
- Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines (5 * aNbl, aNbl);
- for (aNp = 1, aN = 0; aN < aNbl; aN++)
- {
- aPrims->AddBound (5);
- const gp_Pnt &aPnt1 = aSeqLines (aNp++);
- aPrims->AddVertex (aPnt1);
- aPrims->AddVertex (aSeqLines (aNp++));
- aPrims->AddVertex (aSeqLines (aNp++));
- aPrims->AddVertex (aSeqLines (aNp++));
- aPrims->AddVertex (aPnt1);
- }
- myareagroup->AddPrimitiveArray (aPrims);
- }
-
- myareagroup->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (Quantity_NOC_AQUAMARINE1, Aspect_TOL_DASH, 1.0));
- myareagroup->Structure()->SetDisplayPriority (10);
- myareagroup->Structure()->Display();
-
- theView->Update();
-}
-
-//=======================================================================
-// Function: ClearAreas
-// Purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::ClearAreas (const Handle(V3d_View)& theView)
-{
- if (myareagroup.IsNull())
- {
- return;
- }
-
- myareagroup->Clear();
-
- if (!theView.IsNull())
- {
- theView->Update();
- }
-}
-
-//=======================================================================
-// Function: UpdateProj
-// Purpose :
-//=======================================================================
-Standard_Boolean StdSelect_ViewerSelector3d::UpdateProj (const Handle(V3d_View)& theView)
-{
- // Check common properties of camera
- Standard_Real anUp[3];
- Standard_Real aProj[3];
- Standard_Real anAxialScale[3];
- theView->Up (anUp[0], anUp[1], anUp[2]);
- theView->Proj (aProj[0], aProj[1], aProj[2]);
- theView->AxialScale (anAxialScale[0], anAxialScale[1], anAxialScale[2]);
-
- Standard_Boolean isOrthographic = theView->Type() == V3d_ORTHOGRAPHIC;
- Standard_Boolean toUpdateProjector = myPrevOrthographic != isOrthographic
- || myPrevUp[0] != anUp[0]
- || myPrevUp[1] != anUp[1]
- || myPrevUp[2] != anUp[2]
- || myPrevProj[0] != aProj[0]
- || myPrevProj[1] != aProj[1]
- || myPrevProj[2] != aProj[2]
- || myPrevAxialScale[0] != anAxialScale[0]
- || myPrevAxialScale[1] != anAxialScale[1]
- || myPrevAxialScale[2] != anAxialScale[2];
-
- // Check properties of perspective camera
- Standard_Real anAt[3];
- Standard_Real aScale = theView->Scale();
- Standard_Real aFOV = theView->Camera()->FOVy();
- theView->At (anAt[0], anAt[1], anAt[2]);
- if (!isOrthographic && !toUpdateProjector)
- {
- toUpdateProjector = myPrevAt[0] != anAt[0]
- || myPrevAt[1] != anAt[1]
- || myPrevAt[2] != anAt[2]
- || myPrevScale != aScale
- || myPrevFOV != aFOV;
- }
-
- myToUpdateTolerance = aScale != myPrevScale;
-
- // Update projector if anything changed
- if (toUpdateProjector)
- {
- toupdate = Standard_True;
-
- myToUpdateTolerance = Standard_True;
-
- if (isOrthographic)
- {
- // For orthographic view use only direction of projection and up vector
- // Panning, and zooming has no effect on 2D selection sensitives.
- Handle (Graphic3d_Camera) aCamera = new Graphic3d_Camera();
-
- aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
- aCamera->SetCenter (gp::Origin());
- aCamera->SetDirection (gp_Dir (-aProj[0], -aProj[1], -aProj[2]));
- aCamera->SetUp (gp_Dir (anUp[0], anUp[1], anUp[2]));
- aCamera->SetDistance (1.0);
- aCamera->SetAxialScale (gp_XYZ (anAxialScale[0], anAxialScale[1], anAxialScale[2]));
-
- myProjector = new Select3D_Projector (aCamera->OrientationMatrix(), Graphic3d_Mat4d());
- }
- else
- {
- // For perspective projection panning, zooming and location of view
- // has effect. Thus, use current view and projection matrices from
- // view camera. Exception is that the projection transformation
- // is scaled from NDC to size of displaying frame of view space in order
- // to maintain consistence with pixel tolerance conversion.
- const Graphic3d_Mat4d& aMVMatrix = theView->Camera()->OrientationMatrix();
- const Graphic3d_Mat4d& aProjMatrix = theView->Camera()->ProjectionMatrix();
- gp_XYZ aViewDimensions = theView->Camera()->ViewDimensions();
-
- Graphic3d_Mat4d aScaledProj;
- aScaledProj.ChangeValue (0, 0) = aViewDimensions.X();
- aScaledProj.ChangeValue (1, 1) = aViewDimensions.Y();
- aScaledProj.ChangeValue (2, 2) = aViewDimensions.Z();
- Graphic3d_Mat4d aScaledProjMatrix = aScaledProj * aProjMatrix;
-
- Standard_Real aZNear = theView->Camera()->ZNear();
- Standard_Real aZFar = theView->Camera()->ZFar();
-
- myProjector = new Select3D_Projector (aMVMatrix, aScaledProjMatrix, aZNear, aZFar);
- }
- }
-
- myPrevAt[0] = anAt[0];
- myPrevAt[1] = anAt[1];
- myPrevAt[2] = anAt[2];
- myPrevUp[0] = anUp[0];
- myPrevUp[1] = anUp[1];
- myPrevUp[2] = anUp[2];
- myPrevProj[0] = aProj[0];
- myPrevProj[1] = aProj[1];
- myPrevProj[2] = aProj[2];
- myPrevAxialScale[0] = anAxialScale[0];
- myPrevAxialScale[1] = anAxialScale[1];
- myPrevAxialScale[2] = anAxialScale[2];
- myPrevFOV = aFOV;
- myPrevScale = aScale;
- myPrevOrthographic = isOrthographic;
-
- if (myToUpdateTolerance && SensitivityMode() == StdSelect_SM_WINDOW)
- {
- SetSensitivity (theView->Convert (myPixelTolerance));
- myToUpdateTolerance = Standard_False;
- }
-
- if (toupdate)
- {
- UpdateConversion();
- }
-
- if (tosort)
- {
- UpdateSort();
- }
-
- return Standard_True;
-}
-
-
//=======================================================================
// Function: DisplaySensitive.
// Purpose : Display active primitives.
//=======================================================================
void StdSelect_ViewerSelector3d::DisplaySensitive (const Handle(V3d_View)& theView)
{
- if (myToUpdateTolerance && SensitivityMode() == StdSelect_SM_WINDOW)
- {
- SetSensitivity (theView->Convert (myPixelTolerance));
- myToUpdateTolerance = Standard_False;
- }
-
- if (toupdate)
- {
- UpdateProj (theView);
- }
-
- if (tosort)
- {
- UpdateSort(); // Updates the activated areas
- }
-
// Preparation des structures
if (mystruct.IsNull())
{
mysensgroup->SetPrimitivesAspect (
new Graphic3d_AspectLine3d (Quantity_NOC_GRAY40, Aspect_TOL_SOLID, 2.0));
- SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation anIt (myselections);
-
- for (; anIt.More(); anIt.Next())
+ for (Standard_Integer anObjectIdx = 0; anObjectIdx <= mySelectableObjects->Size(); ++anObjectIdx)
{
- if (anIt.Value()==0)
+ const Handle (SelectMgr_SelectableObject)& anObject = mySelectableObjects->GetObjectById (anObjectIdx);
+ for (anObject->Init(); anObject->More(); anObject->Next())
{
- const Handle(SelectMgr_Selection)& aSel = anIt.Key();
- ComputeSensitivePrs (aSel);
+ if (anObject->CurrentSelection()->GetSelectionState() == SelectMgr_SOS_Activated)
+ {
+ ComputeSensitivePrs (anObject->CurrentSelection(), anObject->Transformation());
+ }
}
}
//purpose :
//=======================================================================
void StdSelect_ViewerSelector3d::DisplaySensitive (const Handle(SelectMgr_Selection)& theSel,
+ const gp_Trsf& theTrsf,
const Handle(V3d_View)& theView,
const Standard_Boolean theToClearOthers)
{
mysensgroup->Clear();
}
- ComputeSensitivePrs (theSel);
-
- mystruct->SetDisplayPriority (10);
- mystruct->Display();
-
- theView->Update();
-}
-
-//=======================================================================
-//function : DisplayAreas
-//purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::DisplayAreas (const Handle(SelectMgr_Selection)& theSel,
- const Handle(V3d_View)& theView,
- const Standard_Boolean theToClearOthers)
-{
- if (mystruct.IsNull())
- {
- mystruct = new Graphic3d_Structure (theView->Viewer()->Viewer());
- }
-
- if (mysensgroup.IsNull())
- {
- myareagroup = mystruct->NewGroup();
- myareagroup->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (Quantity_NOC_AQUAMARINE1, Aspect_TOL_DASH, 1.0));
- }
-
- if (theToClearOthers)
- {
- myareagroup->Clear();
- }
-
- ComputeAreasPrs (theSel);
+ ComputeSensitivePrs (theSel, theTrsf);
mystruct->SetDisplayPriority (10);
mystruct->Display();
//function : ComputeSensitivePrs
//purpose :
//=======================================================================
-void StdSelect_ViewerSelector3d::ComputeSensitivePrs (const Handle(SelectMgr_Selection)& theSel)
+void StdSelect_ViewerSelector3d::ComputeSensitivePrs (const Handle(SelectMgr_Selection)& theSel,
+ const gp_Trsf& theLoc)
{
TColgp_SequenceOfPnt aSeqLines, aSeqFree;
TColStd_SequenceOfInteger aSeqBnds;
for (theSel->Init(); theSel->More(); theSel->Next())
{
- Handle(Select3D_SensitiveEntity) Ent = Handle(Select3D_SensitiveEntity)::DownCast(theSel->Sensitive());
- const Standard_Boolean hasloc = (Ent.IsNull()? Standard_False : Ent->HasLocation());
-
- TopLoc_Location theloc;
- if(hasloc)
- theloc = Ent->Location();
+ Handle(Select3D_SensitiveEntity) Ent =
+ Handle(Select3D_SensitiveEntity)::DownCast(theSel->Sensitive()->BaseSensitive());
+ const Standard_Boolean hasloc = theLoc.Form() != gp_Identity;
//==============
// Box
if(hasloc)
{
for (i = 0; i <= 7; i++)
- theboxpoint[i].Transform (theloc.Transformation());
+ theboxpoint[i].Transform (theLoc);
}
aSeqBnds.Append(5);
{
Handle(Select3D_SensitiveFace) aFace = Handle(Select3D_SensitiveFace)::DownCast(Ent);
Handle(TColgp_HArray1OfPnt) TheHPts;
- aFace->Points3D(TheHPts);
+ aFace->GetPoints(TheHPts);
const TColgp_Array1OfPnt& ThePts = TheHPts->Array1();
aSeqBnds.Append(ThePts.Length());
for (Standard_Integer I = ThePts.Lower(); I <= ThePts.Upper(); I++)
{
if (hasloc)
- aSeqLines.Append(ThePts(I).Transformed (theloc.Transformation()));
+ aSeqLines.Append(ThePts(I).Transformed (theLoc));
else
aSeqLines.Append(ThePts(I));
}
for (Standard_Integer I = ThePts.Lower(); I <= ThePts.Upper(); I++)
{
if (hasloc)
- aSeqLines.Append(ThePts(I).Transformed (theloc.Transformation()));
+ aSeqLines.Append(ThePts(I).Transformed (theLoc));
else
aSeqLines.Append(ThePts(I));
}
else if (Ent->DynamicType()==STANDARD_TYPE(Select3D_SensitiveWire))
{
Handle(Select3D_SensitiveWire) aWire = Handle(Select3D_SensitiveWire)::DownCast(Ent);
- Select3D_SensitiveEntitySequence EntitySeq;
- aWire->GetEdges (EntitySeq);
+ const NCollection_Vector<Handle(Select3D_SensitiveEntity)>& anEntities = aWire->GetEdges();
- for (int i = 1; i <= EntitySeq.Length(); i++)
+ for (int i = 0; i < anEntities.Length(); i++)
{
- Handle(Select3D_SensitiveEntity) SubEnt = Handle(Select3D_SensitiveEntity)::DownCast(EntitySeq.Value(i));
+ Handle(Select3D_SensitiveEntity) SubEnt = Handle(Select3D_SensitiveEntity)::DownCast(anEntities.Value(i));
//Segment
if (SubEnt->DynamicType()==STANDARD_TYPE(Select3D_SensitiveSegment))
gp_Pnt P2 (Handle(Select3D_SensitiveSegment)::DownCast(SubEnt)->EndPoint().XYZ());
if (hasloc)
{
- P1.Transform(theloc.Transformation());
- P2.Transform(theloc.Transformation());
+ P1.Transform(theLoc);
+ P2.Transform(theLoc);
}
aSeqBnds.Append(2);
aSeqLines.Append(P1);
if (hasloc)
{
- aPnts[0].Transform (theloc.Transformation());
- aPnts[1].Transform (theloc.Transformation());
- aPnts[2].Transform (theloc.Transformation());
+ aPnts[0].Transform (theLoc);
+ aPnts[1].Transform (theLoc);
+ aPnts[2].Transform (theLoc);
}
aSeqBnds.Append (4);
for (Standard_Integer I = ThePts.Lower(); I <= ThePts.Upper(); I++)
{
if (hasloc)
- aSeqLines.Append(ThePts(I).Transformed (theloc.Transformation()));
+ aSeqLines.Append(ThePts(I).Transformed (theLoc));
else
aSeqLines.Append(ThePts(I));
}
gp_Pnt P2 (Handle(Select3D_SensitiveSegment)::DownCast(Ent)->EndPoint().XYZ());
if (hasloc)
{
- P1.Transform (theloc.Transformation());
- P2.Transform (theloc.Transformation());
+ P1.Transform (theLoc);
+ P2.Transform (theLoc);
}
aSeqBnds.Append(2);
aSeqLines.Append(P1);
if (hasloc)
{
- aPnts[0].Transform (theloc.Transformation());
- aPnts[1].Transform (theloc.Transformation());
- aPnts[2].Transform (theloc.Transformation());
+ aPnts[0].Transform (theLoc);
+ aPnts[1].Transform (theLoc);
+ aPnts[2].Transform (theLoc);
}
aSeqBnds.Append (4);
{
gp_Pnt P = hasloc ?
Handle(Select3D_SensitivePoint)::DownCast(Ent)->Point() :
- Handle(Select3D_SensitivePoint)::DownCast(Ent)->Point().Transformed (theloc.Transformation());
+ Handle(Select3D_SensitivePoint)::DownCast(Ent)->Point().Transformed (theLoc);
Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
anArrayOfPoints->AddVertex (P.X(), P.Y(), P.Z());
mysensgroup->AddPrimitiveArray (anArrayOfPoints);
//==========================================================
else if (Ent->DynamicType()==STANDARD_TYPE(Select3D_SensitiveTriangulation))
{
- const Handle(Poly_Triangulation)& PT =
- (*((Handle(Select3D_SensitiveTriangulation)*) &Ent))->Triangulation();
+ Handle(Poly_Triangulation) PT (Handle(Select3D_SensitiveTriangulation)::DownCast (Ent)->Triangulation());
const Poly_Array1OfTriangle& triangles = PT->Triangles();
const TColgp_Array1OfPnt& Nodes = PT->Nodes();
Standard_Integer n[3];
TopLoc_Location iloc, bidloc;
- if ((*((Handle(Select3D_SensitiveTriangulation)*) &Ent))->HasInitLocation())
- bidloc = (*((Handle(Select3D_SensitiveTriangulation)*) &Ent))->GetInitLocation();
+ if (Handle(Select3D_SensitiveTriangulation)::DownCast (Ent)->HasInitLocation())
+ bidloc = Handle(Select3D_SensitiveTriangulation)::DownCast (Ent)->GetInitLocation();
if (bidloc.IsIdentity())
- iloc = theloc;
+ iloc = theLoc;
else
- iloc = theloc * bidloc;
+ iloc = theLoc * bidloc;
Standard_Integer i;
for (i = 1; i <= PT->NbTriangles(); i++)
}
}
-//=======================================================================
-//function : ComputeAreaPrs
-//purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::ComputeAreasPrs (const Handle(SelectMgr_Selection)& theSel)
-{
- Standard_Real aXmin = 0.0;
- Standard_Real aYmin = 0.0;
- Standard_Real aXmax = 0.0;
- Standard_Real aYmax = 0.0;
-
- gp_Pnt aPbid;
- SelectBasics_ListOfBox2d aBoxList;
-
- TColgp_SequenceOfPnt aSeqLines;
- for (theSel->Init(); theSel->More(); theSel->Next())
- {
- theSel->Sensitive()->Areas (aBoxList);
- for (SelectBasics_ListIteratorOfListOfBox2d aBoxIt (aBoxList); aBoxIt.More(); aBoxIt.Next())
- {
- aBoxIt.Value().Get (aXmin, aYmin, aXmax, aYmax);
-
- aPbid.SetCoord (aXmin - mytolerance, aYmin - mytolerance, 0.0);
- myProjector->Transform (aPbid, myProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
-
- aPbid.SetCoord (aXmax + mytolerance, aYmin - mytolerance, 0.0);
- myProjector->Transform (aPbid, myProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
-
- aPbid.SetCoord (aXmax + mytolerance, aYmax + mytolerance, 0.0);
- myProjector->Transform (aPbid, myProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
-
- aPbid.SetCoord (aXmin - mytolerance, aYmax + mytolerance, 0.0);
- myProjector->Transform (aPbid, myProjector->InvertedTransformation());
- aSeqLines.Append (aPbid);
- }
- }
-
- if (aSeqLines.Length())
- {
- Standard_Integer aN = 0;
- Standard_Integer aNP = 0;
- const Standard_Integer aNBL = aSeqLines.Length() / 4;
- Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines (5 * aNBL, aNBL);
- for (aNP = 1, aN = 0; aN < aNBL; aN++)
- {
- aPrims->AddBound (5);
- const gp_Pnt &aP1 = aSeqLines (aNP++);
- aPrims->AddVertex (aP1);
- aPrims->AddVertex (aSeqLines (aNP++));
- aPrims->AddVertex (aSeqLines (aNP++));
- aPrims->AddVertex (aSeqLines (aNP++));
- aPrims->AddVertex (aP1);
- }
- myareagroup->AddPrimitiveArray (aPrims);
- }
-}
-
//=======================================================================
//function : SetClipping
//purpose :
}
//=======================================================================
-//function : ComputeClipRange
+//function : HasDepthClipping
//purpose :
//=======================================================================
-void StdSelect_ViewerSelector3d::ComputeClipRange (const Graphic3d_SequenceOfHClipPlane& thePlanes,
- const gp_Lin& thePickLine,
- Standard_Real& theDepthMin,
- Standard_Real& theDepthMax) const
+Standard_Boolean StdSelect_ViewerSelector3d::HasDepthClipping (const Handle(SelectMgr_EntityOwner)& theOwner) const
{
- theDepthMin = RealFirst();
- theDepthMax = RealLast();
- Standard_Real aPlaneA, aPlaneB, aPlaneC, aPlaneD;
-
- Graphic3d_SequenceOfHClipPlane::Iterator aPlaneIt (thePlanes);
- for (; aPlaneIt.More(); aPlaneIt.Next())
+ if (!theOwner->HasSelectable())
{
- const Handle(Graphic3d_ClipPlane)& aClipPlane = aPlaneIt.Value();
- if (!aClipPlane->IsOn())
- continue;
-
- gp_Pln aGeomPlane = aClipPlane->ToPlane();
-
- aGeomPlane.Coefficients (aPlaneA, aPlaneB, aPlaneC, aPlaneD);
-
- const gp_Dir& aPlaneDir = aGeomPlane.Axis().Direction();
- const gp_Dir& aPickDir = thePickLine.Direction();
- const gp_XYZ& aPntOnLine = thePickLine.Location().XYZ();
- const gp_XYZ& aPlaneDirXYZ = aPlaneDir.XYZ();
-
- Standard_Real aDotProduct = aPickDir.Dot (aPlaneDir);
- Standard_Real aDistance = -(aPntOnLine.Dot (aPlaneDirXYZ) + aPlaneD);
-
- // check whether the pick line is parallel to clip plane
- if (Abs (aDotProduct) < Precision::Angular())
- {
- if (aDistance > 0.0)
- {
- // line lies above the plane, thus no selection is possible
- theDepthMin = 0.0;
- theDepthMax = 0.0;
- return;
- }
-
- // line lies below the plane and is not clipped, skip
- continue;
- }
-
- // compute distance to point of pick line intersection with the plane
- Standard_Real aIntDist = aDistance / aDotProduct;
-
- // change depth limits for case of opposite and directed planes
- if (aDotProduct < 0.0)
- {
- theDepthMax = Min (aIntDist, theDepthMax);
- }
- else if (aIntDist > theDepthMin)
- {
- theDepthMin = Max (aIntDist, theDepthMin);
- }
+ return Standard_False;
}
-}
-//=======================================================================
-//function : PickingLine
-//purpose :
-//=======================================================================
-gp_Lin StdSelect_ViewerSelector3d::PickingLine(const Standard_Real theX, const Standard_Real theY) const
-{
- return myProjector->Shoot (theX, theY);
-}
-
-//=======================================================================
-//function : DepthClipping
-//purpose :
-//=======================================================================
-void StdSelect_ViewerSelector3d::DepthClipping (const Standard_Real theX,
- const Standard_Real theY,
- Standard_Real& theDepthMin,
- Standard_Real& theDepthMax) const
-{
- return ComputeClipRange (myClipPlanes, PickingLine (theX, theY), theDepthMin, theDepthMax);
+ const Handle(SelectMgr_SelectableObject)& aSelectable = theOwner->Selectable();
+ return (aSelectable->GetClipPlanes().Size() > 0);
}
//=======================================================================
-//function : DepthClipping
-//purpose :
+//function : ResetSelectionActivationStatus
+//purpose : Marks all sensitive entities, stored in viewer selector,
+// as inactive for selection
//=======================================================================
-void StdSelect_ViewerSelector3d::DepthClipping (const Standard_Real theX,
- const Standard_Real theY,
- const Handle(SelectMgr_EntityOwner)& theOwner,
- Standard_Real& theDepthMin,
- Standard_Real& theDepthMax) const
+void StdSelect_ViewerSelector3d::ResetSelectionActivationStatus()
{
- return ComputeClipRange (theOwner->Selectable()->GetClipPlanes(),
- PickingLine (theX, theY),
- theDepthMin, theDepthMax);
+ resetSelectionActivationStatus();
}
//=======================================================================
-//function : HasDepthClipping
-//purpose :
+//function : AllowOverlapDetection
+//purpose : Sets the detection type: if theIsToAllow is false,
+// only fully included sensitives will be detected, otherwise
+// the algorithm will mark both included and overlapped entities
+// as matched
//=======================================================================
-Standard_Boolean StdSelect_ViewerSelector3d::HasDepthClipping (const Handle(SelectMgr_EntityOwner)& theOwner) const
+void StdSelect_ViewerSelector3d::AllowOverlapDetection (const Standard_Boolean theIsToAllow)
{
- if (!theOwner->HasSelectable())
- {
- return Standard_False;
- }
-
- const Handle(SelectMgr_SelectableObject)& aSelectable = theOwner->Selectable();
- return (aSelectable->GetClipPlanes().Size() > 0);
+ mySelectingVolumeMgr.AllowOverlapDetection (theIsToAllow);
}
projects / occt.git / blobdiff