X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Actor.cxx;h=dc35fcda2aa9bba3850ce2767a0bc69933183e44;hp=29a1f094bd6a1af283abcd59800a555786fa3fc0;hb=4a31c0f62c598738b612ab5f1810db58271a554c;hpb=c3bf92bd87b770fd81631a3853f7f5bb1ac6a4e8;ds=sidebyside diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx index 29a1f094b..dc35fcda2 100644 --- a/src/OBJECT/SMESH_Actor.cxx +++ b/src/OBJECT/SMESH_Actor.cxx @@ -27,19 +27,34 @@ // $Header$ -#include "SMESH_Actor.h" +#include "SMESH_ActorDef.h" +#include "SMESH_ActorUtils.h" #include "SMESH_DeviceActor.h" +#include "SMESH_ControlsDef.hxx" #include "SALOME_ExtractUnstructuredGrid.h" #include "QAD_Config.h" -#include "utilities.h" #include +#include #include #include #include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include + #include +#include #include #include #include @@ -49,54 +64,56 @@ #include #include -#include + +#include +#include +#include + +#include "utilities.h" #ifdef _DEBUG_ -static int MYDEBUG = 1; -static int MYDEBUGWITHFILES = 0; +static int MYDEBUG = 0; #else static int MYDEBUG = 0; -static int MYDEBUGWITHFILES = 0; #endif -using namespace std; - - -inline float GetFloat(const QString& theValue, float theDefault = 0){ - if(theValue.isEmpty()) return theDefault; - QString aValue = QAD_CONFIG->getSetting(theValue); - if(aValue.isEmpty()) return theDefault; - return aValue.toFloat(); -} +static int aLineWidthInc = 2; +static int aPointSizeInc = 2; -SMESH_Actor* SMESH_Actor::New(){ - return new SMESH_Actor(); +SMESH_ActorDef* SMESH_ActorDef::New(){ + return new SMESH_ActorDef(); } SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj, - SMESH::FilterManager_ptr theFilterMgr, const char* theEntry, const char* theName, int theIsClear) { - SMESH_Actor* anActor = SMESH_Actor::New(); - anActor->Init(theVisualObj,theFilterMgr,theEntry,theName,theIsClear); + SMESH_ActorDef* anActor = SMESH_ActorDef::New(); + if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){ + anActor->Delete(); + anActor = NULL; + } return anActor; } -SMESH_Actor::SMESH_Actor(){ - if(MYDEBUG) MESSAGE("SMESH_Actor"); +SMESH_ActorDef::SMESH_ActorDef(){ + if(MYDEBUG) MESSAGE("SMESH_ActorDef"); + + myTimeStamp = vtkTimeStamp::New(); myIsPointsVisible = false; myIsShrinkable = false; myIsShrunk = false; - float aPointSize = GetFloat("SMESH:SettingsNodesSize",3); - float aLineWidth = GetFloat("SMESH:SettingsWidth",1); + myControlsPrecision = (long)SMESH::GetFloat( "SMESH:ControlsPrecision", -1 ); + + float aPointSize = SMESH::GetFloat("SMESH:SettingsNodesSize",3); + float aLineWidth = SMESH::GetFloat("SMESH:SettingsWidth",1); vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); SALOME_ExtractUnstructuredGrid* aFilter = NULL; @@ -105,15 +122,15 @@ SMESH_Actor::SMESH_Actor(){ //----------------------------------------- float anRGB[3] = {1,1,1}; mySurfaceProp = vtkProperty::New(); - anRGB[0] = GetFloat("SMESH:SettingsFillColorRed", 0)/255.; - anRGB[1] = GetFloat("SMESH:SettingsFillColorGreen", 170)/255.; - anRGB[2] = GetFloat("SMESH:SettingsFillColorBlue", 255)/255.; + anRGB[0] = SMESH::GetFloat("SMESH:SettingsFillColorRed", 0)/255.; + anRGB[1] = SMESH::GetFloat("SMESH:SettingsFillColorGreen", 170)/255.; + anRGB[2] = SMESH::GetFloat("SMESH:SettingsFillColorBlue", 255)/255.; mySurfaceProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myBackSurfaceProp = vtkProperty::New(); - anRGB[0] = GetFloat("SMESH:SettingsBackFaceColorRed", 0)/255.; - anRGB[1] = GetFloat("SMESH:SettingsBackFaceColorGreen", 0)/255.; - anRGB[2] = GetFloat("SMESH:SettingsBackFaceColorBlue", 255)/255.; + anRGB[0] = SMESH::GetFloat("SMESH:SettingsBackFaceColorRed", 0)/255.; + anRGB[1] = SMESH::GetFloat("SMESH:SettingsBackFaceColorGreen", 0)/255.; + anRGB[2] = SMESH::GetFloat("SMESH:SettingsBackFaceColorBlue", 255)/255.; myBackSurfaceProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); my2DActor = SMESH_DeviceActor::New(); @@ -151,9 +168,9 @@ SMESH_Actor::SMESH_Actor(){ myEdgeProp->SetAmbient(1.0); myEdgeProp->SetDiffuse(0.0); myEdgeProp->SetSpecular(0.0); - anRGB[0] = GetFloat("SMESH:SettingsOutlineColorRed", 0)/255.; - anRGB[1] = GetFloat("SMESH:SettingsOutlineColorGreen", 170)/255.; - anRGB[2] = GetFloat("SMESH:SettingsOutlineColorBlue", 255)/255.; + anRGB[0] = SMESH::GetFloat("SMESH:SettingsOutlineColorRed", 0)/255.; + anRGB[1] = SMESH::GetFloat("SMESH:SettingsOutlineColorGreen", 170)/255.; + anRGB[2] = SMESH::GetFloat("SMESH:SettingsOutlineColorBlue", 255)/255.; myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myEdgeProp->SetLineWidth(aLineWidth); @@ -161,6 +178,7 @@ SMESH_Actor::SMESH_Actor(){ my1DActor->SetUserMatrix(aMatrix); my1DActor->SetStoreMapping(true); my1DActor->PickableOff(); + my1DActor->SetHighlited(true); my1DActor->SetProperty(myEdgeProp); my1DActor->SetRepresentation(SMESH_DeviceActor::eSurface); aFilter = my1DActor->GetExtractUnstructuredGrid(); @@ -169,8 +187,7 @@ SMESH_Actor::SMESH_Actor(){ my1DProp = vtkProperty::New(); my1DProp->DeepCopy(myEdgeProp); - static int aCotnrolLineWidth = 3; - my1DProp->SetLineWidth(aCotnrolLineWidth); + my1DProp->SetLineWidth(aLineWidth + aLineWidthInc); my1DProp->SetPointSize(aPointSize); my1DExtProp = vtkProperty::New(); @@ -179,12 +196,14 @@ SMESH_Actor::SMESH_Actor(){ anRGB[1] = 1 - anRGB[1]; anRGB[2] = 1 - anRGB[2]; my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); - my1DExtProp->SetLineWidth(aCotnrolLineWidth); + my1DExtProp->SetLineWidth(aLineWidth + aLineWidthInc); + my1DExtProp->SetPointSize(aPointSize + aPointSizeInc); my1DExtActor = SMESH_DeviceActor::New(); my1DExtActor->SetUserMatrix(aMatrix); my1DExtActor->SetStoreMapping(true); my1DExtActor->PickableOff(); + my1DExtActor->SetHighlited(true); my1DExtActor->SetVisibility(false); my1DExtActor->SetProperty(my1DExtProp); my1DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe); @@ -196,9 +215,9 @@ SMESH_Actor::SMESH_Actor(){ //Definition 0D divice of the actor //--------------------------------- myNodeProp = vtkProperty::New(); - anRGB[0] = GetFloat("SMESH:SettingsNodeColorRed",255)/255.; - anRGB[1] = GetFloat("SMESH:SettingsNodeColorGreen",0)/255.; - anRGB[2] = GetFloat("SMESH:SettingsNodeColorBlue",0)/255.; + anRGB[0] = SMESH::GetFloat("SMESH:SettingsNodeColorRed",255)/255.; + anRGB[1] = SMESH::GetFloat("SMESH:SettingsNodeColorGreen",0)/255.; + anRGB[2] = SMESH::GetFloat("SMESH:SettingsNodeColorBlue",0)/255.; myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myNodeProp->SetPointSize(aPointSize); @@ -227,9 +246,9 @@ SMESH_Actor::SMESH_Actor(){ myHighlightProp->SetAmbient(1.0); myHighlightProp->SetDiffuse(0.0); myHighlightProp->SetSpecular(0.0); - anRGB[0] = GetFloat("SMESH:SettingsSelectColorRed", 255)/255.; // 1; - anRGB[1] = GetFloat("SMESH:SettingsSelectColorGreen", 255)/255.; // 1; - anRGB[2] = GetFloat("SMESH:SettingsSelectColorBlue", 255)/255.; // 1; + anRGB[0] = SMESH::GetFloat("SMESH:SettingsSelectColorRed", 255)/255.; // 1; + anRGB[1] = SMESH::GetFloat("SMESH:SettingsSelectColorGreen", 255)/255.; // 1; + anRGB[2] = SMESH::GetFloat("SMESH:SettingsSelectColorBlue", 255)/255.; // 1; myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myHighlightProp->SetPointSize(aPointSize); myHighlightProp->SetRepresentation(1); @@ -238,9 +257,9 @@ SMESH_Actor::SMESH_Actor(){ myPreselectProp->SetAmbient(1.0); myPreselectProp->SetDiffuse(0.0); myPreselectProp->SetSpecular(0.0); - anRGB[0] = GetFloat("SMESH:SettingsPreSelectColorRed", 0)/255.; // 0; - anRGB[1] = GetFloat("SMESH:SettingsPreSelectColorGreen", 255)/255.; // 1; - anRGB[2] = GetFloat("SMESH:SettingsPreSelectColorBlue", 255)/255.; // 1; + anRGB[0] = SMESH::GetFloat("SMESH:SettingsPreSelectColorRed", 0)/255.; // 0; + anRGB[1] = SMESH::GetFloat("SMESH:SettingsPreSelectColorGreen", 255)/255.; // 1; + anRGB[2] = SMESH::GetFloat("SMESH:SettingsPreSelectColorBlue", 255)/255.; // 1; myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myPreselectProp->SetPointSize(aPointSize); myPreselectProp->SetRepresentation(1); @@ -251,18 +270,21 @@ SMESH_Actor::SMESH_Actor(){ myHighlitableActor->PickableOff(); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); + myNodeHighlitableActor = SMESH_DeviceActor::New(); + myNodeHighlitableActor->SetUserMatrix(aMatrix); + myNodeHighlitableActor->SetStoreMapping(false); + myNodeHighlitableActor->PickableOff(); + myNodeHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint); + aFilter = myNodeHighlitableActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfExtraction(SALOME_ExtractUnstructuredGrid::ePoints); + - SetShrinkFactor(GetFloat("SMESH:SettingsShrinkCoeff", 75)/100.); + SetShrinkFactor(SMESH::GetFloat("SMESH:SettingsShrinkCoeff", 75)/100.); myName = ""; myIO = NULL; - myDisplayMode = 0; - - ishighlighted = false; - ispreselected = false; - myColorMode = eNone; - my1DColorMode = e1DNone; + myControlMode = eNone; myControlActor = my2DActor; //Definition of myScalarBarActor @@ -415,7 +437,9 @@ SMESH_Actor::SMESH_Actor(){ aPtsTextProp->SetShadow(0); myPtsLabeledDataMapper->SetLabelTextProperty(aPtsTextProp); aPtsTextProp->Delete(); - + + myEntityMode = eAllEntity; + myIsPointsLabeled = false; myPointLabels = vtkActor2D::New(); @@ -461,11 +485,15 @@ SMESH_Actor::SMESH_Actor(){ myCellsLabels->SetMapper(myClsLabeledDataMapper); myCellsLabels->GetProperty()->SetColor(0,1,0); myCellsLabels->SetVisibility(myIsCellsLabeled); + + // Clipping planes + myImplicitBoolean = vtkImplicitBoolean::New(); + myImplicitBoolean->SetOperationTypeToIntersection(); } -SMESH_Actor::~SMESH_Actor(){ - if(MYDEBUG) MESSAGE("~SMESH_Actor"); +SMESH_ActorDef::~SMESH_ActorDef(){ + if(MYDEBUG) MESSAGE("~SMESH_ActorDef"); myScalarBarActor->Delete(); myLookupTable->Delete(); @@ -490,7 +518,9 @@ SMESH_Actor::~SMESH_Actor(){ myNodeActor->Delete(); myBaseActor->Delete(); + myHighlitableActor->Delete(); + myNodeHighlitableActor->Delete(); //Deleting of pints numbering pipeline @@ -526,16 +556,21 @@ SMESH_Actor::~SMESH_Actor(){ myCellCenters->Delete(); myCellsLabels->Delete(); + + myImplicitBoolean->Delete(); + + myTimeStamp->Delete(); } -void SMESH_Actor::SetPointsLabeled( bool theIsPointsLabeled ) +void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled ) { - myIsPointsLabeled = theIsPointsLabeled; + vtkUnstructuredGrid* aGrid = GetUnstructuredGrid(); + myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints(); if ( myIsPointsLabeled ) { - myPointsNumDataSet->ShallowCopy( GetUnstructuredGrid() ); + myPointsNumDataSet->ShallowCopy(aGrid); vtkDataSet *aDataSet = myPointsNumDataSet; int aNbElem = aDataSet->GetNumberOfPoints(); @@ -558,15 +593,16 @@ void SMESH_Actor::SetPointsLabeled( bool theIsPointsLabeled ) { myPointLabels->SetVisibility( false ); } - - SetRepresentation( GetRepresentation() ); + SetRepresentation(GetRepresentation()); + myTimeStamp->Modified(); } -void SMESH_Actor::SetCellsLabeled(bool theIsCellsLabeled){ - myIsCellsLabeled = theIsCellsLabeled; +void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled){ + vtkUnstructuredGrid* aGrid = GetUnstructuredGrid(); + myIsCellsLabeled = theIsCellsLabeled && aGrid->GetNumberOfPoints(); if(myIsCellsLabeled){ - myCellsNumDataSet->ShallowCopy(GetUnstructuredGrid()); + myCellsNumDataSet->ShallowCopy(aGrid); vtkDataSet *aDataSet = myCellsNumDataSet; int aNbElem = aDataSet->GetNumberOfCells(); vtkIntArray *anArray = vtkIntArray::New(); @@ -581,12 +617,12 @@ void SMESH_Actor::SetCellsLabeled(bool theIsCellsLabeled){ }else{ myCellsLabels->SetVisibility(false); } + myTimeStamp->Modified(); } -void SMESH_Actor::SetControlMode(eControl theMode){ - myColorMode = eNone; - my1DColorMode = e1DNone; +void SMESH_ActorDef::SetControlMode(eControl theMode){ + myControlMode = eNone; my1DActor->GetMapper()->SetScalarVisibility(false); my2DActor->GetMapper()->SetScalarVisibility(false); @@ -596,125 +632,139 @@ void SMESH_Actor::SetControlMode(eControl theMode){ bool anIsScalarVisible = theMode > eNone; if(anIsScalarVisible){ - SMESH::NumericalFunctor_var aFunctor; - SMESH::Predicate_var aPredicate; - + SMESH::Controls::FunctorPtr aFunctor; switch(theMode){ - case eLengthEdges: - aFunctor = myFilterMgr->CreateLength(); + case eLength: + { + SMESH::Controls::Length* aControl = new SMESH::Controls::Length(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my1DActor; break; + } + case eLength2D: + { + aFunctor.reset(new SMESH::Controls::Length2D()); + myControlActor = my2DActor; + break; + } case eFreeBorders: - aPredicate = myFilterMgr->CreateFreeBorders(); + aFunctor.reset(new SMESH::Controls::FreeBorders()); myControlActor = my1DActor; break; + case eFreeEdges: + aFunctor.reset(new SMESH::Controls::FreeEdges()); + myControlActor = my2DActor; + break; case eMultiConnection: - aFunctor = myFilterMgr->CreateMultiConnection(); + aFunctor.reset(new SMESH::Controls::MultiConnection()); myControlActor = my1DActor; break; + case eMultiConnection2D: + aFunctor.reset(new SMESH::Controls::MultiConnection2D()); + myControlActor = my2DActor; + break; case eArea: - aFunctor = myFilterMgr->CreateArea(); + { + SMESH::Controls::Area* aControl = new SMESH::Controls::Area(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my2DActor; break; + } case eTaper: - aFunctor = myFilterMgr->CreateTaper(); + { + SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my2DActor; break; + } case eAspectRatio: - aFunctor = myFilterMgr->CreateAspectRatio(); + { + SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my2DActor; break; + } + case eAspectRatio3D: + { + SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); + myControlActor = my3DActor; + break; + } case eMinimumAngle: - aFunctor = myFilterMgr->CreateMinimumAngle(); + { + SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my2DActor; break; + } case eWarping: - aFunctor = myFilterMgr->CreateWarping(); + { + SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my2DActor; break; + } case eSkew: - aFunctor = myFilterMgr->CreateSkew(); + { + SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); myControlActor = my2DActor; break; + } default: return; } - + vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid(); vtkIdType aNbCells = aGrid->GetNumberOfCells(); if(aNbCells){ - if(theMode == eFreeBorders){ - if(!aPredicate->_is_nil()){ - myVisualObj->UpdateFunctor(aPredicate); - SALOME_ExtractUnstructuredGrid* aFilter = - my1DExtActor->GetExtractUnstructuredGrid(); - aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding); - aFilter->ClearRegisteredCells(); - for( vtkIdType i = 0; i < aNbCells; i++ ){ - vtkIdType anObjId = myControlActor->GetElemObjId( i ); - CORBA::Boolean aValue = aPredicate->IsSatisfy(anObjId); - if(aValue) - aFilter->RegisterCell(i); - } - if(!aFilter->IsCellsRegistered()) - aFilter->RegisterCell(-1); - aPredicate->Destroy(); - } - myColorMode = theMode; - my1DColorMode = e1DHighlited; - }else{ - myColorMode = theMode; - if(myControlActor == my1DActor) - my1DColorMode = e1DColored; - - vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New(); - aDataSet->ShallowCopy(aGrid); - myScalarBarActor->SetVisibility(true); - myControlActor->GetMapper()->SetScalarVisibility(true); - - vtkDoubleArray *aScalars = vtkDoubleArray::New(); - aScalars->SetNumberOfComponents( 1 ); - aScalars->SetNumberOfTuples(aNbCells); - - if(!aFunctor->_is_nil()){ - myVisualObj->UpdateFunctor(aFunctor); - for( vtkIdType i = 0; i < aNbCells; i++ ){ - vtkIdType anObjId = myControlActor->GetElemObjId( i ); - CORBA::Double aValue = aFunctor->GetValue(anObjId); - aScalars->SetValue( i, aValue ); - } - aFunctor->Destroy(); - }else if(!aPredicate->_is_nil()){ - myVisualObj->UpdateFunctor(aPredicate); - for( vtkIdType i = 0; i < aNbCells; i++ ){ - vtkIdType anObjId = myControlActor->GetElemObjId( i ); - CORBA::Boolean aValue = aPredicate->IsSatisfy(anObjId); - aScalars->SetValue( i, aValue ); - } - aPredicate->Destroy(); - } - aDataSet->GetCellData()->SetScalars(aScalars); - aScalars->Delete(); - - float aRange[2]; - aScalars->GetRange(aRange); - myLookupTable->SetRange(aRange); - myLookupTable->Build(); - - myControlActor->GetMergeFilter()->SetScalars(aDataSet); - aDataSet->Delete(); - if(MYDEBUGWITHFILES) - WriteUnstructuredGrid(aDataSet,"/tmp/SetControlMode.vtk"); + myControlMode = theMode; + switch(myControlMode){ + case eFreeEdges: + case eFreeBorders: + my1DExtActor->SetExtControlMode(aFunctor,myControlActor); + break; + case eLength2D: + my1DExtActor->SetExtControlMode(aFunctor,myControlActor,myScalarBarActor,myLookupTable); + break; + case eMultiConnection2D: + my1DExtActor->SetExtControlMode(aFunctor,myControlActor,myScalarBarActor,myLookupTable); + break; + default: + myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable); } } + + if(QAD_CONFIG->getSetting("SMESH:DispayEntity") == "true"){ + if(myControlActor == my1DActor) + myEntityMode = eEdges; + else if(myControlActor == my2DActor) + myEntityMode = eFaces; + else if(myControlActor == my3DActor) + myEntityMode = eVolumes; + } + + }else if(QAD_CONFIG->getSetting("SMESH:DispayEntity") == "true"){ + myEntityMode = eAllEntity; } + SetRepresentation(GetRepresentation()); - + + myTimeStamp->Modified(); Modified(); } -void SMESH_Actor::AddToRender(vtkRenderer* theRenderer){ +void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){ SALOME_Actor::AddToRender(theRenderer); theRenderer->AddActor(myNodeActor); @@ -727,6 +777,7 @@ void SMESH_Actor::AddToRender(vtkRenderer* theRenderer){ theRenderer->AddActor(my1DExtActor); theRenderer->AddActor(myHighlitableActor); + theRenderer->AddActor(myNodeHighlitableActor); theRenderer->AddActor2D(myScalarBarActor); @@ -737,12 +788,14 @@ void SMESH_Actor::AddToRender(vtkRenderer* theRenderer){ theRenderer->AddActor2D(myCellsLabels); } -void SMESH_Actor::RemoveFromRender(vtkRenderer* theRenderer){ +void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ SALOME_Actor::RemoveFromRender(theRenderer); theRenderer->RemoveActor(myNodeActor); theRenderer->RemoveActor(myBaseActor); + theRenderer->RemoveActor(myHighlitableActor); + theRenderer->RemoveActor(myNodeHighlitableActor); theRenderer->RemoveActor(my1DActor); theRenderer->RemoveActor(my1DExtActor); @@ -756,21 +809,21 @@ void SMESH_Actor::RemoveFromRender(vtkRenderer* theRenderer){ } -void SMESH_Actor::Init(TVisualObjPtr theVisualObj, - SMESH::FilterManager_ptr theFilterMgr, - const char* theEntry, - const char* theName, - int theIsClear) +bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, + const char* theEntry, + const char* theName, + int theIsClear) { - Handle(SALOME_InteractiveObject) anIO = - new SALOME_InteractiveObject(strdup(theEntry),strdup("MESH"),strdup(theName)); + Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName); setIO(anIO); - setName(strdup(theName)); + setName(theName); myVisualObj = theVisualObj; myNodeActor->myVisualObj = myVisualObj; myBaseActor->myVisualObj = myVisualObj; + myHighlitableActor->myVisualObj = myVisualObj; + myNodeHighlitableActor->myVisualObj = myVisualObj; my1DActor->myVisualObj = myVisualObj; my1DExtActor->myVisualObj = myVisualObj; @@ -779,10 +832,32 @@ void SMESH_Actor::Init(TVisualObjPtr theVisualObj, my3DActor->myVisualObj = myVisualObj; myVisualObj->Update(theIsClear); - SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid()); + + myNodeActor->Init(myVisualObj,myImplicitBoolean); + myBaseActor->Init(myVisualObj,myImplicitBoolean); + + myHighlitableActor->Init(myVisualObj,myImplicitBoolean); + myNodeHighlitableActor->Init(myVisualObj,myImplicitBoolean); + + my1DActor->Init(myVisualObj,myImplicitBoolean); + my1DExtActor->Init(myVisualObj,myImplicitBoolean); + + my2DActor->Init(myVisualObj,myImplicitBoolean); + my3DActor->Init(myVisualObj,myImplicitBoolean); - myFilterMgr = SMESH::FilterManager::_duplicate(theFilterMgr); + my1DActor->GetMapper()->SetLookupTable(myLookupTable); + my1DExtActor->GetMapper()->SetLookupTable(myLookupTable); + my2DActor->GetMapper()->SetLookupTable(myLookupTable); + my3DActor->GetMapper()->SetLookupTable(myLookupTable); + + float aFactor, aUnits; + my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); + my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); + + //SetIsShrunkable(theGrid->GetNumberOfCells() > 10); + SetIsShrunkable(true); + QString aMode = QAD_CONFIG->getSetting("SMESH:DisplayMode"); SetRepresentation(-1); if(aMode.compare("Wireframe") == 0){ @@ -798,19 +873,28 @@ void SMESH_Actor::Init(TVisualObjPtr theVisualObj, SetShrink(); } + myTimeStamp->Modified(); Modified(); + return true; +} + + +float* SMESH_ActorDef::GetBounds(){ + return myNodeActor->GetBounds(); } -vtkPolyData* SMESH_Actor::GetPolyDataInput(){ - return myPickableActor->GetPolyDataInput(); +vtkDataSet* SMESH_ActorDef::GetInput(){ + return GetUnstructuredGrid(); } -void SMESH_Actor::SetTransform(SALOME_Transform* theTransform){ +void SMESH_ActorDef::SetTransform(SALOME_Transform* theTransform){ myNodeActor->SetTransform(theTransform); myBaseActor->SetTransform(theTransform); + myHighlitableActor->SetTransform(theTransform); + myNodeHighlitableActor->SetTransform(theTransform); my1DActor->SetTransform(theTransform); my1DExtActor->SetTransform(theTransform); @@ -822,72 +906,46 @@ void SMESH_Actor::SetTransform(SALOME_Transform* theTransform){ } -void SMESH_Actor::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid){ - if(theGrid){ - myNodeActor->SetUnstructuredGrid(theGrid); - myBaseActor->SetUnstructuredGrid(theGrid); - myHighlitableActor->SetUnstructuredGrid(theGrid); - - my1DActor->SetUnstructuredGrid(theGrid); - my1DExtActor->SetUnstructuredGrid(theGrid); - - my2DActor->SetUnstructuredGrid(theGrid); - my3DActor->SetUnstructuredGrid(theGrid); - - my1DActor->GetMapper()->SetLookupTable(myLookupTable); - my2DActor->GetMapper()->SetLookupTable(myLookupTable); - my3DActor->GetMapper()->SetLookupTable(myLookupTable); - - float aFactor, aUnits; - my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); - my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); - - //SetIsShrunkable(theGrid->GetNumberOfCells() > 10); - SetIsShrunkable(true); - - Modified(); - } -} - - -void SMESH_Actor::SetMapper(vtkMapper* theMapper){ +void SMESH_ActorDef::SetMapper(vtkMapper* theMapper){ vtkLODActor::SetMapper(theMapper); } -void SMESH_Actor::ShallowCopy(vtkProp *prop){ +void SMESH_ActorDef::ShallowCopy(vtkProp *prop){ SALOME_Actor::ShallowCopy(prop); } -vtkMapper* SMESH_Actor::GetMapper(){ +vtkMapper* SMESH_ActorDef::GetMapper(){ return myPickableActor->GetMapper(); } -vtkUnstructuredGrid* SMESH_Actor::GetUnstructuredGrid(){ +vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid(){ return myVisualObj->GetUnstructuredGrid(); } -bool SMESH_Actor::IsInfinitive(){ +bool SMESH_ActorDef::IsInfinitive(){ vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid(); aDataSet->Update(); - myIsInfinite = aDataSet->GetNumberOfCells() == 0; + myIsInfinite = aDataSet->GetNumberOfCells() == 0 || + aDataSet->GetNumberOfCells() == 1 && + aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX; return SALOME_Actor::IsInfinitive(); } -void SMESH_Actor::SetIsShrunkable(bool theShrunkable){ +void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){ myIsShrinkable = theShrunkable; Modified(); } -float SMESH_Actor::GetShrinkFactor(){ +float SMESH_ActorDef::GetShrinkFactor(){ return myBaseActor->GetShrinkFactor(); } -void SMESH_Actor::SetShrinkFactor(float theValue){ +void SMESH_ActorDef::SetShrinkFactor(float theValue){ myBaseActor->SetShrinkFactor(theValue); my1DActor->SetShrinkFactor(theValue); @@ -899,7 +957,7 @@ void SMESH_Actor::SetShrinkFactor(float theValue){ Modified(); } -void SMESH_Actor::SetShrink(){ +void SMESH_ActorDef::SetShrink(){ if(!myIsShrinkable) return; myBaseActor->SetShrink(); @@ -914,7 +972,7 @@ void SMESH_Actor::SetShrink(){ Modified(); } -void SMESH_Actor::UnShrink(){ +void SMESH_ActorDef::UnShrink(){ if(!myIsShrunk) return; myBaseActor->UnShrink(); @@ -930,85 +988,110 @@ void SMESH_Actor::UnShrink(){ } -int SMESH_Actor::GetObjId(int theVtkID){ - if (GetRepresentation() == 0){ - return GetNodeObjId(theVtkID); - }else{ - return GetElemObjId(theVtkID); - } +int SMESH_ActorDef::GetNodeObjId(int theVtkID){ + return myPickableActor->GetNodeObjId(theVtkID); } -SALOME_Actor::TVectorId SMESH_Actor::GetVtkId(int theObjID){ - if (GetRepresentation() == 0){ - return GetNodeVtkId(theObjID); - }else{ - return GetElemVtkId(theObjID); - } +float* SMESH_ActorDef::GetNodeCoord(int theObjID){ + return myPickableActor->GetNodeCoord(theObjID); } -int SMESH_Actor::GetNodeObjId(int theVtkID){ - return myPickableActor->GetNodeObjId(theVtkID); +int SMESH_ActorDef::GetElemObjId(int theVtkID){ + return myPickableActor->GetElemObjId(theVtkID); } -SALOME_Actor::TVectorId SMESH_Actor::GetNodeVtkId(int theObjID){ - return myPickableActor->GetNodeVtkId(theObjID); +vtkCell* SMESH_ActorDef::GetElemCell(int theObjID){ + return myPickableActor->GetElemCell(theObjID); } -int SMESH_Actor::GetElemObjId(int theVtkID){ - return myPickableActor->GetElemObjId(theVtkID); -} - -SALOME_Actor::TVectorId SMESH_Actor::GetElemVtkId(int theObjID){ - return myPickableActor->GetElemVtkId(theObjID); +void SMESH_ActorDef::SetVisibility(int theMode){ + SetVisibility(theMode,true); } -void SMESH_Actor::SetVisibility(int theMode){ +void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ SALOME_Actor::SetVisibility(theMode); + + myNodeActor->VisibilityOff(); + myBaseActor->VisibilityOff(); + + my1DActor->VisibilityOff(); + my1DExtActor->VisibilityOff(); + + my2DActor->VisibilityOff(); + my3DActor->VisibilityOff(); + + myScalarBarActor->VisibilityOff(); + myPointLabels->VisibilityOff(); + myCellsLabels->VisibilityOff(); + if(GetVisibility()){ - SetRepresentation(GetRepresentation()); + if(theIsUpdateRepersentation) + SetRepresentation(GetRepresentation()); - if(myColorMode != eNone){ - if(my1DColorMode == e1DHighlited) + if(myControlMode != eNone){ + switch(myControlMode){ + case eFreeEdges: + case eFreeBorders: my1DExtActor->VisibilityOn(); - else if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) - myScalarBarActor->VisibilityOn(); + break; + case eLength2D: + my1DExtActor->VisibilityOn(); + case eMultiConnection2D: + my1DExtActor->VisibilityOn(); + default: + if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) + myScalarBarActor->VisibilityOn(); + } } if(myRepresentation != ePoint) myPickableActor->VisibilityOn(); - my1DActor->VisibilityOn(); + if(myEntityMode & eEdges) + my1DActor->VisibilityOn(); + + if(myEntityMode & eFaces) + my2DActor->VisibilityOn(); + + if(myEntityMode & eVolumes) + my3DActor->VisibilityOn(); + + if(myIsPointsLabeled) + myPointLabels->VisibilityOn(); - my2DActor->VisibilityOn(); - my3DActor->VisibilityOn(); + if(myIsCellsLabeled) + myCellsLabels->VisibilityOn(); + } - if(myIsPointsLabeled) myPointLabels->VisibilityOn(); - if(myIsCellsLabeled) myCellsLabels->VisibilityOn(); - }else{ - myNodeActor->VisibilityOff(); - myBaseActor->VisibilityOff(); + Modified(); +} - my1DActor->VisibilityOff(); - my1DExtActor->VisibilityOff(); - my2DActor->VisibilityOff(); - my3DActor->VisibilityOff(); +void SMESH_ActorDef::SetEntityMode(unsigned int theMode){ + if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) + theMode &= ~eEdges; - myScalarBarActor->VisibilityOff(); - myPointLabels->VisibilityOff(); - myCellsLabels->VisibilityOff(); - } - Modified(); -} + if(!myVisualObj->GetNbEntities(SMDSAbs_Face)) + theMode &= ~eFaces; + + if(!myVisualObj->GetNbEntities(SMDSAbs_Volume)) + theMode &= ~eVolumes; + if(!theMode) + return; + + myEntityMode = theMode; + + SetVisibility(GetVisibility(),false); +} -void SMESH_Actor::SetRepresentation(int theMode){ - int aNbEdges = myVisualObj->GetNbEntities(SMESH::EDGE); - int aNbFaces = myVisualObj->GetNbEntities(SMESH::FACE); - int aNbVolumes = myVisualObj->GetNbEntities(SMESH::VOLUME); +void SMESH_ActorDef::SetRepresentation(int theMode){ + int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge); + int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face); + int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume); if(theMode < 0){ myRepresentation = eSurface; if(!aNbFaces && !aNbVolumes && aNbEdges){ @@ -1047,6 +1130,8 @@ void SMESH_Actor::SetRepresentation(int theMode){ switch(myRepresentation){ case ePoint: myPickableActor = myNodeActor; + myNodeActor->SetVisibility(true); + aProp = aBackProp = myNodeProp; aReperesent = SMESH_DeviceActor::ePoint; break; @@ -1070,78 +1155,90 @@ void SMESH_Actor::SetRepresentation(int theMode){ my3DActor->SetRepresentation(aReperesent); my1DExtActor->SetVisibility(false); - switch(my1DColorMode){ - case e1DColored: + + switch(myControlMode){ + case eLength: + case eMultiConnection: aProp = aBackProp = my1DProp; if(myRepresentation != ePoint) aReperesent = SMESH_DeviceActor::eInsideframe; break; - case e1DHighlited: - my1DExtActor->SetVisibility(true); - break; } my1DActor->SetProperty(aProp); my1DActor->SetBackfaceProperty(aBackProp); my1DActor->SetRepresentation(aReperesent); + + my1DExtActor->SetRepresentation(aReperesent); - if ( GetPointRepresentation() || !GetUnstructuredGrid()->GetNumberOfCells() || myIsPointsLabeled ) - { + if(myIsPointsVisible) myPickableActor = myNodeActor; + + if(GetPointRepresentation()) myNodeActor->SetVisibility(true); - } SetMapper(myPickableActor->GetMapper()); + SetVisibility(GetVisibility(),false); + Modified(); } -void SMESH_Actor::SetPointRepresentation(int theIsPointsVisible){ +void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible){ myIsPointsVisible = theIsPointsVisible; SetRepresentation(GetRepresentation()); } +bool SMESH_ActorDef::GetPointRepresentation(){ + return myIsPointsVisible || myIsPointsLabeled; +} + -void SMESH_Actor::UpdateHighlight(){ +void SMESH_ActorDef::UpdateHighlight(){ myHighlitableActor->SetVisibility(false); - myNodeActor->SetProperty(myNodeProp); - if(myPickableActor != myNodeActor) - myNodeActor->SetVisibility(false); + myHighlitableActor->SetHighlited(false); + + myNodeHighlitableActor->SetVisibility(false); + myNodeHighlitableActor->SetHighlited(false); - if(ishighlighted){ + if(myIsHighlighted){ myHighlitableActor->SetProperty(myHighlightProp); - }else if(ispreselected){ + }else if(myIsPreselected){ myHighlitableActor->SetProperty(myPreselectProp); } - if(ishighlighted || ispreselected){ - if(!GetUnstructuredGrid()->GetNumberOfCells()){ - myNodeActor->SetProperty(myHighlitableActor->GetProperty()); - myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint); - myNodeActor->SetVisibility(GetVisibility()); - }else{ + bool isVisible = GetVisibility(); + + if(myIsHighlighted || myIsPreselected){ + if(GetUnstructuredGrid()->GetNumberOfCells()){ myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); - myHighlitableActor->SetVisibility(GetVisibility()); + myHighlitableActor->SetVisibility(isVisible); + myHighlitableActor->SetHighlited(isVisible); + } + if(myRepresentation == ePoint || GetPointRepresentation()){ + myNodeHighlitableActor->SetProperty(myHighlitableActor->GetProperty()); + myNodeHighlitableActor->SetVisibility(isVisible); + myNodeHighlitableActor->SetHighlited(isVisible); } } } -void SMESH_Actor::highlight(Standard_Boolean highlight){ - ishighlighted = highlight; +void SMESH_ActorDef::highlight(bool theHighlight){ + myIsHighlighted = theHighlight; UpdateHighlight(); } -void SMESH_Actor::SetPreSelected(Standard_Boolean presel){ - ispreselected = presel; +void SMESH_ActorDef::SetPreSelected(bool thePreselect){ + myIsPreselected = thePreselect; UpdateHighlight(); } // From vtkFollower -int SMESH_Actor::RenderOpaqueGeometry(vtkViewport *vp) +int SMESH_ActorDef::RenderOpaqueGeometry(vtkViewport *vp) { if (myPickableActor->GetIsOpaque()) { @@ -1153,7 +1250,7 @@ int SMESH_Actor::RenderOpaqueGeometry(vtkViewport *vp) } -int SMESH_Actor::RenderTranslucentGeometry(vtkViewport *vp) +int SMESH_ActorDef::RenderTranslucentGeometry(vtkViewport *vp) { if (!myPickableActor->GetIsOpaque()) { @@ -1165,10 +1262,38 @@ int SMESH_Actor::RenderTranslucentGeometry(vtkViewport *vp) } -void SMESH_Actor::Render(vtkRenderer *ren){} +void SMESH_ActorDef::Render(vtkRenderer *ren){ + unsigned long aTime = myTimeStamp->GetMTime(); + unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime(); + unsigned long aClippingTime = myImplicitBoolean->GetMTime(); + if(anObjTime > aTime || aClippingTime > aTime) + Update(); +} + + +void SMESH_ActorDef::Update(){ + if(MYDEBUG) MESSAGE("SMESH_ActorDef::Update"); + + if(GetControlMode() != eNone) { + unsigned long aTime = myTimeStamp->GetMTime(); + unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime(); + if (anObjTime > aTime) + SetControlMode(GetControlMode()); + } + if(myIsPointsLabeled){ + SetPointsLabeled(myIsPointsLabeled); + } + if(myIsCellsLabeled){ + SetCellsLabeled(myIsCellsLabeled); + } + SetVisibility(GetVisibility()); + + myTimeStamp->Modified(); + Modified(); +} -void SMESH_Actor::ReleaseGraphicsResources(vtkWindow *renWin){ +void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){ SALOME_Actor::ReleaseGraphicsResources(renWin); myPickableActor->ReleaseGraphicsResources(renWin); @@ -1183,7 +1308,7 @@ static void GetColor(vtkProperty *theProperty, float& r,float& g,float& b){ } -void SMESH_Actor::SetOpacity(float theValue){ +void SMESH_ActorDef::SetOpacity(float theValue){ mySurfaceProp->SetOpacity(theValue); myBackSurfaceProp->SetOpacity(theValue); myEdgeProp->SetOpacity(theValue); @@ -1193,95 +1318,190 @@ void SMESH_Actor::SetOpacity(float theValue){ } -float SMESH_Actor::GetOpacity(){ +float SMESH_ActorDef::GetOpacity(){ return mySurfaceProp->GetOpacity(); } -void SMESH_Actor::SetSufaceColor(float r,float g,float b){ +void SMESH_ActorDef::SetSufaceColor(float r,float g,float b){ mySurfaceProp->SetColor(r,g,b); Modified(); } -void SMESH_Actor::GetSufaceColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetSufaceColor(float& r,float& g,float& b){ ::GetColor(mySurfaceProp,r,g,b); } -void SMESH_Actor::SetBackSufaceColor(float r,float g,float b){ +void SMESH_ActorDef::SetBackSufaceColor(float r,float g,float b){ myBackSurfaceProp->SetColor(r,g,b); Modified(); } -void SMESH_Actor::GetBackSufaceColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetBackSufaceColor(float& r,float& g,float& b){ ::GetColor(myBackSurfaceProp,r,g,b); } -void SMESH_Actor::SetEdgeColor(float r,float g,float b){ +void SMESH_ActorDef::SetEdgeColor(float r,float g,float b){ myEdgeProp->SetColor(r,g,b); my1DProp->SetColor(r,g,b); my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b); Modified(); } -void SMESH_Actor::GetEdgeColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetEdgeColor(float& r,float& g,float& b){ ::GetColor(myEdgeProp,r,g,b); } -void SMESH_Actor::SetNodeColor(float r,float g,float b){ +void SMESH_ActorDef::SetNodeColor(float r,float g,float b){ myNodeProp->SetColor(r,g,b); Modified(); } -void SMESH_Actor::GetNodeColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetNodeColor(float& r,float& g,float& b){ ::GetColor(myNodeProp,r,g,b); } -void SMESH_Actor::SetHighlightColor(float r,float g,float b){ +void SMESH_ActorDef::SetHighlightColor(float r,float g,float b){ myHighlightProp->SetColor(r,g,b); Modified(); } -void SMESH_Actor::GetHighlightColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetHighlightColor(float& r,float& g,float& b){ ::GetColor(myHighlightProp,r,g,b); } -void SMESH_Actor::SetPreHighlightColor(float r,float g,float b){ +void SMESH_ActorDef::SetPreHighlightColor(float r,float g,float b){ myPreselectProp->SetColor(r,g,b); Modified(); } -void SMESH_Actor::GetPreHighlightColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetPreHighlightColor(float& r,float& g,float& b){ ::GetColor(myPreselectProp,r,g,b); } -float SMESH_Actor::GetLineWidth(){ +float SMESH_ActorDef::GetLineWidth(){ return myEdgeProp->GetLineWidth(); } -void SMESH_Actor::SetLineWidth(float theVal){ +void SMESH_ActorDef::SetLineWidth(float theVal){ myEdgeProp->SetLineWidth(theVal); + + my1DProp->SetLineWidth(theVal + aLineWidthInc); + my1DExtProp->SetLineWidth(theVal + aLineWidthInc); + Modified(); } -void SMESH_Actor::SetNodeSize(float theSize){ - myNodeProp->SetPointSize(theSize); - myHighlightProp->SetPointSize(theSize); - myPreselectProp->SetPointSize(theSize); +void SMESH_ActorDef::SetNodeSize(float theVal){ + myNodeProp->SetPointSize(theVal); + myHighlightProp->SetPointSize(theVal); + myPreselectProp->SetPointSize(theVal); - my1DExtProp->SetPointSize(theSize); - my1DProp->SetPointSize(theSize); + my1DProp->SetPointSize(theVal + aPointSizeInc); + my1DExtProp->SetPointSize(theVal + aPointSizeInc); Modified(); } -float SMESH_Actor::GetNodeSize(){ +float SMESH_ActorDef::GetNodeSize(){ return myNodeProp->GetPointSize(); } -int SMESH_Actor::GetObjDimension( const int theObjId ) +int SMESH_ActorDef::GetObjDimension( const int theObjId ) { return myVisualObj->GetElemDimension( theObjId ); } + + +vtkImplicitBoolean* SMESH_ActorDef::GetPlaneContainer(){ + return myImplicitBoolean; +} + + +static void ComputeBoundsParam(vtkDataSet* theDataSet, + float theDirection[3], float theMinPnt[3], + float& theMaxBoundPrj, float& theMinBoundPrj) +{ + float aBounds[6]; + theDataSet->GetBounds(aBounds); + + //Enlarge bounds in order to avoid conflicts of precision + for(int i = 0; i < 6; i += 2){ + static double EPS = 1.0E-3; + float aDelta = (aBounds[i+1] - aBounds[i])*EPS; + aBounds[i] -= aDelta; + aBounds[i+1] += aDelta; + } + + float aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]}, + {aBounds[1],aBounds[2],aBounds[4]}, + {aBounds[0],aBounds[3],aBounds[4]}, + {aBounds[1],aBounds[3],aBounds[4]}, + {aBounds[0],aBounds[2],aBounds[5]}, + {aBounds[1],aBounds[2],aBounds[5]}, + {aBounds[0],aBounds[3],aBounds[5]}, + {aBounds[1],aBounds[3],aBounds[5]}}; + + int aMaxId = 0, aMinId = aMaxId; + theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]); + theMinBoundPrj = theMaxBoundPrj; + for(int i = 1; i < 8; i++){ + float aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]); + if(theMaxBoundPrj < aTmp){ + theMaxBoundPrj = aTmp; + aMaxId = i; + } + if(theMinBoundPrj > aTmp){ + theMinBoundPrj = aTmp; + aMinId = i; + } + } + float *aMinPnt = aBoundPoints[aMaxId]; + theMinPnt[0] = aMinPnt[0]; + theMinPnt[1] = aMinPnt[1]; + theMinPnt[2] = aMinPnt[2]; +} + + +static void DistanceToPosition(vtkDataSet* theDataSet, + float theDirection[3], float theDist, float thePos[3]) +{ + float aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; + ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); + float aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist; + thePos[0] = aMinPnt[0]-theDirection[0]*aLength; + thePos[1] = aMinPnt[1]-theDirection[1]*aLength; + thePos[2] = aMinPnt[2]-theDirection[2]*aLength; +} + + +static void PositionToDistance(vtkDataSet* theDataSet, + float theDirection[3], float thePos[3], float& theDist) +{ + float aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; + ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); + float aPrj = vtkMath::Dot(theDirection,thePos); + theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj); +} + + +void SMESH_ActorDef::SetPlaneParam(float theDir[3], float theDist, vtkPlane* thePlane) +{ + thePlane->SetNormal(theDir); + float anOrigin[3]; + ::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin); + thePlane->SetOrigin(anOrigin); +} + + +void SMESH_ActorDef::GetPlaneParam(float theDir[3], float& theDist, vtkPlane* thePlane) +{ + thePlane->GetNormal(theDir); + + float anOrigin[3]; + thePlane->GetOrigin(anOrigin); + ::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist); +}