OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

OCC22357 Hidden face selection

Browse Source
This commit is contained in:
bugmaster 2011-04-28 15:57:34 +00:00 committed by bugmaster
parent 256d432045
commit 4952a30a49
32 changed files with 1565 additions and 1213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/AIS/AIS_InteractiveContext_2.cxx
View File

@ -20,8 +20,6 @@
#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
#include <AIS_Selection.hxx>
static TColStd_ListIteratorOfListOfInteger ItL;
//=======================================================================
//function : OpenLocalContext
//purpose :
@ -64,22 +62,14 @@ OpenLocalContext(const Standard_Boolean UseDisplayedObjects,
UseDisplayedObjects,
AllowShapeDecomposition,
AcceptEraseOfTemporary);
// rob 16/04/97 pour les Pbs d'ordres asynchrones
if(myLocalContexts.Extent()>0){
const Select3D_Projector& Prj = myLocalContexts(untilnow)->MainSelector()->Projector();
NewLocal->MainSelector()->Set(Prj);
}
else{
const Select3D_Projector& Prj = myMainSel->Projector();
NewLocal->MainSelector()->Set(Prj);
}
NewLocal->MainSelector()->Set ((myLocalContexts.Extent() > 0)
? myLocalContexts (untilnow)->MainSelector()->Projector()
: myMainSel->Projector());
NewLocal->MainSelector()->UpdateConversion();
myLocalContexts.Bind(myCurLocalIndex,NewLocal);
#ifdef DEB
cout<<"\tOpen Local Context No "<<myCurLocalIndex<<endl;
if(UseDisplayedObjects){
@ -93,7 +83,6 @@ OpenLocalContext(const Standard_Boolean UseDisplayedObjects,
cout<<"\t\tNo Objects Were Loaded "<<endl;
#endif
return myCurLocalIndex;
}
//=======================================================================
@ -268,6 +257,7 @@ Deactivate(const Handle(AIS_InteractiveObject)& anIObj)
{
if(!HasOpenedContext()){
if(!myObjects.IsBound(anIObj)) return;
TColStd_ListIteratorOfListOfInteger ItL;
for(ItL.Initialize(myObjects(anIObj)->SelectionModes());
ItL.More();
ItL.Next()){
@ -312,9 +302,9 @@ void AIS_InteractiveContext::
ActivatedModes(const Handle(AIS_InteractiveObject)& anIObj,
TColStd_ListOfInteger& theList) const
{
TColStd_ListIteratorOfListOfInteger ItL;
if(!HasOpenedContext()){
if(myObjects.IsBound(anIObj)){
//ItL est une variable statique...
for(ItL.Initialize(myObjects(anIObj)->SelectionModes());
ItL.More();
ItL.Next())
@ -393,6 +383,7 @@ SubIntensityOn(const Handle(AIS_InteractiveObject)& anIObj,
if(myObjects.IsBound(anIObj)){
const Handle(AIS_GlobalStatus)& STAT = myObjects(anIObj);
STAT->SubIntensityOn();
TColStd_ListIteratorOfListOfInteger ItL;
for (ItL.Initialize(STAT->DisplayedModes());ItL.More();ItL.Next())
myMainPM->Color(anIObj,mySubIntensity,ItL.Value());
}
@ -446,6 +437,7 @@ SubIntensityOff(const Handle(AIS_InteractiveObject)& anIObj,
if(myObjects.IsBound(anIObj)){
const Handle(AIS_GlobalStatus)& STAT = myObjects(anIObj);
STAT->SubIntensityOff();
TColStd_ListIteratorOfListOfInteger ItL;
for (ItL.Initialize(STAT->DisplayedModes());ItL.More();ItL.Next())
myMainPM->Unhighlight(anIObj,ItL.Value());
if(STAT->IsHilighted())
@ -489,11 +481,10 @@ void AIS_InteractiveContext::SubIntensityOn(const Standard_Boolean updateviewer)
//=======================================================================
void AIS_InteractiveContext::SubIntensityOff(const Standard_Boolean updateviewer)
{
if(!HasOpenedContext()) return;
AIS_DataMapIteratorOfDataMapOfIOStatus It (myObjects);
TColStd_ListIteratorOfListOfInteger ItL;
for(;It.More();It.Next()){
const Handle(AIS_GlobalStatus)& STAT = It.Value();
if(STAT->IsSubIntensityOn())

23
src/AIS/AIS_LocalContext.cxx
View File

@ -660,18 +660,21 @@ void AIS_LocalContext::RemoveFilter(const Handle(SelectMgr_Filter)& aFilter)
Standard_Boolean AIS_LocalContext::HasSameProjector(const Select3D_Projector& aPrj) const
Standard_Boolean AIS_LocalContext::HasSameProjector(const Handle(Select3D_Projector)& thePrj) const
{
const Select3D_Projector& CurPrj = myMainVS->Projector();
if(CurPrj.Perspective()!=aPrj.Perspective()) return Standard_False;
if(CurPrj.Perspective())
if(CurPrj.Focus()!=aPrj.Focus()) return Standard_False;
gp_GTrsf CurTrsf(CurPrj.Transformation());
gp_GTrsf PrjTrsf(aPrj.Transformation());
const Handle(Select3D_Projector)& aCurPrj = myMainVS->Projector();
if (aCurPrj->Perspective() != thePrj->Perspective())
return Standard_False;
if (aCurPrj->Perspective() && aCurPrj->Focus() != thePrj->Focus())
return Standard_False;
const gp_GTrsf& aCurTrsf = aCurPrj->Transformation();
const gp_GTrsf& aPrjTrsf = thePrj->Transformation();
for(Standard_Integer i=1;i<=3;i++){
for(Standard_Integer j=1;j<=3;j++){
if(CurTrsf.Value(i,j)!=PrjTrsf.Value(i,j))
for (Standard_Integer i = 1; i <= 3; ++i)
{
for (Standard_Integer j = 1; j <= 3 ; ++j)
{
if (aCurTrsf.Value (i, j) != aPrjTrsf.Value (i, j))
return Standard_False;
}
}

6
src/MeshVS/MeshVS_SensitiveFace.cxx
View File

@ -31,13 +31,13 @@ MeshVS_SensitiveFace::MeshVS_SensitiveFace (
// name : MeshVS_SensitiveFace::Project
// Purpose :
//=======================================================================
void MeshVS_SensitiveFace::Project( const Select3D_Projector& aProj )
void MeshVS_SensitiveFace::Project( const Handle(Select3D_Projector)& aProj )
{
Select3D_SensitiveFace::Project( aProj );
if ( HasLocation() )
aProj.Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
aProj->Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
else
aProj.Project( myCentre, myProjCentre );
aProj->Project( myCentre, myProjCentre );
}
//=======================================================================

10
src/MeshVS/MeshVS_SensitiveMesh.cxx
View File

@ -139,14 +139,14 @@ Handle(Select3D_SensitiveEntity) MeshVS_SensitiveMesh::GetConnected( const TopLo
//=======================================================================
Standard_Real MeshVS_SensitiveMesh::ComputeDepth( const gp_Lin& /*EyeLine*/ ) const
{
return 0.;
return Precision::Infinite();
}
//==================================================
// Function: ProjectOneCorner
// Purpose :
//==================================================
void MeshVS_SensitiveMesh::ProjectOneCorner(const Select3D_Projector& theProj,
void MeshVS_SensitiveMesh::ProjectOneCorner(const Handle(Select3D_Projector)& theProj,
const Standard_Real theX,
const Standard_Real theY,
const Standard_Real theZ)
@ -154,9 +154,9 @@ void MeshVS_SensitiveMesh::ProjectOneCorner(const Select3D_Projector& theProj,
gp_Pnt aPnt( theX, theY, theZ );
gp_Pnt2d aProjPnt;
if( HasLocation() )
theProj.Project( aPnt.Transformed(Location().Transformation()), aProjPnt );
theProj->Project( aPnt.Transformed(Location().Transformation()), aProjPnt );
else
theProj.Project( aPnt, aProjPnt );
theProj->Project( aPnt, aProjPnt );
mybox2d.Add( aProjPnt );
}
@ -164,7 +164,7 @@ void MeshVS_SensitiveMesh::ProjectOneCorner(const Select3D_Projector& theProj,
// Function: Project
// Purpose :
//==================================================
void MeshVS_SensitiveMesh::Project(const Select3D_Projector& aProj)
void MeshVS_SensitiveMesh::Project(const Handle(Select3D_Projector)& aProj)
{
Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...

13
src/MeshVS/MeshVS_SensitivePolyhedron.cxx
View File

@ -34,7 +34,7 @@ MeshVS_SensitivePolyhedron( const Handle( SelectBasics_EntityOwner )& Owner,
// Function : Project
// Purpose :
//================================================================
void MeshVS_SensitivePolyhedron::Project( const Select3D_Projector& aProjector )
void MeshVS_SensitivePolyhedron::Project( const Handle(Select3D_Projector)& aProjector )
{
Select3D_SensitiveEntity::Project( aProjector );
@ -55,9 +55,9 @@ void MeshVS_SensitivePolyhedron::Project( const Select3D_Projector& aProjector )
{
pnt = myNodes->Value( i );
if( !hasLoc )
aProjector.Project( pnt, proj );
aProjector->Project( pnt, proj );
else
aProjector.Project( pnt.Transformed( Location().Transformation() ), proj );
aProjector->Project( pnt.Transformed( Location().Transformation() ), proj );
myNodes2d->SetValue( i, proj.XY() );
myCenter += proj.XY();
@ -161,9 +161,10 @@ Standard_Boolean MeshVS_SensitivePolyhedron::Matches( const Standard_Real X,
}
if( inside )
Select3D_SensitiveEntity::Matches( X, Y, aTol, DMin );
return inside;
{
return Select3D_SensitiveEntity::Matches( X, Y, aTol, DMin );
}
return Standard_False;
}
//================================================================

6
src/MeshVS/MeshVS_SensitiveSegment.cxx
View File

@ -27,13 +27,13 @@ MeshVS_SensitiveSegment::MeshVS_SensitiveSegment (
// name : MeshVS_SensitiveSegment::Project
// Purpose :
//=======================================================================
void MeshVS_SensitiveSegment::Project( const Select3D_Projector& aProj )
void MeshVS_SensitiveSegment::Project( const Handle(Select3D_Projector)& aProj )
{
Select3D_SensitiveSegment::Project( aProj );
if ( HasLocation() )
aProj.Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
aProj->Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
else
aProj.Project( myCentre, myProjCentre );
aProj->Project( myCentre, myProjCentre );
}
//=======================================================================

20
src/OpenGl/OpenGl_togl_begin_immediat_mode.cxx
View File

@ -286,23 +286,19 @@ void EXPORT call_togl_clear_immediat_mode (
call_subr_displayCB(aview,OCC_REDRAW_WINDOW);
#endif
call_func_redraw_all_structs_end (aview->WsId, aFlush);
/*
After a redraw,
Made the back identical to the front buffer
*/
if( retainmode && (partial >= 0) )
TelCopyBuffers (aview->WsId, GL_FRONT, GL_BACK,
xm, ym, zm, XM, YM, ZM, partial);
// After a redraw,
// Made the back identical to the front buffer.
// Always perform full copy (partial update optimization is useless on mordern hardware)!
if (retainmode)
TelCopyBuffers (aview->WsId, GL_FRONT, GL_BACK, xm, ym, zm, XM, YM, ZM, 0);
#ifdef TRACE
printf(" $$$ REDRAW\n");
#endif
TelSetBackBufferRestored (TOn);
} else if( partial >= 0 ) {
/*
Restore pixels from the back buffer.
*/
TelCopyBuffers (aview->WsId, GL_BACK, GL_FRONT,
xm, ym, zm, XM, YM, ZM, partial);
// Restore pixels from the back buffer.
// Always perform full copy (partial update optimization is useless on mordern hardware)!
TelCopyBuffers (aview->WsId, GL_BACK, GL_FRONT, xm, ym, zm, XM, YM, ZM, 0);
}
TsmGetWSAttri (aview->WsId, WSTransient, &data);

16
src/Poly/Poly.cdl
View File

@ -1,5 +1,4 @@
-- -- File: Poly.cdl
-- File: Poly.cdl
-- Created: Mon Mar 6 09:38:50 1995
-- Author: Laurent PAINNOT
-- <lpa@metrox>
@ -161,4 +160,17 @@ is
---Purpose: Compute node normals for face triangulation
-- as mean normal of surrounding triangles
PointOnTriangle(P1, P2, P3, P: XY from gp; UV: out XY from gp)
returns Real;
---Purpose: Computes parameters of the point P on triangle
-- defined by points P1, P2, and P3, in 2d.
-- The parameters U and V are defined so that
-- P = P1 + U * (P2 - P1) + V * (P3 - P1),
-- with U >= 0, V >= 0, U + V <= 1.
-- If P is located outside of triangle, or triangle
-- is degenerated, the returned parameters correspond
-- to closest point, and returned value is square of
-- the distance from original point to triangle (0 if
-- point is inside).
end Poly;

107
src/Poly/Poly.cxx
View File

@ -25,8 +25,7 @@
//purpose : Join several triangulations to one new triangulation object
//=======================================================================
Handle(Poly_Triangulation) Poly::Catenate
(const Poly_ListOfTriangulation& lstTri)
Handle(Poly_Triangulation) Poly::Catenate (const Poly_ListOfTriangulation& lstTri)
{
Standard_Integer nNodes(0);
Standard_Integer nTrian(0);
@ -493,3 +492,107 @@ void Poly::ComputeNormals(const Handle(Poly_Triangulation)& Tri)
Tri->SetNormals(Normals);
}
//=======================================================================
//function : PointOnTriangle
//purpose :
//=======================================================================
Standard_Real Poly::PointOnTriangle (const gp_XY& theP1, const gp_XY& theP2, const gp_XY& theP3,
const gp_XY& theP, gp_XY& theUV)
{
gp_XY aDP = theP - theP1;
gp_XY aDU = theP2 - theP1;
gp_XY aDV = theP3 - theP1;
Standard_Real aDet = aDU ^ aDV;
// case of non-degenerated triangle
if ( Abs (aDet) > gp::Resolution() )
{
Standard_Real aU = (aDP ^ aDV) / aDet;
Standard_Real aV = -(aDP ^ aDU) / aDet;
// if point is inside triangle, just return parameters
if ( aU > -gp::Resolution() &&
aV > -gp::Resolution() &&
1. - aU - aV > -gp::Resolution() )
{
theUV.SetCoord (aU, aV);
return 0.;
}
// else find closest point on triangle sides; note that in general case
// triangle can be very distorted and it is necessary to check
// projection on all sides regardless of values of computed parameters
// project on side U=0
aU = 0.;
aV = Min (1., Max (0., (aDP * aDV) / aDV.SquareModulus()));
Standard_Real aD = (aV * aDV - aDP).SquareModulus();
// project on side V=0
Standard_Real u = Min (1., Max (0., (aDP * aDU) / aDU.SquareModulus()));
Standard_Real d = (u * aDU - aDP).SquareModulus();
if ( d < aD )
{
aU = u;
aV = 0.;
aD = d;
}
// project on side U+V=1
gp_XY aDUV = aDV - aDU;
Standard_Real v = Min (1., Max (0., ((aDP - aDU) * aDUV) / aDUV.SquareModulus()));
d = (theP2 + v * aDUV - theP).SquareModulus();
if ( d < aD )
{
aU = 1. - v;
aV = v;
aD = d;
}
theUV.SetCoord (aU, aV);
return aD;
}
// degenerated triangle
Standard_Real aL2U = aDU.SquareModulus();
Standard_Real aL2V = aDV.SquareModulus();
if ( aL2U < gp::Resolution() ) // side 1-2 is degenerated
{
if ( aL2V < gp::Resolution() ) // whole triangle is degenerated to point
{
theUV.SetCoord (0., 0.);
return (theP - theP1).SquareModulus();
}
else
{
theUV.SetCoord (0., (aDP * aDV) / aL2V);
return (theP - (theP1 + theUV.Y() * aDV)).SquareModulus();
}
}
else if ( aL2V < gp::Resolution() ) // side 1-3 is degenerated
{
theUV.SetCoord ((aDP * aDU) / aL2U, 0.);
return (theP - (theP1 + theUV.X() * aDU)).SquareModulus();
}
else // sides 1-2 and 1-3 are collinear
{
// select parameter on one of sides so as to have points closer to picked
Standard_Real aU = Min (1., Max (0., (aDP * aDU) / aL2U));
Standard_Real aV = Min (1., Max (0., (aDP * aDV) / aL2V));
Standard_Real aD1 = (aDP - aU * aDU).SquareModulus();
Standard_Real aD2 = (aDP - aV * aDV).SquareModulus();
if ( aD1 < aD2 )
{
theUV.SetCoord ((aDP * aDU) / aL2U, 0.);
return aD1;
}
else
{
theUV.SetCoord (0., (aDP * aDV) / aL2V);
return aD2;
}
}
}

3
src/QABUC/QABUC.cxx
View File

@ -758,7 +758,8 @@ static Standard_Integer BUC60698(Draw_Interpretor& di, Standard_Integer argc, co
gp_Pln thegpPln = gce_MakePln(gp_Pnt(0.5,0.5,0.5),gp_Dir(0,0,1));
Standard_Real A,B,C,D;
thegpPln.Coefficients(A,B,C,D);
Handle_V3d_Plane thePlane = new V3d_Plane(myAISContext->CurrentViewer(),A,B,C,D);
Handle_V3d_Plane thePlane = new V3d_Plane(A,B,C,D);
myAISContext->CurrentViewer()->AddPlane (thePlane); // add to defined planes list
for (myAISContext->CurrentViewer()->InitActiveViews();
myAISContext->CurrentViewer()->MoreActiveViews ();
myAISContext->CurrentViewer()->NextActiveViews ()) {

33
src/Select3D/Select3D_Projector.cdl
View File

@ -4,7 +4,7 @@
-- <cma@sdsun2> copie quasi exacte de HLRAlgo_Projector
---Copyright: Matra Datavision 1992
class Projector from Select3D
class Projector from Select3D inherits Transient from Standard
---Purpose: A framework to define 3D projectors.
uses
Real from Standard,
@ -59,17 +59,14 @@ is
---Purpose: build a Projector with automatic minmax directions.
returns Projector from Select3D;
Delete(me:out) is virtual;
---C++: alias "Standard_EXPORT virtual ~Select3D_Projector(){Delete() ; }"
Set (me: in out ;
Set (me : mutable;
T : Trsf from gp;
Persp : Boolean from Standard;
Focus : Real from Standard)
is static;
SetView(me:in out ; V : View from V3d);
SetView(me : mutable; V : View from V3d);
---Purpose: Sets the 3D view V used at the time of construction.
View(me) returns any View from V3d;
@ -82,7 +79,7 @@ is
---C++: inline
is virtual;
Scaled(me : in out; On : Boolean from Standard = Standard_False)
Scaled(me : mutable; On : Boolean from Standard = Standard_False)
---Purpose: to compute with the given scale and translation.
is virtual;
@ -152,7 +149,24 @@ is
-- 2d point <X,Y>.
is virtual;
SetDirection(me: in out)
DepthMin(me) returns Real from Standard;
---Purpose: Returns the minimum depth value (if clipping plane defined).
--- Should be used when call ::Shoot() to compute eyeline.
---C++: inline
DepthMax(me) returns Real from Standard;
---Purpose: Returns the maximum depth value (if clipping plane defined).
--- Should be used when call ::Shoot() to compute eyeline.
---C++: inline
DepthMinMax(me : mutable;
theDepthMin : in Real from Standard;
theDepthMax : in Real from Standard);
---Purpose: Setup the min/max depth values (doesn't affect
--- projection functionality itself).
--- Should be used when call ::Shoot() to compute eyeline.
SetDirection(me : mutable)
is static private;
Transform(me; P : in out Pnt from gp;
@ -177,7 +191,8 @@ fields
myD2 : Vec2d from gp is protected;
myD3 : Vec2d from gp is protected;
myView : View from V3d;
myDepthMin : Real from Standard;
myDepthMax : Real from Standard;
end Projector;

119
src/Select3D/Select3D_Projector.cxx
View File

@ -25,14 +25,15 @@
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector(const Handle(V3d_View)& aViou):
myPersp(aViou->Type()==V3d_PERSPECTIVE),
myFocus(aViou->Focale()),
myD1(1,0),
myD2(0,1),
myD3(1,1),
myView(aViou)
Select3D_Projector::Select3D_Projector(const Handle(V3d_View)& aViou)
: myPersp(aViou->Type()==V3d_PERSPECTIVE),
myFocus(aViou->Focale()),
myD1(1,0),
myD2(0,1),
myD3(1,1),
myView(aViou),
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
Standard_Real Xat,Yat,Zat,XUp,YUp,ZUp,DX,DY,DZ;
//Standard_Boolean Pers=Standard_False;
@ -51,8 +52,19 @@ myView(aViou)
}
Select3D_Projector::Select3D_Projector () :
myPersp(Standard_False),myFocus(0),myD1(1,0),myD2(0,1),myD3(1,1)
//=======================================================================
//function : Select3D_Projector
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector()
: myPersp(Standard_False),
myFocus(0),
myD1(1,0),
myD2(0,1),
myD3(1,1),
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
Scaled();
SetDirection();
@ -63,9 +75,11 @@ myPersp(Standard_False),myFocus(0),myD1(1,0),myD2(0,1),myD3(1,1)
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector
(const gp_Ax2& CS) :
myPersp(Standard_False), myFocus(0)
Select3D_Projector::Select3D_Projector (const gp_Ax2& CS)
: myPersp(Standard_False),
myFocus(0),
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
myScaledTrsf.SetTransformation(CS);
myGTrsf.SetTrsf(myScaledTrsf);
@ -78,29 +92,32 @@ Select3D_Projector::Select3D_Projector
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector
(const gp_Ax2& CS,
const Standard_Real Focus) :
myPersp(Standard_True), myFocus(Focus)
{
myScaledTrsf.SetTransformation(CS);
myGTrsf.SetTrsf(myScaledTrsf);
Scaled();
SetDirection();
}
//=======================================================================
//function : Select3D_Projector
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector
(const gp_Trsf& T,
const Standard_Boolean Persp,
const Standard_Real Focus) :
myPersp(Persp),
Select3D_Projector::Select3D_Projector (const gp_Ax2& CS,
const Standard_Real Focus)
: myPersp(Standard_True),
myFocus(Focus),
myScaledTrsf(T)
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
myScaledTrsf.SetTransformation(CS);
myGTrsf.SetTrsf(myScaledTrsf);
Scaled();
SetDirection();
}
//=======================================================================
//function : Select3D_Projector
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector (const gp_Trsf& T,
const Standard_Boolean Persp,
const Standard_Real Focus)
: myPersp(Persp),
myFocus(Focus),
myScaledTrsf(T),
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
myGTrsf.SetTrsf(myScaledTrsf);
Scaled();
@ -112,19 +129,20 @@ Select3D_Projector::Select3D_Projector
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector
(const gp_Trsf& T,
Select3D_Projector::Select3D_Projector (const gp_Trsf& T,
const Standard_Boolean Persp,
const Standard_Real Focus,
const gp_Vec2d& v1,
const gp_Vec2d& v2,
const gp_Vec2d& v3) :
myPersp(Persp),
const gp_Vec2d& v3)
: myPersp(Persp),
myFocus(Focus),
myScaledTrsf(T),
myD1(v1),
myD2(v2),
myD3(v3)
myD3(v3),
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
myGTrsf.SetTrsf(myScaledTrsf);
Scaled();
@ -135,21 +153,19 @@ Select3D_Projector::Select3D_Projector
//purpose :
//=======================================================================
Select3D_Projector::Select3D_Projector
(const gp_GTrsf& GT,
Select3D_Projector::Select3D_Projector (const gp_GTrsf& GT,
const Standard_Boolean Persp,
const Standard_Real Focus) :
myPersp(Persp),
const Standard_Real Focus)
: myPersp(Persp),
myFocus(Focus),
myGTrsf(GT)
myGTrsf(GT),
myDepthMin(-Precision::Infinite()),
myDepthMax( Precision::Infinite())
{
Scaled();
SetDirection();
}
void Select3D_Projector::Delete()
{}
//=======================================================================
//function : Set
//purpose :
@ -504,3 +520,10 @@ void Select3D_Projector::SetView(const Handle(V3d_View)& aViou)
Scaled();
}
void Select3D_Projector::DepthMinMax (const Standard_Real theDepthMin,
const Standard_Real theDepthMax)
{
myDepthMin = theDepthMin;
myDepthMax = theDepthMax;
}

8
src/Select3D/Select3D_Projector.lxx
View File

@ -124,4 +124,12 @@ inline void Select3D_Projector::Transform (gp_Pnt& Pnt, const gp_GTrsf& T) const
Pnt = gp_Pnt(xyz);
}
inline Standard_Real Select3D_Projector::DepthMin() const
{
return myDepthMin;
}
inline Standard_Real Select3D_Projector::DepthMax() const
{
return myDepthMax;
}

20
src/Select3D/Select3D_SensitiveBox.cxx
View File

@ -49,7 +49,7 @@ Select3D_SensitiveEntity(OwnerId)
// Purpose :
//==================================================
void Select3D_SensitiveBox::
Project(const Select3D_Projector& aProj)
Project(const Handle(Select3D_Projector)& aProj)
{
Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
@ -164,7 +164,7 @@ void Select3D_SensitiveBox::Dump(Standard_OStream& S,const Standard_Boolean Full
//purpose :
//=======================================================================
void Select3D_SensitiveBox::ProjectBox(const Select3D_Projector& aPrj,
void Select3D_SensitiveBox::ProjectBox(const Handle(Select3D_Projector)& aPrj,
const Bnd_Box& aBox)
{
mybox2d.SetVoid();
@ -172,21 +172,21 @@ void Select3D_SensitiveBox::ProjectBox(const Select3D_Projector& aPrj,
Standard_Real XMin,YMin,ZMin,XMax,YMax,ZMax;
aBox.Get(XMin,YMin,ZMin,XMax,YMax,ZMax);
aPrj.Project(gp_Pnt(XMin,YMin,ZMin),curp2d);
aPrj->Project(gp_Pnt(XMin,YMin,ZMin),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMax,YMin,ZMin),curp2d);
aPrj->Project(gp_Pnt(XMax,YMin,ZMin),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMax,YMax,ZMin),curp2d);
aPrj->Project(gp_Pnt(XMax,YMax,ZMin),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMin,YMax,ZMin),curp2d);
aPrj->Project(gp_Pnt(XMin,YMax,ZMin),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMin,YMin,ZMax),curp2d);
aPrj->Project(gp_Pnt(XMin,YMin,ZMax),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMax,YMin,ZMax),curp2d);
aPrj->Project(gp_Pnt(XMax,YMin,ZMax),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMax,YMax,ZMax),curp2d);
aPrj->Project(gp_Pnt(XMax,YMax,ZMax),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
aPrj.Project(gp_Pnt(XMin,YMax,ZMax),curp2d);
aPrj->Project(gp_Pnt(XMin,YMax,ZMax),curp2d);
mybox2d.Update(curp2d.X(),curp2d.Y());
}

14
src/Select3D/Select3D_SensitiveCurve.cxx
View File

@ -64,16 +64,18 @@ Standard_Boolean Select3D_SensitiveCurve
Standard_Integer Rank;
TColgp_Array1OfPnt2d aArrayOf2dPnt(1, mynbpoints);
Points2D(aArrayOf2dPnt);
Standard_Boolean KK = SelectBasics_BasicTool::MatchPolyg2d(aArrayOf2dPnt,
X,Y,
if (SelectBasics_BasicTool::MatchPolyg2d (aArrayOf2dPnt,
X, Y,
aTol,
DMin,
Rank);
if(KK){
Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
Rank))
{
mylastseg = Rank;
// compute and validate the depth (::Depth()) along the eyeline
return Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin);
}
return KK;
return Standard_False;
}
//==================================================

2
src/Select3D/Select3D_SensitiveEntity.cdl
View File

@ -146,7 +146,7 @@ is
fields
mylastprj : Address from Standard is protected;
mylastprj : Projector from Select3D is protected;
mylastdepth : ShortReal from Standard;
end SensitiveEntity;

35
src/Select3D/Select3D_SensitiveEntity.cxx
View File

@ -19,8 +19,8 @@
Select3D_SensitiveEntity::Select3D_SensitiveEntity(const Handle(SelectBasics_EntityOwner)& OwnerId):
SelectBasics_SensitiveEntity(OwnerId),
mylastprj(NULL),
mylastdepth(0.0)
mylastprj(),
mylastdepth(ShortRealLast())
{}
//=======================================================================
@ -28,9 +28,9 @@ mylastdepth(0.0)
//purpose :
//=======================================================================
void Select3D_SensitiveEntity::Project(const Select3D_Projector& aPrj)
void Select3D_SensitiveEntity::Project(const Handle(Select3D_Projector)& aPrj)
{
mylastprj = (Standard_Address*)&aPrj;
mylastprj = aPrj;
}
//=======================================================================
@ -43,12 +43,17 @@ Standard_Boolean Select3D_SensitiveEntity::Matches(const Standard_Real X,
const Standard_Real aTol,
Standard_Real& DMin)
{
gp_Lin L;
if(mylastprj!=NULL)
L = (* ((Select3D_Projector*) mylastprj)).Shoot(X,Y);
SetLastDepth( ComputeDepth(L) );
return (Abs(mylastdepth)>Precision::Confusion());
if (!mylastprj.IsNull())
{
gp_Lin L = mylastprj->Shoot (X, Y);
SetLastDepth (ComputeDepth (L));
return (mylastdepth > mylastprj->DepthMin()) && (mylastdepth < mylastprj->DepthMax());
}
else
{
SetLastDepth (ComputeDepth (gp_Lin())); // how we determine depth without eyeline here?
return (mylastdepth > ShortRealFirst()) && (mylastdepth < ShortRealLast());
}
}
//=======================================================================
@ -184,8 +189,10 @@ gp_Lin Select3D_SensitiveEntity::GetEyeLine(const Standard_Real X,
const Standard_Real Y) const
{
gp_Lin L;
if(mylastprj!=NULL)
L = (* ((Select3D_Projector*) mylastprj)).Shoot(X,Y);
if (!mylastprj.IsNull())
{
L = mylastprj->Shoot (X, Y);
}
return L;
}
@ -202,8 +209,8 @@ Standard_Integer Select3D_SensitiveEntity::MaxBoxes() const
//purpose :
//=======================================================================
void Select3D_SensitiveEntity::SetLastPrj(const Select3D_Projector& aprj)
{ mylastprj = (Standard_Address*)& aprj;}
void Select3D_SensitiveEntity::SetLastPrj(const Handle(Select3D_Projector)& aprj)
{ mylastprj = aprj; }
//=======================================================================

35
src/Select3D/Select3D_SensitiveFace.cxx
View File

@ -8,6 +8,7 @@
//Modif on jul-21-97 : changement en harray1 pour eventuelles connexions ...
#include <Select3D_SensitiveFace.ixx>
#include <Select3D_Projector.hxx>
#include <SelectBasics_BasicTool.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pnt.hxx>
@ -117,11 +118,9 @@ Matches(const Standard_Real X,
Standard_Real valtst = PlaneTest^V1;
if(isplane2d && Abs(valtst)>aTol) isplane2d=Standard_False;
}
if(isplane2d) {
Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
return Standard_True;
if (isplane2d)
{
return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
}
//detection d'une auto - intersection dans le polygon 2D; si oui on sort
// if (!AutoComputeFlag(myautointer)) {
@ -151,10 +150,11 @@ Matches(const Standard_Real X,
res = Standard_True;
}
}
if(res)
Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
return res;
if (res)
{
return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
}
return Standard_False;
}
//=======================================================================
@ -230,8 +230,17 @@ void Select3D_SensitiveFace::Dump(Standard_OStream& S,const Standard_Boolean Ful
//=======================================================================
Standard_Real Select3D_SensitiveFace::ComputeDepth(const gp_Lin& EyeLine) const
{
Standard_Real val(Precision::Infinite());
for(Standard_Integer i=0;i<mynbpoints-1;i++)
val = Min(val,ElCLib::Parameter(EyeLine,((Select3D_Pnt*)mypolyg3d)[i]));
return val;
Standard_Real aDepth = Precision::Infinite();
Standard_Real aDepthMin = !mylastprj.IsNull() ? mylastprj->DepthMin() : -Precision::Infinite();
Standard_Real aDepthMax = !mylastprj.IsNull() ? mylastprj->DepthMax() : Precision::Infinite();
Standard_Real aDepthTest;
for (Standard_Integer i = 0; i < mynbpoints - 1; i++)
{
aDepthTest = ElCLib::Parameter (EyeLine, ((Select3D_Pnt* )mypolyg3d)[i]);
if (aDepthTest < aDepth && (aDepthTest > aDepthMin) && (aDepthTest < aDepthMax))
{
aDepth = aDepthTest;
}
}
return aDepth;
}

45
src/Select3D/Select3D_SensitiveGroup.cxx
View File

@ -89,7 +89,7 @@ void Select3D_SensitiveGroup::Clear()
//purpose :
//=======================================================================
void Select3D_SensitiveGroup::Project(const Select3D_Projector& aProjector)
void Select3D_SensitiveGroup::Project(const Handle(Select3D_Projector)& aProjector)
{
Select3D_SensitiveEntity::Project(aProjector); // to set the field last proj...
@ -180,16 +180,16 @@ Standard_Boolean Select3D_SensitiveGroup::Matches(const Standard_Real X,
myLastTol = aTol;
for(Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next()){
myLastRank++;
if(It.Value()->Matches(X,Y,aTol,DMin)){
myX = X;myY = Y;myLastTol = aTol;
SetLastDepth( Precision::Infinite() );
Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
return Standard_True;
if (It.Value()->Matches (X, Y, aTol, DMin))
{
myX = X; myY = Y; myLastTol = aTol;
// compute and validate the depth (will call ::ComputeDepth())
return Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin);
}
}
myLastRank =0;
SetLastDepth(0.0);
// no match
myLastRank = 0;
SetLastDepth (ShortRealLast());
return Standard_False;
}
@ -258,18 +258,25 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
//=======================================================================
Standard_Real Select3D_SensitiveGroup::ComputeDepth(const gp_Lin& EyeLine) const
{
Standard_Integer currank(0);
Standard_Real DMin,thedepth(Precision::Infinite());
for(Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next()){
Standard_Integer currank = 0;
Standard_Real DMin, thedepth (Precision::Infinite());
for (Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next())
{
currank++;
if(currank>=myLastRank){
if(It.Value()->Matches(myX,myY,myLastTol,DMin)){
It.Value()->ComputeDepth(EyeLine);
thedepth = Min(Depth(),
It.Value()->Depth());
if (currank >= myLastRank)
{
// this recomputes and validates the depth for the entity
if (It.Value()->Matches (myX, myY, myLastTol, DMin))
{
It.Value()->ComputeDepth (EyeLine);
if (It.Value()->Depth() < thedepth)
{
// search for topmost entity
thedepth = It.Value()->Depth();
//myLastRank = currank; // can not do this here...
}
}
}
}
return thedepth;
}
@ -287,7 +294,7 @@ Standard_Integer Select3D_SensitiveGroup::MaxBoxes() const
return nbboxes;
}
void Select3D_SensitiveGroup::SetLastPrj(const Select3D_Projector& Prj)
void Select3D_SensitiveGroup::SetLastPrj(const Handle(Select3D_Projector)& Prj)
{
Select3D_SensitiveEntity::SetLastPrj(Prj);
for(Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next())

13
src/Select3D/Select3D_SensitivePoint.cxx
View File

@ -32,15 +32,15 @@ Select3D_SensitiveEntity(anOwner)
// Purpose :
//==================================================
void Select3D_SensitivePoint
::Project (const Select3D_Projector& aProj)
::Project (const Handle(Select3D_Projector)& aProj)
{
Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
gp_Pnt2d aPoint2d;
if(!HasLocation())
aProj.Project(mypoint, aPoint2d);
aProj->Project(mypoint, aPoint2d);
else{
gp_Pnt aP(mypoint.x, mypoint.y, mypoint.z);
aProj.Project(aP.Transformed(Location().Transformation()), aPoint2d);
aProj->Project(aP.Transformed(Location().Transformation()), aPoint2d);
}
myprojpt = aPoint2d;
}
@ -69,9 +69,10 @@ Standard_Boolean Select3D_SensitivePoint
Standard_Real& DMin)
{
DMin = gp_Pnt2d(X,Y).Distance(myprojpt);
if(DMin<=aTol*SensitivityFactor()) {
Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
return Standard_True;
if(DMin<=aTol*SensitivityFactor())
{
// compute and validate the depth (::Depth()) along the eyeline
return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
}
return Standard_False;
}

11
src/Select3D/Select3D_SensitivePoly.cxx
View File

@ -61,7 +61,7 @@ Select3D_SensitiveEntity(OwnerId)
// Purpose :
//==================================================
void Select3D_SensitivePoly::Project(const Select3D_Projector& aProj)
void Select3D_SensitivePoly::Project(const Handle(Select3D_Projector)& aProj)
{
Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
mybox2d.SetVoid();
@ -71,11 +71,14 @@ void Select3D_SensitivePoly::Project(const Select3D_Projector& aProj)
for(Standard_Integer i=0;i<mynbpoints;i++)
{
gp_Pnt aPnt(((Select3D_Pnt*)mypolyg3d)[i].x, ((Select3D_Pnt*)mypolyg3d)[i].y, ((Select3D_Pnt*)mypolyg3d)[i].z);
if(hasloc){
aProj.Project(aPnt.Transformed(Location().Transformation()),aPnt2d);
if (hasloc)
{
aProj->Project(aPnt.Transformed(Location().Transformation()),aPnt2d);
}
else
aProj.Project(aPnt,aPnt2d);
{
aProj->Project(aPnt,aPnt2d);
}
mybox2d.Update(aPnt2d);
((Select3D_Pnt2d*)mypolyg2d)[i] = aPnt2d;
}

13
src/Select3D/Select3D_SensitiveSegment.cxx
View File

@ -45,7 +45,7 @@ mymaxrect(MaxRect)
// Purpose :
//=====================================================
void Select3D_SensitiveSegment
::Project(const Select3D_Projector& aProj)
::Project(const Handle(Select3D_Projector)& aProj)
{
Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
gp_Pnt2d aPoint2dStart;
@ -54,12 +54,12 @@ void Select3D_SensitiveSegment
if(HasLocation()){
gp_Pnt aStart(mystart.x, mystart.y, mystart.z);
gp_Pnt aEnd(myend.x, myend.y, myend.z);
aProj.Project(aStart.Transformed(Location().Transformation()),aPoint2dStart);
aProj.Project(aEnd.Transformed(Location().Transformation()),aPoint2dEnd);
aProj->Project(aStart.Transformed(Location().Transformation()),aPoint2dStart);
aProj->Project(aEnd.Transformed(Location().Transformation()),aPoint2dEnd);
}
else{
aProj.Project(mystart,aPoint2dStart);
aProj.Project(myend,aPoint2dEnd);
aProj->Project(mystart,aPoint2dStart);
aProj->Project(myend,aPoint2dEnd);
}
myprojstart = aPoint2dStart;
myprojend = aPoint2dEnd;
@ -124,8 +124,7 @@ Standard_Boolean Select3D_SensitiveSegment
gp_Pnt2d aPEnd(myprojend.x,myprojend.y);
if ( ! SelectBasics_BasicTool::MatchSegment (aPStart, aPEnd, X, Y, aTol, DMin) )
return Standard_False;
Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin); // to compute depth
return Standard_True;
return Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin); // compute and validate depth
}
Standard_Boolean Select3D_SensitiveSegment::

85
src/Select3D/Select3D_SensitiveTriangulation.cxx
View File

@ -11,6 +11,7 @@
#include <Select3D_SensitiveTriangulation.ixx>
#include <gp_Pnt2d.hxx>
#include <Poly.hxx>
#include <Poly_Connect.hxx>
#include <CSLib_Class2d.hxx>
#include <TColStd_Array1OfInteger.hxx>
@ -185,7 +186,7 @@ myDetectedTr(-1)
//purpose :
//=======================================================================
void Select3D_SensitiveTriangulation::Project(const Select3D_Projector& aPrj)
void Select3D_SensitiveTriangulation::Project(const Handle(Select3D_Projector)& aPrj)
{
Select3D_SensitiveEntity::Project(aPrj); // to set the field last proj...
@ -196,15 +197,15 @@ void Select3D_SensitiveTriangulation::Project(const Select3D_Projector& aPrj)
for(Standard_Integer I=1;I<=myTriangul->NbNodes();I++){
if(myTrsf.Form()!=gp_Identity)
aPrj.Project(Nodes(I).Transformed(myTrsf),ProjPT);
aPrj->Project(Nodes(I).Transformed(myTrsf),ProjPT);
else
aPrj.Project(Nodes(I),ProjPT);
aPrj->Project(Nodes(I),ProjPT);
myNodes2d.SetValue(I,ProjPT);
mybox2d.Add(ProjPT);
}
aPrj.Project(myCDG3D,myCDG2D);
aPrj->Project(myCDG3D,myCDG2D);
}
//=======================================================================
@ -217,59 +218,6 @@ void Select3D_SensitiveTriangulation::Areas(SelectBasics_ListOfBox2d& boxes)
boxes.Append(mybox2d);
}
//=======================================================================
//function : getUV
//purpose : compute parameters of the picked point on triangle in 2d
// Note: parameters of point P on triangle (P1, P2, P3) are defined
// as U and V such that P = P1 + U * (P2 - P1) + V * (P3 - P1);
// Range: U >= 0, V >= 0, U + V <= 1
//=======================================================================
static gp_XY getUV (const gp_XY& aP2d1, const gp_XY& aP2d2, const gp_XY& aP2d3,
const gp_XY& aPick)
{
gp_XY aDU = aP2d2 - aP2d1;
gp_XY aDV = aP2d3 - aP2d1;
Standard_Real aDet = aDU ^ aDV;
// case of non-degenerated triangle
gp_XY aDP = aPick - aP2d1;
if ( Abs (aDet) > gp::Resolution() )
{
Standard_Real aU = (aDP ^ aDV) / aDet;
Standard_Real aV = -(aDP ^ aDU) / aDet;
if ( aU < 0. ) aU = 0.;
if ( aV < 0. ) aV = 0.;
if ( aU + aV > 1. ) { Standard_Real aD = aU + aV; aU /= aD; aV /= aD; }
return gp_XY (aU, aV);
}
// degenerated case (in 2d projection)
Standard_Real aL2U = aDU.SquareModulus();
Standard_Real aL2V = aDV.SquareModulus();
if ( aL2U < gp::Resolution() ) // side 1-2 is degenerated
{
if ( aL2V < gp::Resolution() ) // whole triangle is degenerated to point
return gp_XY (0., 0.);
else
return gp_XY (0., (aDP * aDV) / aL2V);
}
else if ( aL2V < gp::Resolution() ) // side 1-3 is degenerated
return gp_XY ((aDP * aDU) / aL2U, 0.);
else // sides 1-2 and 1-3 are collinear
{
// select parameter on one of sides so as to have points closer to picked
Standard_Real aU = Min (1., Max (0., (aDP * aDU) / aL2U));
Standard_Real aV = Min (1., Max (0., (aDP * aDV) / aL2V));
gp_XY aP2dU = aP2d1 + aU * aDU;
gp_XY aP2dV = aP2d1 + aV * aDV;
if ( (aPick - aP2dU).SquareModulus() < (aPick - aP2dV).SquareModulus() )
return gp_XY ((aDP * aDU) / aL2U, 0.);
else
return gp_XY (0., (aDP * aDV) / aL2V);
}
}
//=======================================================================
//function : Matches
//purpose :
@ -280,7 +228,7 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
Standard_Real& DMin)
{
// get view direction (necessary for calculation of depth) from field mylastprj of the base class
if ( ! mylastprj )
if (mylastprj.IsNull())
return Standard_False;
DMin = Precision::Infinite();
@ -291,7 +239,7 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
// on regarde si on est a l'interieur d'1 triangle 2d.
if(myIntFlag)
{
gp_Lin EyeLine = (*((Select3D_Projector*)mylastprj)).Shoot(X,Y);
gp_Lin EyeLine = mylastprj->Shoot(X,Y);
if ( myTrsf.Form()!=gp_Identity )
EyeLine.Transform (myTrsf.Inverted());
@ -304,24 +252,26 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
const gp_XY& aPnt2d1 = myNodes2d(n1).XY();
const gp_XY& aPnt2d2 = myNodes2d(n2).XY();
const gp_XY& aPnt2d3 = myNodes2d(n3).XY();
Standard_Real DD = 0.;
if (Status (BidPoint, aPnt2d1, aPnt2d2, aPnt2d3, aTol, DD) == 2)
gp_XY aUV;
Standard_Real aDistSquare = Poly::PointOnTriangle (aPnt2d1, aPnt2d2, aPnt2d3, BidPoint, aUV);
if ( aDistSquare > aTol * aTol )
continue;
// compute depth on this triangle
gp_XY aUV = getUV (aPnt2d1, aPnt2d2, aPnt2d3, BidPoint);
Standard_Real aDepth1 = ElCLib::Parameter (EyeLine, Nodes(n1));
Standard_Real aDepth2 = ElCLib::Parameter (EyeLine, Nodes(n2));
Standard_Real aDepth3 = ElCLib::Parameter (EyeLine, Nodes(n3));
Standard_Real aDepth = aDepth1 + aUV.X() * (aDepth2 - aDepth1) +
aUV.Y() * (aDepth3 - aDepth1);
// take triangle with lowest depth
if ( aDepth < aMinDepth )
// take triangle with lowest depth and within defined depth interval
if (aDepth < aMinDepth &&
aDepth > mylastprj->DepthMin() &&
aDepth < mylastprj->DepthMax())
{
aMinDepth = aDepth;
myDetectedTr = itr;
DMin = DD;
DMin = Sqrt (aDistSquare);
}
}
}
@ -359,8 +309,9 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
}
if ( myDetectedTr <= 0 )
return Standard_False;
Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
return Standard_True;
// compute and validate the depth (::Depth()) along the eyeline
return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
}

10
src/Select3D/Select3D_SensitiveWire.cxx
View File

@ -94,7 +94,7 @@ void Select3D_SensitiveWire::ResetLocation()
// Purpose :
//=====================================================
void Select3D_SensitiveWire
::Project(const Select3D_Projector& aProj)
::Project(const Handle(Select3D_Projector)& aProj)
{
for ( Standard_Integer i=1; i<=mysensitive.Length(); i++)
mysensitive(i)->Project(aProj);
@ -144,9 +144,11 @@ Standard_Boolean Select3D_SensitiveWire
}
}
}
// Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
if ( ! IsTouched )
return Standard_False;
return IsTouched;
// compute and validate the depth (::Depth()) along the eyeline
return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
}
//=====================================================
@ -253,7 +255,7 @@ Standard_Real Select3D_SensitiveWire::ComputeDepth(const gp_Lin& EyeLine) const
//function : SetLastPrj
//purpose :
//=======================================================================
void Select3D_SensitiveWire::SetLastPrj(const Select3D_Projector& Prj)
void Select3D_SensitiveWire::SetLastPrj(const Handle(Select3D_Projector)& Prj)
{
Select3D_SensitiveEntity::SetLastPrj(Prj);
for(Standard_Integer i=1;i<=mysensitive.Length();i++)

10
src/StdSelect/StdSelect.cxx
View File

@ -4,8 +4,6 @@
// Author: Robert COUBLANC
// <rob>
#include <StdSelect.ixx>
#include <SelectMgr_Selection.hxx>
#include <Graphic3d_StructureManager.hxx>
@ -24,12 +22,8 @@
#include <gp_Ax3.hxx>
#include <V3d_PerspectiveView.hxx>
#include <StdSelect_BRepOwner.hxx>
//#include <.hxx>
Select3D_Projector StdSelect::GetProjector(const Handle(V3d_View)& aViou)
Handle(Select3D_Projector) StdSelect::GetProjector(const Handle(V3d_View)& aViou)
{
Standard_Real Focale=0.,Xat,Yat,Zat,XUp,YUp,ZUp,DX,DY,DZ;
Standard_Boolean Pers=Standard_False;
@ -48,7 +42,7 @@ Select3D_Projector StdSelect::GetProjector(const Handle(V3d_View)& aViou)
gp_Ax3 Axe (At, Zpers, Xpers);
gp_Trsf T;
T.SetTransformation(Axe);
return Select3D_Projector(T,Pers,Focale);
return new Select3D_Projector(T,Pers,Focale);
}

90
src/StdSelect/StdSelect_ViewerSelector3d.cxx
View File

@ -15,6 +15,7 @@
#include <gp_Ax3.hxx>
#include <gp_GTrsf.hxx>
#include <V3d_PerspectiveView.hxx>
#include <V3d_Plane.hxx>
#include <Select3D_SensitiveEntity.hxx>
#include <Graphic3d_Array1OfVertex.hxx>
#include <SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive.hxx>
@ -83,6 +84,7 @@ static Standard_Boolean StdSelectDebugModeOn()
StdSelect_ViewerSelector3d
::StdSelect_ViewerSelector3d():
myprj(new Select3D_Projector()),
mylastzoom(0.0),
mypixtol(2),
myupdatetol(Standard_True)
@ -98,7 +100,7 @@ myupdatetol(Standard_True)
//==================================================
StdSelect_ViewerSelector3d
::StdSelect_ViewerSelector3d(const Select3D_Projector& aProj):
::StdSelect_ViewerSelector3d(const Handle(Select3D_Projector)& aProj):
myprj(aProj),
mylastzoom(0.0),
mypixtol(2),
@ -147,7 +149,7 @@ void StdSelect_ViewerSelector3d
//==================================================
void StdSelect_ViewerSelector3d
::Set(const Select3D_Projector& aProj)
::Set(const Handle(Select3D_Projector)& aProj)
{
myprj = aProj;
toupdate=Standard_True;
@ -167,7 +169,53 @@ void StdSelect_ViewerSelector3d
Standard_Real Xr3d,Yr3d,Zr3d;
gp_Pnt2d P2d;
aView->Convert(XPix,YPix,Xr3d,Yr3d,Zr3d);
myprj.Project(gp_Pnt(Xr3d,Yr3d,Zr3d),P2d);
myprj->Project(gp_Pnt(Xr3d,Yr3d,Zr3d),P2d);
// compute depth limits if clipping plane(s) enabled
gp_Lin anEyeLine = myprj->Shoot (P2d.X(), P2d.Y());
Standard_Real aPlaneA, aPlaneB, aPlaneC, aPlaneD;
Standard_Real aDepthFrom = ShortRealFirst();
Standard_Real aDepthTo = ShortRealLast();
for (aView->InitActivePlanes(); aView->MoreActivePlanes(); aView->NextActivePlanes())
{
aView->ActivePlane()->Plane (aPlaneA, aPlaneB, aPlaneC, aPlaneD);
const gp_Dir& anEyeLineDir = anEyeLine.Direction();
gp_Dir aPlaneNormal (aPlaneA, aPlaneB, aPlaneC);
Standard_Real aDotProduct = anEyeLineDir.Dot (aPlaneNormal);
Standard_Real aDirection = -(aPlaneD + anEyeLine.Location().XYZ().Dot (aPlaneNormal.XYZ()));
if (Abs (aDotProduct) < Precision::Angular())
{
// eyeline parallel to the clipping plane
if (aDirection > 0.0)
{
// invalidate the interval
aDepthTo = ShortRealFirst();
aDepthFrom = ShortRealFirst();
break;
}
// just ignore this plane
continue;
}
// compute distance along the eyeline from eyeline location to intersection with clipping plane
Standard_Real aDepth = aDirection / aDotProduct;
// reduce depth limits
if (aDotProduct < 0.0)
{
if (aDepth < aDepthTo)
{
aDepthTo = aDepth;
}
}
else if (aDepth > aDepthFrom)
{
aDepthFrom = aDepth;
}
}
myprj->DepthMinMax (aDepthFrom, aDepthTo);
InitSelect(P2d.X(),P2d.Y());
}
@ -195,8 +243,8 @@ void StdSelect_ViewerSelector3d
gp_Pnt2d P2d_1,P2d_2;
aView->Convert(XPMin,YPMin,x1,y1,z1);
aView->Convert(XPMax,YPMax,x2,y2,z2);
myprj.Project(gp_Pnt(x1,y1,z1),P2d_1);
myprj.Project(gp_Pnt(x2,y2,z2),P2d_2);
myprj->Project(gp_Pnt(x1,y1,z1),P2d_1);
myprj->Project(gp_Pnt(x2,y2,z2),P2d_2);
InitSelect (Min(P2d_1.X(),P2d_2.X()),
Min(P2d_1.Y(),P2d_2.Y()),
@ -236,7 +284,7 @@ void StdSelect_ViewerSelector3d
gp_Pnt2d Pnt2d;
aView->Convert (XP, YP, x, y, z);
myprj.Project (gp_Pnt (x, y, z), Pnt2d);
myprj->Project (gp_Pnt (x, y, z), Pnt2d);
P2d->SetValue (i, Pnt2d);
}
@ -272,8 +320,8 @@ DisplayAreas(const Handle(V3d_View)& aView)
}
SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive It(myentities);
Select3D_Projector prj = StdSelect::GetProjector(aView);
prj.SetView(aView);
Handle(Select3D_Projector) prj = StdSelect::GetProjector(aView);
prj->SetView(aView);
Graphic3d_Array1OfVertex Av1 (1,5);
@ -291,23 +339,23 @@ DisplayAreas(const Handle(V3d_View)& aView)
itb.Value().Get (xmin, ymin, xmax, ymax);
Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
prj.Transform (Pbid, prj.InvertedTransformation());
prj->Transform (Pbid, prj->InvertedTransformation());
Av1.SetValue (1, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmax + mytolerance, ymin - mytolerance, 0.0);
prj.Transform (Pbid, prj.InvertedTransformation());
prj->Transform (Pbid, prj->InvertedTransformation());
Av1.SetValue (2, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmax + mytolerance, ymax + mytolerance, 0.0);
prj.Transform (Pbid, prj.InvertedTransformation());
prj->Transform (Pbid, prj->InvertedTransformation());
Av1.SetValue (3, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmin - mytolerance, ymax + mytolerance, 0.0);
prj.Transform (Pbid, prj.InvertedTransformation());
prj->Transform (Pbid, prj->InvertedTransformation());
Av1.SetValue (4,Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
prj.Transform (Pbid, prj.InvertedTransformation());
prj->Transform (Pbid, prj->InvertedTransformation());
Av1.SetValue (5, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
myareagroup->Polyline (Av1);
@ -421,14 +469,14 @@ UpdateProj(const Handle(V3d_View)& aView)
GT.SetTranslationPart (loc);
GT.SetVectorialPart (matrix);
myprj = Select3D_Projector (GT, Pers, mycoeff[9]);
myprj = new Select3D_Projector (GT, Pers, mycoeff[9]);
// SAV 08/05/02 : fix for detection problem in a perspective view
if (aView->Type() == V3d_PERSPECTIVE)
myprj.SetView (aView);
myprj->SetView (aView);
// NKV 31/07/07 : fix for detection problem in case of custom matrix
else if (aView->ViewOrientation().IsCustomMatrix())
myprj.SetView (aView);
myprj->SetView (aView);
}
if (Abs (aView->Scale() - mylastzoom) > 1.e-3)
@ -1008,23 +1056,23 @@ ComputeAreasPrs (const Handle(SelectMgr_Selection)& Sel)
itb.Value().Get (xmin, ymin, xmax, ymax);
Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
myprj.Transform (Pbid, myprj.InvertedTransformation());
myprj->Transform (Pbid, myprj->InvertedTransformation());
Av1.SetValue (1, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmax + mytolerance, ymin - mytolerance, 0.0);
myprj.Transform (Pbid, myprj.InvertedTransformation());
myprj->Transform (Pbid, myprj->InvertedTransformation());
Av1.SetValue (2, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmax + mytolerance, ymax + mytolerance, 0.0);
myprj.Transform (Pbid, myprj.InvertedTransformation());
myprj->Transform (Pbid, myprj->InvertedTransformation());
Av1.SetValue (3, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmin - mytolerance, ymax + mytolerance, 0.0);
myprj.Transform (Pbid, myprj.InvertedTransformation());
myprj->Transform (Pbid, myprj->InvertedTransformation());
Av1.SetValue (4, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
myprj.Transform (Pbid, myprj.InvertedTransformation());
myprj->Transform (Pbid, myprj->InvertedTransformation());
Av1.SetValue (5, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
myareagroup->Polyline (Av1);

6
src/StdSelect/StdSelect_ViewerSelector3d.lxx
View File

@ -1,2 +1,4 @@
inline const Select3D_Projector& StdSelect_ViewerSelector3d::
Projector() const {return myprj;}
inline const Handle(Select3D_Projector)& StdSelect_ViewerSelector3d::Projector() const
{
return myprj;
}

3
src/V3d/V3d_Plane.cdl
View File

@ -20,7 +20,6 @@ inherits
uses
Viewer from V3d,
View from V3d,
ClipPlane from Visual3d,
Structure from Graphic3d,
@ -38,7 +37,7 @@ is
-- The methods :
--
Create ( VM : Viewer ; A: Parameter = 0.0;
Create (A: Parameter = 0.0;
B: Parameter = 0.0;
C: Parameter = 1.0;
D: Parameter = 0.0

13
src/V3d/V3d_Plane.cxx
View File

@ -14,19 +14,22 @@
//-Language C++ 2.1
// for the class
#include <V3d.hxx>
#include <V3d_Plane.ixx>
#include <Viewer_BadValue.hxx>
#include <Graphic3d_Group.hxx>
#include <Graphic3d_Array1OfVertex.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
#include <gp_Pln.hxx>
//-Constructors
V3d_Plane::V3d_Plane(const Handle(V3d_Viewer)& VM, const Standard_Real A, const Standard_Real B, const Standard_Real C, const Standard_Real D) {
V3d_Plane::V3d_Plane(const Standard_Real A, const Standard_Real B, const Standard_Real C, const Standard_Real D) {
Viewer_BadValue_Raise_if( sqrt(A*A + B*B + C*C) <= 0., "V3d_Plane::V3d_Plane, bad plane coefficients");
MyPlane = new Visual3d_ClipPlane(A,B,C,D) ;
VM->AddPlane(this) ;
}
//-Methods, in order
@ -42,9 +45,6 @@ void V3d_Plane::SetPlane( const Standard_Real A, const Standard_Real B, const St
}
}
#include <Graphic3d_Group.hxx>
#include <Graphic3d_Array1OfVertex.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
void V3d_Plane::Display(const Handle(V3d_View)& aView,
const Quantity_Color& aColor) {
Handle(V3d_Viewer) theViewer = aView->Viewer();
@ -96,7 +96,6 @@ Standard_Boolean V3d_Plane::IsDisplayed() const {
return MyGraphicStructure->IsDisplayed();
}
#include <gp_Pln.hxx>
void V3d_Plane::Update() {
if( !MyGraphicStructure.IsNull() ) {

16
src/V3d/V3d_Viewer.cdl
View File

@ -32,7 +32,6 @@ inherits
uses
-- GraphicDevice from Graphic3d,
GraphicDevice from Aspect,
TypeOfUpdate from V3d,
TypeOfVisualization from V3d,
@ -69,14 +68,12 @@ uses
GridDrawMode from Aspect,
GradientFillMethod from Aspect
raises
BadValue from Viewer
is
-- Create ( Device : GraphicDevice from Graphic3d;
Create ( Device : GraphicDevice from Aspect;
aName : ExtString from Standard;
aDomain : CString from Standard = "";
@ -425,6 +422,12 @@ is
DefinedLight(me) returns Light from V3d;
---Level: Advanced
AddPlane( me: mutable; MyPlane : Plane from V3d);
---Purpose: Adds Plane in Sequence Of Planes.
DelPlane( me: mutable; MyPlane : Plane from V3d);
---Purpose: Delete Plane in Sequence Of Planes.
InitDefinedPlanes(me: mutable);
---Level: Advanced
---Purpose: initializes an iteration on the Defined Planes.
@ -635,12 +638,6 @@ is
AddLight( me: mutable; MyLight : Light from V3d) is private;
---Purpose: Adds Light in Sequence Of Lights.
AddPlane( me: mutable; MyPlane : Plane from V3d) is private ;
---Purpose: Adds Plane in Sequence Of Planes.
DelPlane( me: mutable; MyPlane : Plane from V3d) is private;
---Purpose: Delete Plane in Sequence Of Planes.
SetDefaultLights(me: mutable);
---Purpose: defines default lights -
-- positional-light 0.3 0. 0.
@ -659,7 +656,6 @@ is
---Purpose:
-- Display grid echo at requested point in the view.
fields
MyViewer: ViewManager from Visual3d ;

14
src/ViewerTest/ViewerTest.cxx
View File

@ -305,12 +305,12 @@ void ViewerTest::SetAISContext (const Handle(AIS_InteractiveContext)& aCtx)
Handle(V3d_Viewer) ViewerTest::GetViewerFromContext()
{
return TheAISContext()->CurrentViewer();
return !TheAISContext().IsNull() ? TheAISContext()->CurrentViewer() : Handle(V3d_Viewer)();
}
Handle(V3d_Viewer) ViewerTest::GetCollectorFromContext()
{
return TheAISContext()->CurrentViewer();
return !TheAISContext().IsNull() ? TheAISContext()->CurrentViewer() : Handle(V3d_Viewer)();
}
@ -2066,7 +2066,7 @@ static int VPerf(Draw_Interpretor& di, Standard_Integer , const char** argv) {
// Function : VAnimation
//==================================================================================
static int VAnimation (Draw_Interpretor& di, Standard_Integer argc, const char** argv) {
if (argc != 5) {
if (argc =! 5) {
di<<"Use: "<<argv[0]<<" CrankArmFile CylinderHeadFile PropellerFile EngineBlockFile"<<"\n";
return 1;
}
@ -2580,7 +2580,7 @@ Standard_Boolean ViewerTest::PickObjects(Handle(TColStd_HArray1OfTransient)& ar
Standard_Integer curindex = (TheType == AIS_KOI_None) ? 0 : TheAISContext()->OpenLocalContext();
// step 1: prepare the data
if(curindex != 0){
if(curindex !=0){
Handle(AIS_SignatureFilter) F1 = new AIS_SignatureFilter(TheType,TheSignature);
TheAISContext()->AddFilter(F1);
}
@ -2639,7 +2639,7 @@ Handle(AIS_InteractiveObject) ViewerTest::PickObject(const AIS_KindOfInteractive
// step 1: prepare the data
if(curindex != 0){
if(curindex !=0){
Handle(AIS_SignatureFilter) F1 = new AIS_SignatureFilter(TheType,TheSignature);
TheAISContext()->AddFilter(F1);
}
@ -2666,7 +2666,7 @@ Handle(AIS_InteractiveObject) ViewerTest::PickObject(const AIS_KindOfInteractive
IO = TheAISContext()->SelectedInteractive();
}
if(curindex != 0)
if(curindex!=0)
TheAISContext()->CloseLocalContext(curindex);
return IO;
}
@ -3079,7 +3079,7 @@ static int VIOTypes( Draw_Interpretor& di, Standard_Integer , const char** )
static int VEraseType( Draw_Interpretor& , Standard_Integer argc, const char** argv)
{
if(argc != 2) return 1;
if(argc!=2) return 1;
AIS_KindOfInteractive TheType;
Standard_Integer TheSign(-1);

180
src/ViewerTest/ViewerTest_ObjectCommands.cxx
View File

@ -26,8 +26,10 @@
#include <OSD_Chronometer.hxx>
#include <TCollection_AsciiString.hxx>
#include <Visual3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <V3d_View.hxx>
#include <V3d_Plane.hxx>
#include <V3d.hxx>
#include <AIS_Shape.hxx>
@ -2556,6 +2558,180 @@ static int VDrawSphere (Draw_Interpretor& di, Standard_Integer argc, const char*
return 0;
}
//===============================================================================================
//function : VClipPlane
//purpose :
//===============================================================================================
static int VClipPlane (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
Handle(V3d_View) aView = ViewerTest::CurrentView();
Standard_Real coeffA, coeffB, coeffC, coeffD;
if (aViewer.IsNull() || aView.IsNull())
{
std::cout << "Viewer not initialized!\n";
return 1;
}
// count an active planes count
Standard_Integer aNewPlaneId = 1;
Standard_Integer anActivePlanes = 0;
for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aNewPlaneId)
{
Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
if (aView->IsActivePlane (aPlaneV3d))
{
++anActivePlanes;
}
}
if (argc == 1)
{
// just show info about existing planes
Standard_Integer aPlaneId = 1;
std::cout << "Active planes: " << anActivePlanes << " from maximal " << aView->View()->PlaneLimit() << "\n";
for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
{
Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
aPlaneV3d->Plane (coeffA, coeffB, coeffC, coeffD);
gp_Pln aPlane (coeffA, coeffB, coeffC, coeffD);
const gp_Pnt& aLoc = aPlane.Location();
const gp_Dir& aNor = aPlane.Axis().Direction();
Standard_Boolean isActive = aView->IsActivePlane (aPlaneV3d);
std::cout << "Plane #" << aPlaneId
<< " " << aLoc.X() << " " << aLoc.Y() << " " << aLoc.Z()
<< " " << aNor.X() << " " << aNor.Y() << " " << aNor.Z()
<< (isActive ? " on" : " off")
<< (aPlaneV3d->IsDisplayed() ? ", displayed" : ", hidden")
<< "\n";
}
if (aPlaneId == 1)
{
std::cout << "No defined clipping planes\n";
}
return 0;
}
else if (argc == 2 || argc == 3)
{
Standard_Integer aPlaneIdToOff = (argc == 3) ? atoi (argv[1]) : 1;
Standard_Boolean toIterateAll = (argc == 2);
TCollection_AsciiString isOnOffStr ((argc == 3) ? argv[2] : argv[1]);
isOnOffStr.LowerCase();
Standard_Integer aPlaneId = 1;
for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
{
if (aPlaneIdToOff == aPlaneId || toIterateAll)
{
Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
if (isOnOffStr.Search ("off") >= 0)
{
aView->SetPlaneOff (aPlaneV3d);
std::cout << "Clipping plane #" << aPlaneId << " was disabled\n";
}
else if (isOnOffStr.Search ("on") >= 0)
{
// avoid z-fighting glitches
aPlaneV3d->Erase();
if (!aView->IsActivePlane (aPlaneV3d))
{
if (anActivePlanes < aView->View()->PlaneLimit())
{
aView->SetPlaneOn (aPlaneV3d);
std::cout << "Clipping plane #" << aPlaneId << " was enabled\n";
}
else
{
std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
<< "You should disable or remove some existing plane to activate this one\n";
}
}
else
{
std::cout << "Clipping plane #" << aPlaneId << " was already enabled\n";
}
}
else if (isOnOffStr.Search ("del") >= 0 || isOnOffStr.Search ("rem") >= 0)
{
aPlaneV3d->Erase(); // not performed on destructor!!!
aView->SetPlaneOff (aPlaneV3d);
aViewer->DelPlane (aPlaneV3d);
std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
if (toIterateAll)
{
for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->InitDefinedPlanes(), ++aPlaneId)
{
aPlaneV3d = aViewer->DefinedPlane();
aPlaneV3d->Erase(); // not performed on destructor!!!
aView->SetPlaneOff (aPlaneV3d);
aViewer->DelPlane (aPlaneV3d);
std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
}
break;
}
else
{
break;
}
}
else if (isOnOffStr.Search ("disp") >= 0 || isOnOffStr.Search ("show") >= 0)
{
// avoid z-fighting glitches
aView->SetPlaneOff (aPlaneV3d);
aPlaneV3d->Display (aView);
std::cout << "Clipping plane #" << aPlaneId << " was shown and disabled\n";
}
else if (isOnOffStr.Search ("hide") >= 0)
{
aPlaneV3d->Erase();
std::cout << "Clipping plane #" << aPlaneId << " was hidden\n";
}
else
{
std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
return 1;
}
}
}
if (aPlaneIdToOff >= aPlaneId && !toIterateAll)
{
std::cout << "Clipping plane with id " << aPlaneIdToOff << " not found!\n";
return 1;
}
aView->Update();
return 0;
}
else if (argc != 7)
{
std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
return 1;
}
Standard_Real aLocX = atof (argv[1]);
Standard_Real aLocY = atof (argv[2]);
Standard_Real aLocZ = atof (argv[3]);
Standard_Real aNormDX = atof (argv[4]);
Standard_Real aNormDY = atof (argv[5]);
Standard_Real aNormDZ = atof (argv[6]);
Handle(V3d_Plane) aPlaneV3d = new V3d_Plane();
gp_Pln aPlane (gp_Pnt (aLocX, aLocY, aLocZ), gp_Dir (aNormDX, aNormDY, aNormDZ));
aPlane.Coefficients (coeffA, coeffB, coeffC, coeffD);
aPlaneV3d->SetPlane(coeffA, coeffB, coeffC, coeffD);
aViewer->AddPlane (aPlaneV3d); // add to defined planes list
std::cout << "Added clipping plane #" << aNewPlaneId << "\n";
if (anActivePlanes < aView->View()->PlaneLimit())
{
aView->SetPlaneOn (aPlaneV3d); // add to enabled planes list
aView->Update();
}
else
{
std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
<< "You should disable or remove some existing plane to activate the new one\n";
}
return 0;
}
//=======================================================================
//function : ObjectsCommands
@ -2625,4 +2801,8 @@ void ViewerTest::ObjectCommands(Draw_Interpretor& theCommands)
"vdrawsphere: vdrawsphere shapeName Fineness [X=0.0 Y=0.0 Z=0.0] [Radius=100.0] [ToEnableVBO=1] [NumberOfViewerUpdate=1] [ToShowEdges=0]\n",
__FILE__,VDrawSphere,group);
theCommands.Add("vclipplane",
"vclipplane : vclipplane [x y z dx dy dz] [planeId {on/off/del/display/hide}]",
__FILE__,VClipPlane,group);
}