#include "HYDROData_CalculationCase.h"
#include "HYDROData_ArtificialObject.h"
-#include "HYDROData_Bathymetry.h"
+#include "HYDROData_IAltitudeObject.h"
#include "HYDROData_Document.h"
#include "HYDROData_ShapesGroup.h"
#include "HYDROData_Iterator.h"
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
-
+//#define DEB_CALCULATION 1
+#ifdef DEB_CALCULATION
+#include <BRepTools.hxx>
+#include <TopLoc_Location.hxx>
+#endif
#define CALCULATION_REGIONS_PREF GetName() + "_Reg"
#define CALCULATION_ZONES_PREF GetName() + "_Zone"
#define CALCULATION_GROUPS_PREF GetName() + "_"
-
-#define PYTHON_CALCULATION_ID "KIND_CALCULATION"
+//#define DEB_CLASS2D 1
+#ifdef DEB_CLASS2D
+#include <BRepBuilderAPI_MakeVertex.hxx>
+#endif
#define EXPORT_NAME "HYDRO_" + GetName()
if ( aRegion.IsNull() )
continue;
- QString aRegionName = aRegion->GetName();
- if ( aRegionName.startsWith( anOldCaseName ) )
- {
- aRegionName.replace( anOldCaseName, theName );
- aRegion->SetName( aRegionName );
- }
+ HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegion );
HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
HYDROData_SequenceOfObjects::Iterator anIter( aZones );
if ( aRegZone.IsNull() )
continue;
- QString aRegionZoneName = aRegZone->GetName();
- if ( aRegionZoneName.startsWith( anOldCaseName ) )
- {
- aRegionZoneName.replace( anOldCaseName, theName );
- aRegZone->SetName( aRegionZoneName );
- }
+ HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegZone );
}
}
- HYDROData_SequenceOfObjects aGroups = GetGeometryGroups();
+ HYDROData_SequenceOfObjects aGroups = GetSplittedGroups();
anIter.Init( aGroups );
for ( ; anIter.More(); anIter.Next() )
if ( aGroup.IsNull() )
continue;
- QString aGroupName = aGroup->GetName();
- if ( aGroupName.startsWith( anOldCaseName ) )
- {
- aGroupName.replace( anOldCaseName, theName );
- aGroup->SetName( aGroupName );
- }
+ HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aGroup );
}
}
QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
{
- QStringList aResList;
+ QStringList aResList = dumpObjectCreation( theTreatedObjects );
- Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
- if ( aDocument.IsNull() )
- return aResList;
-
- QString aDocName = aDocument->GetDocPyName();
- QString aCalculName = GetName();
-
- aResList << QString( "%1 = %2.CreateObject( %3 );" )
- .arg( aCalculName ).arg( aDocName ).arg( PYTHON_CALCULATION_ID );
- aResList << QString( "%1.SetName( \"%2\" );" )
- .arg( aCalculName ).arg( aCalculName );
- aResList << QString( "" );
+ QString aCalculName = GetObjPyName();
HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
HYDROData_SequenceOfObjects::Iterator anIter( aGeomObjects );
{
Handle(HYDROData_Object) aRefGeomObj =
Handle(HYDROData_Object)::DownCast( anIter.Value() );
- if ( !aRefGeomObj.IsNull() )
- setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" );
+ setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" );
}
aResList << QString( "" );
- aResList << QString( "%1.SplitGeometryObjects();" ).arg( aCalculName );
+ QString aGroupName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "case_geom_group" );
+
+ HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups();
+ anIter.Init( aGeomGroups );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ Handle(HYDROData_ShapesGroup) aGeomGroup =
+ Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
+ if ( aGeomGroup.IsNull() )
+ continue;
+
+ Handle(HYDROData_Object) aFatherGeom =
+ Handle(HYDROData_Object)::DownCast( aGeomGroup->GetFatherObject() );
+ if ( aFatherGeom.IsNull() )
+ continue;
+
+ int aGroupId = aFatherGeom->GetGroupId( aGeomGroup );
+ aResList << QString( "%1 = %2.GetGroup( %3 );" )
+ .arg( aGroupName ).arg( aFatherGeom->GetObjPyName() ).arg( aGroupId );
+
+ aResList << QString( "%1.AddGeometryGroup( %2 );" ).arg( aCalculName ).arg( aGroupName );
+ }
+ aResList << QString( "" );
+
+ Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
+ setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" );
+ aResList << QString( "" );
+
+ aResList << QString( "%1.Update();" ).arg( aCalculName );
aResList << QString( "" );
// Now we restore the regions and zones order
continue;
QString aRegionName = aRegion->GetName();
- // TODO
+
+ HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
+ HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones );
+ for ( ; aZonesIter.More(); aZonesIter.Next() )
+ {
+ Handle(HYDROData_Zone) aRegZone =
+ Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() );
+ if ( aRegZone.IsNull() )
+ continue;
+
+ // TODO
+ }
}
+ aResList << QString( "" );
return aResList;
}
{
const QString& anObjName = aSplitData.ObjectNames.at( i );
- Handle(HYDROData_Object) aRefObject = Handle(HYDROData_Object)::DownCast(
- HYDROData_Tool::FindObjectByName( aDocument, anObjName ) );
+ Handle(HYDROData_Object) aRefObject =
+ Handle(HYDROData_Object)::DownCast( aDocument->FindObjectByName( anObjName ) );
if ( aRefObject.IsNull() )
continue;
QString anObjName = aSplitData.ObjectNames.first();
if ( anObjName.isEmpty() )
continue;
-
+#ifdef DEB_CALCULATION
+ QString aStr = aSplitData.ObjectNames.join(" ");
+ cout << " CCase: Names = "<<aStr.toStdString() << " size = " <<aSplitData.ObjectNames.size() <<endl;
+#endif
Handle(HYDROData_SplittedShapesGroup) aSplittedGroup;
if ( !aSplittedEdgesGroupsMap.contains( anObjName ) )
{
double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const
{
- double aResAltitude = HYDROData_Bathymetry::GetInvalidAltitude();
+ Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
+ return GetAltitudeForPoint( thePoint, aZone );
+}
+
+double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint,
+ const Handle(HYDROData_Region)& theRegion ) const
+{
+ double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude();
Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
- if ( aZone.IsNull() )
+ if ( !aZone.IsNull() )
+ {
+ Handle(HYDROData_Region) aRefRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() );
+ if ( IsEqual( aRefRegion, theRegion ) )
+ aResAltitude = GetAltitudeForPoint( thePoint, aZone );
+ }
+
+ return aResAltitude;
+}
+
+double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint,
+ const Handle(HYDROData_Zone)& theZone ) const
+{
+ double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude();
+ if ( theZone.IsNull() )
return aResAltitude;
- HYDROData_Zone::MergeBathymetriesType aZoneMergeType = aZone->GetMergeType();
- if ( !aZone->IsMergingNeed() )
+ HYDROData_Zone::MergeAltitudesType aZoneMergeType = theZone->GetMergeType();
+ if ( !theZone->IsMergingNeed() )
{
aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN;
}
return aResAltitude;
}
+ HYDROData_IInterpolator* aZoneInterpolator = theZone->GetInterpolator();
if ( aZoneMergeType == HYDROData_Zone::Merge_Object )
{
- Handle(HYDROData_Bathymetry) aMergeBathymetry = aZone->GetMergeBathymetry();
- if ( !aMergeBathymetry.IsNull() )
- aResAltitude = aMergeBathymetry->GetAltitudeForPoint( thePoint );
+ Handle(HYDROData_IAltitudeObject) aMergeAltitude = theZone->GetMergeAltitude();
+ if ( !aMergeAltitude.IsNull() )
+ {
+ if ( aZoneInterpolator != NULL )
+ {
+ aZoneInterpolator->SetAltitudeObject( aMergeAltitude );
+ aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint );
+ }
+ else
+ aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint );
+ }
}
else
{
- HYDROData_SequenceOfObjects aZoneObjects = aZone->GetGeometryObjects();
+ HYDROData_SequenceOfObjects aZoneObjects = theZone->GetGeometryObjects();
HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects );
for ( ; anIter.More(); anIter.Next() )
{
if ( aZoneObj.IsNull() )
continue;
- Handle(HYDROData_Bathymetry) anObjBathymetry = aZoneObj->GetBathymetry();
- if ( anObjBathymetry.IsNull() )
+ Handle(HYDROData_IAltitudeObject) anObjAltitude = aZoneObj->GetAltitudeObject();
+ if ( anObjAltitude.IsNull() )
continue;
- double aPointAltitude = anObjBathymetry->GetAltitudeForPoint( thePoint );
- if ( ValuesEquals( aPointAltitude, HYDROData_Bathymetry::GetInvalidAltitude() ) )
+ double aPointAltitude = 0.0;
+ if ( aZoneInterpolator != NULL )
+ {
+ aZoneInterpolator->SetAltitudeObject( anObjAltitude );
+ aPointAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint );
+ }
+ else
+ aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint );
+
+ if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) )
continue;
if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
}
else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMIN )
{
- if ( ValuesEquals( aResAltitude, HYDROData_Bathymetry::GetInvalidAltitude() ) ||
+ if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
aResAltitude > aPointAltitude )
{
aResAltitude = aPointAltitude;
}
else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMAX )
{
- if ( ValuesEquals( aResAltitude, HYDROData_Bathymetry::GetInvalidAltitude() ) ||
+ if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
aResAltitude < aPointAltitude )
{
aResAltitude = aPointAltitude;
return aResAltitude;
}
+NCollection_Sequence<double> HYDROData_CalculationCase::GetAltitudesForPoints(
+ const NCollection_Sequence<gp_XY>& thePoints,
+ const Handle(HYDROData_Region)& theRegion ) const
+{
+ NCollection_Sequence<double> aResSeq;
+
+ for ( int i = 1, n = thePoints.Length(); i <= n; ++i )
+ {
+ const gp_XY& thePnt = thePoints.Value( i );
+
+ double anAltitude = GetAltitudeForPoint( thePnt, theRegion );
+ aResSeq.Append( anAltitude );
+ }
+
+ return aResSeq;
+}
+
+NCollection_Sequence<double> HYDROData_CalculationCase::GetAltitudesForPoints(
+ const NCollection_Sequence<gp_XY>& thePoints,
+ const Handle(HYDROData_Zone)& theZone ) const
+{
+ NCollection_Sequence<double> aResSeq;
+
+ for ( int i = 1, n = thePoints.Length(); i <= n; ++i )
+ {
+ const gp_XY& thePnt = thePoints.Value( i );
+
+ double anAltitude = GetAltitudeForPoint( thePnt, theZone );
+ aResSeq.Append( anAltitude );
+ }
+
+ return aResSeq;
+}
+
+Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const
+{
+ Handle(HYDROData_Region) aResRegion;
+
+ Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
+ if ( !aZone.IsNull() )
+ aResRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() );
+
+ return aResRegion;
+}
+
Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint ) const
{
Handle(HYDROData_Zone) aResZone;
TopoDS_Face aZoneFace = TopoDS::Face( theZone->GetShape() );
if ( aZoneFace.IsNull() )
return aRes;
-
- BRepTopAdaptor_FClass2d aClassifier( aZoneFace, Precision::Confusion() );
- TopAbs_State State = aClassifier.Perform( gp_Pnt2d(thePoint), Standard_False );
+#ifdef DEB_CLASS2D
+ TopoDS_Compound aCmp;
+ BRep_Builder aBB;
+ aBB.MakeCompound(aCmp);
+ aBB.Add(aCmp, aZoneFace);
+ gp_Pnt aPnt (thePoint.X(), thePoint.Y(), 0.);
+ BRepBuilderAPI_MakeVertex aMk(aPnt);
+ aBB.Add(aCmp, aMk.Vertex());
+ BRepTools::Write(aCmp, "FCL2d.brep");
+#endif
+ TopAbs_State State = HYDROData_Tool::ComputePointState(thePoint, aZoneFace);
if (State == TopAbs_OUT)
- aRes = POINT_OUT;
+ aRes = POINT_OUT;
else if(State == TopAbs_IN)
aRes = POINT_IN;
else if(State == TopAbs_ON)
- aRes = POINT_ON;
+ aRes = POINT_ON;
return aRes;
}
return aNewGroup;
}
-bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine,
- SALOMEDS::Study_ptr theStudy )
+bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine,
+ SALOMEDS::Study_ptr theStudy ) const
{
+ HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs;
+
+ // Get groups definitions
+ HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups();
+
+ HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ // Get shapes group
+ Handle(HYDROData_ShapesGroup) aGroup =
+ Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
+ if ( aGroup.IsNull() )
+ continue;
+
+ HYDROData_ShapesGroup::GroupDefinition aGroupDef;
+
+ aGroupDef.Name = aGroup->GetName().toLatin1().constData();
+ aGroup->GetShapes( aGroupDef.Shapes );
+
+ aSeqOfGroupsDefs.Append( aGroupDef );
+ }
+
// Get faces
- // TODO to be revised
TopTools_ListOfShape aFaces;
HYDROData_SequenceOfObjects aCaseRegions = GetRegions();
HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions );
- for ( ; aRegionIter.More(); aRegionIter.Next() ) {
+ for ( ; aRegionIter.More(); aRegionIter.Next() )
+ {
Handle(HYDROData_Region) aRegion =
Handle(HYDROData_Region)::DownCast( aRegionIter.Value() );
- if( aRegion.IsNull() ) {
+ if( aRegion.IsNull() )
continue;
- }
- TopoDS_Shape aRegionShape = aRegion->GetShape();
+ TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs );
aFaces.Append( aRegionShape );
}
- // Get groups
- // TODO to be revised
- HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups();
-
- return Export( theGeomEngine, theStudy, aFaces, aSplittedGroups );
+ return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs );
}
-bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine,
- SALOMEDS::Study_ptr theStudy,
- const TopTools_ListOfShape& theFaces,
- const HYDROData_SequenceOfObjects& theSplittedGroups )
+bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine,
+ SALOMEDS::Study_ptr theStudy,
+ const TopTools_ListOfShape& theFaces,
+ const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs ) const
{
// Sew faces
- BRepBuilderAPI_Sewing aSewing( Precision::Confusion()*10.0 );
- aSewing.SetNonManifoldMode( Standard_True );
-
+ BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 );
+ aSewing.SetNonManifoldMode( Standard_False );
+#ifdef DEB_CALCULATION
+ TCollection_AsciiString aNam("Sh_");
+ int i=1;
+#endif
TopTools_ListIteratorOfListOfShape aFaceIter( theFaces );
- for ( ; aFaceIter.More(); aFaceIter.Next() ) {
+ for ( ; aFaceIter.More(); aFaceIter.Next() )
+ {
TopoDS_Shape aShape = aFaceIter.Value();
- if ( !aShape.IsNull() && (aShape.ShapeType() == TopAbs_FACE) ) {
- TopoDS_Face aFace = TopoDS::Face( aShape );
- if ( !aFace.IsNull() ) {
- aSewing.Add( aFace );
- }
- } else {
+ if ( aShape.IsNull() )
+ continue;
+
+ if ( aShape.ShapeType() == TopAbs_FACE )
+ {
+ aSewing.Add( aShape );
+#ifdef DEB_CALCULATION
+ TCollection_AsciiString aName = aNam + ++i + ".brep";
+ BRepTools::Write(aShape ,aName.ToCString());
+#endif
+ }
+ else
+ {
+#ifdef DEB_CALCULATION
+ int j = 1;
+#endif
TopExp_Explorer anExp( aShape, TopAbs_FACE );
- for ( ; anExp.More(); anExp.Next() ) {
- TopoDS_Face aFace = TopoDS::Face( anExp.Current() );
- if ( !aFace.IsNull() ) {
- aSewing.Add( aFace );
- }
+ for (; anExp.More(); anExp.Next() ) {
+ aSewing.Add( anExp.Current() );
+#ifdef DEB_CALCULATION
+
+ TCollection_AsciiString aName = aNam + i + "_" + ++j + ".brep";
+ BRepTools::Write(anExp.Current() ,aName.ToCString());
+#endif
}
}
} // faces iterator
TopoDS_Shape aSewedShape = aSewing.SewedShape();
// If the sewed shape is empty - return false
- if ( aSewedShape.IsNull() || !TopoDS_Iterator(aSewedShape).More() ) {
+ if ( aSewedShape.IsNull() || !TopoDS_Iterator( aSewedShape ).More() )
return false;
- }
+#ifdef DEB_CALCULATION
+ BRepTools::Write(aSewedShape ,"Sew.brep");
+#endif
// Publish the sewed shape
QString aName = EXPORT_NAME;
GEOM::GEOM_Object_ptr aMainShape =
publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName );
- if ( aMainShape->_is_nil() ) {
+ if ( aMainShape->_is_nil() )
return false;
- }
+
+ if ( theGroupsDefs.IsEmpty() )
+ return true;
// Create groups
TopTools_IndexedMapOfShape aMapOfSubShapes;
TopExp::MapShapes( aSewedShape, aMapOfSubShapes );
- QHash<QString, QSet<int> > aGroupsData;
+ NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> > aGroupsData;
- HYDROData_SequenceOfObjects::Iterator anIter( theSplittedGroups );
- for ( ; anIter.More(); anIter.Next() ) {
- // Get shapes group
- Handle(HYDROData_ShapesGroup) aGroup =
- Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
- if ( aGroup.IsNull() ) {
- continue;
- }
+ for ( int aGrId = 1, nbGroups = theGroupsDefs.Length(); aGrId <= nbGroups; ++aGrId )
+ {
+ const HYDROData_ShapesGroup::GroupDefinition& aGroupDef = theGroupsDefs.Value( aGrId );
- QSet<int> anIndexes;
-
- // Get shapes of the group
- TopTools_SequenceOfShape aShapes;
- aGroup->GetShapes( aShapes );
- for( int i = 1, aNbShapes = aShapes.Length(); i <= aNbShapes; i++ ) {
- const TopoDS_Shape& aShape = aShapes.Value( i );
- const TopoDS_Shape ModifiedShape = aSewing.Modified( aShape );
- if ( !ModifiedShape.IsNull() ) {
- int anIndex = aMapOfSubShapes.FindIndex( ModifiedShape );
- if ( anIndex > 0 ) {
- anIndexes << anIndex;
+ NCollection_Sequence<int> aGroupIndexes;
+ for( int i = 1, n = aGroupDef.Shapes.Length(); i <= n; i++ )
+ {
+ const TopoDS_Shape& aShape = aGroupDef.Shapes.Value( i );
+#ifdef DEB_CALCULATION
+ cout << "\nOld shape(" << i << ") = " << aShape.TShape() <<endl;
+#endif
+
+ TopoDS_Shape aModifiedShape = aShape;
+ if ( aSewing.IsModified( aShape ) )
+ aModifiedShape = aSewing.Modified( aShape );
+ else if ( aSewing.IsModifiedSubShape( aShape ) )
+ aModifiedShape = aSewing.ModifiedSubShape( aShape );
+
+#ifdef DEB_CALCULATION
+ const TopLoc_Location& aL1 = aShape.Location();
+ const TopLoc_Location& aL2 = aModifiedShape.Location();
+ cout << "\nNew shape(" << i << ") = " << aModifiedShape.TShape() << " Location is Equal = " << aL1.IsEqual(aL2)<<endl;
+#endif
+
+ int anIndex = aMapOfSubShapes.FindIndex(aModifiedShape);
+ if ( anIndex > 0 ) {
+ aGroupIndexes.Append( anIndex );
+ } else {
+#ifdef DEB_CALCULATION
+ TCollection_AsciiString aNam("Lost_");
+ if(!aMapOfSubShapes.Contains(aModifiedShape)) {
+ for ( int anIndex = 1; anIndex <= aMapOfSubShapes.Extent(); anIndex++ )
+ {
+ const TopoDS_Shape& aS = aMapOfSubShapes.FindKey( anIndex );
+ if ( aModifiedShape.IsPartner( aS ) )
+ {
+ cout <<"\nIndex in Map = " << anIndex << "TShape = " << aS.TShape() <<endl;
+ TCollection_AsciiString aName = aNam + i + "_" + anIndex + ".brep";
+ BRepTools::Write(aS ,aName.ToCString());
+ break;
+ }
+ }
}
+#endif
}
}
-
- if ( anIndexes.count() > 0 ) {
- aGroupsData.insert( aGroup->GetName(), anIndexes );
- }
+ if ( !aGroupIndexes.IsEmpty() )
+ aGroupsData.Bind( aGroupDef.Name, aGroupIndexes );
}
-
- GEOM::GEOM_IGroupOperations_var aGroupOp =
- theGeomEngine->GetIGroupOperations( theStudy->StudyId() );
-
- foreach ( const QString& aGroupName, aGroupsData.keys() ) {
- QSet<int> aGroupIndexes = aGroupsData.value( aGroupName );
-
- GEOM::GEOM_Object_var aGroup = aGroupOp->CreateGroup( aMainShape, TopAbs_EDGE );
- if ( !CORBA::is_nil(aGroup) && aGroupOp->IsDone() ) {
- GEOM::ListOfLong_var anIndexes = new GEOM::ListOfLong;
- int aListIndex = 0;
- foreach ( const int anIndex, aGroupIndexes ) {
- anIndexes[aListIndex++] = anIndex;
- }
+
+ if ( !aGroupsData.IsEmpty() )
+ {
+ GEOM::GEOM_IGroupOperations_var aGroupOp =
+ theGeomEngine->GetIGroupOperations( theStudy->StudyId() );
+
+ NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> >::Iterator aMapIt( aGroupsData );
+ for ( ; aMapIt.More(); aMapIt.Next() )
+ {
+ const TCollection_AsciiString& aGroupName = aMapIt.Key();
+ const NCollection_Sequence<int>& aGroupIndexes = aMapIt.Value();
+
+ GEOM::GEOM_Object_var aGeomGroup = aGroupOp->CreateGroup( aMainShape, TopAbs_EDGE );
+ if ( CORBA::is_nil( aGeomGroup ) || !aGroupOp->IsDone() )
+ continue;
+
+ GEOM::ListOfLong_var aGeomIndexes = new GEOM::ListOfLong;
+ aGeomIndexes->length( aGroupIndexes.Length() );
- aGroupOp->UnionIDs( aGroup, anIndexes );
- if ( aGroupOp->IsDone() ) {
+ for( int i = 1, n = aGroupIndexes.Length(); i <= n; i++ )
+ aGeomIndexes[ i - 1 ] = aGroupIndexes.Value( i );
+
+ aGroupOp->UnionIDs( aGeomGroup, aGeomIndexes );
+ if ( aGroupOp->IsDone() )
+ {
SALOMEDS::SObject_var aGroupSO =
- theGeomEngine->AddInStudy( theStudy, aGroup, qPrintable( aName ), aMainShape );
+ theGeomEngine->AddInStudy( theStudy, aGeomGroup, aGroupName.ToCString(), aMainShape );
}
}
}
GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM(
GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy,
- const TopoDS_Shape& theShape, const QString& theName )
+ const TopoDS_Shape& theShape, const QString& theName ) const
{
GEOM::GEOM_Object_var aGeomObj;
SALOMEDS::SObject_var aResultSO =
theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(),
- aGeomObj, qPrintable( theName ) );
+ aGeomObj, qPrintable( aName ) );
if ( aResultSO->_is_nil() ) {
aGeomObj = GEOM::GEOM_Object::_nil();
}
