aCriterion.UnaryOp = FT_Undefined;
aCriterion.BinaryOp = FT_Undefined;
aCriterion.ThresholdStr = "";
+ aCriterion.ThresholdID = "";
aCriterion.Tolerance = Precision::Confusion();
aCriterion.TypeOfElement = SMESH::ALL;
aCriterion.Precision = -1;
return TopoDS_Shape();
}
+static TopoDS_Shape getShapeByID( const char* theID )
+{
+ if ( theID != 0 && theID!="" )
+ {
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
+ if ( aStudy != 0 )
+ {
+ CORBA::Object_var obj = aStudy->ConvertIORToObject(theID);
+ GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( obj );
+
+ if ( !aGeomObj->_is_nil() )
+ {
+ GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
+ return aLocShape;
+ }
+ }
+ }
+ return TopoDS_Shape();
+}
+static char* getShapeNameByID ( const char* theID )
+{
+ char* aName = "";
+
+ if ( theID != 0 && theID!="" )
+ {
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
+ if ( aStudy != 0 )
+ {
+ SALOMEDS::SObject_var aSObj = aStudy->FindObjectIOR( theID );
+ SALOMEDS::GenericAttribute_var anAttr;
+ if ( !aSObj->_is_nil() && aSObj->FindAttribute( anAttr, "AttributeName") )
+ {
+ SALOMEDS::AttributeName_var aNameAttr = SALOMEDS::AttributeName::_narrow( anAttr );
+ aName = aNameAttr->Value();
+ }
+ }
+ }
+
+ return aName;
+}
/*
FUNCTORS
return myPredicatePtr;
}
+/*
+ Class : BadOrientedVolume_i
+ Description : Verify whether a mesh volume is incorrectly oriented from
+ the point of view of MED convention
+*/
+BadOrientedVolume_i::BadOrientedVolume_i()
+{
+ Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
+ myFunctorPtr = myPredicatePtr = control;
+};
+
+FunctorType BadOrientedVolume_i::GetFunctorType()
+{
+ return SMESH::FT_BadOrientedVolume;
+}
/*
Class : BelongToGeom_i
myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
myShapeName = 0;
+ myShapeID = 0;
}
BelongToGeom_i::~BelongToGeom_i()
{
delete myShapeName;
+ delete myShapeID;
}
void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
}
+void BelongToGeom_i::SetShape( const char* theID, const char* theName )
+{
+ delete myShapeName;
+ myShapeName = strdup( theName );
+ delete myShapeID;
+ if ( theID )
+ myShapeID = strdup( theID );
+ else
+ myShapeID = 0;
+
+ if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
+ myBelongToGeomPtr->SetGeom( getShapeByID(myShapeID) );
+ else
+ myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+}
+
char* BelongToGeom_i::GetShapeName()
{
return CORBA::string_dup( myShapeName );
}
+char* BelongToGeom_i::GetShapeID()
+{
+ return CORBA::string_dup( myShapeID );
+}
+
/*
Class : BelongToSurface_i
Description : Predicate for selection on geometrical support
myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
myShapeName = 0;
+ myShapeID = 0;
mySurfaceType = theSurfaceType;
}
BelongToSurface_i::~BelongToSurface_i()
{
delete myShapeName;
+ delete myShapeID;
}
void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
}
+void BelongToSurface_i::SetShape( const char* theID, const char* theName, ElementType theType )
+{
+ delete myShapeName;
+ myShapeName = strdup( theName );
+ delete myShapeID;
+ if ( theID )
+ myShapeID = strdup( theID );
+ else
+ myShapeID = 0;
+
+ if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
+ myElementsOnSurfacePtr->SetSurface( getShapeByID(myShapeID), (SMDSAbs_ElementType)theType );
+ else
+ myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
+}
+
char* BelongToSurface_i::GetShapeName()
{
return CORBA::string_dup( myShapeName );
}
+char* BelongToSurface_i::GetShapeID()
+{
+ return CORBA::string_dup( myShapeID );
+}
+
void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
{
myElementsOnSurfacePtr->SetTolerance( theToler );
myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
myShapeName = 0;
+ myShapeID = 0;
}
LyingOnGeom_i::~LyingOnGeom_i()
{
delete myShapeName;
+ delete myShapeID;
}
void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
}
+void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
+{
+ delete myShapeName;
+ myShapeName = strdup( theName );
+ delete myShapeID;
+ if ( theID )
+ myShapeID = strdup( theID );
+ else
+ myShapeID = 0;
+
+ if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
+ myLyingOnGeomPtr->SetGeom( getShapeByID(myShapeID) );
+ else
+ myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+}
+
char* LyingOnGeom_i::GetShapeName()
{
return CORBA::string_dup( myShapeName );
}
+char* LyingOnGeom_i::GetShapeID()
+{
+ return CORBA::string_dup( myShapeID );
+}
+
/*
Class : FreeBorders_i
Description : Predicate for free borders
return anObj._retn();
}
+BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
+{
+ SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
+ SMESH::BadOrientedVolume_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
LessThan_ptr FilterManager_i::CreateLessThan()
{
SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
theCriteria[ i ].Type = FT_BelongToGeom;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
+ theCriteria[ i ].ThresholdID = aPred->GetShapeID();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
return true;
theCriteria[ i ].Type = aFType;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
+ theCriteria[ i ].ThresholdID = aPred->GetShapeID();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
theCriteria[ i ].Tolerance = aPred->GetTolerance();
theCriteria[ i ].Type = FT_LyingOnGeom;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
+ theCriteria[ i ].ThresholdID = aPred->GetShapeID();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
return true;
theCriteria[ i ].ThresholdStr = aPred->GetRangeStr();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
+ return true;
+ }
+ case FT_BadOrientedVolume:
+ {
+ BadOrientedVolume_i* aPred = dynamic_cast<BadOrientedVolume_i*>( thePred );
+
+ CORBA::ULong i = theCriteria->length();
+ theCriteria->length( i + 1 );
+
+ theCriteria[ i ] = createCriterion();
+
+ theCriteria[ i ].Type = FT_BadOrientedVolume;
+ theCriteria[ i ].TypeOfElement = aPred->GetElementType();
+
return true;
}
case FT_LessThan:
int aBinary = theCriteria[ i ].BinaryOp;
double aTolerance = theCriteria[ i ].Tolerance;
const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
+ const char* aThresholdID = theCriteria[ i ].ThresholdID;
ElementType aTypeOfElem = theCriteria[ i ].TypeOfElement;
long aPrecision = theCriteria[ i ].Precision;
{
SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
tmpPred->SetElementType( aTypeOfElem );
- tmpPred->SetShapeName( aThresholdStr );
+ tmpPred->SetShape( aThresholdID, aThresholdStr );
aPredicate = tmpPred;
}
break;
tmpPred = aFilterMgr->CreateBelongToPlane();
else
tmpPred = aFilterMgr->CreateBelongToCylinder();
- tmpPred->SetShapeName( aThresholdStr, aTypeOfElem );
+ tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
tmpPred->SetTolerance( aTolerance );
aPredicate = tmpPred;
}
{
SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
tmpPred->SetElementType( aTypeOfElem );
- tmpPred->SetShapeName( aThresholdStr );
+ tmpPred->SetShape( aThresholdID, aThresholdStr );
aPredicate = tmpPred;
}
break;
aPredicate = tmpPred;
}
break;
+ case SMESH::FT_BadOrientedVolume:
+ {
+ aPredicate = aFilterMgr->CreateBadOrientedVolume();
+ }
+ break;
default:
continue;
case FT_BelongToPlane : return "Belong to Plane";
case FT_BelongToCylinder: return "Belong to Cylinder";
case FT_LyingOnGeom : return "Lying on Geom";
+ case FT_BadOrientedVolume: return "Bad Oriented Volume";
case FT_RangeOfIds : return "Range of IDs";
case FT_FreeBorders : return "Free borders";
case FT_FreeEdges : return "Free edges";
else if ( theStr.equals( "Length" ) ) return FT_Length;
// else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
+ else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
else if ( theStr.equals( "Less than" ) ) return FT_LessThan;
else if ( theStr.equals( "More than" ) ) return FT_MoreThan;
else if ( theStr.equals( "Equal to" ) ) return FT_EqualTo;
aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type ) );
aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
- aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) );
aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
}
else
aCriterion.ThresholdStr = str.GetString();
-
+
aCriteria.push_back( aCriterion );
}