X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=198222ab62a76428d734c9c6163ba39374c9eb0f;hb=b45bf3e182741f13e3bb9f66f114a840be017dea;hp=5259902971421651ee788c1b7b4e239a06091a21;hpb=ad8562bab9992101430a6327aa7ca06c71f6d084;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index 52599029..198222ab 100644 --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -2,26 +2,47 @@ #include "HYDROData_CalculationCase.h" #include "HYDROData_ArtificialObject.h" +#include "HYDROData_IAltitudeObject.h" #include "HYDROData_Document.h" +#include "HYDROData_ShapesGroup.h" #include "HYDROData_Iterator.h" #include "HYDROData_NaturalObject.h" -#include "HYDROData_Polyline.h" +#include "HYDROData_PolylineXY.h" #include "HYDROData_SplitToZonesTool.h" +#include "HYDROData_SplittedShapesGroup.h" #include "HYDROData_Region.h" #include "HYDROData_Tool.h" #include "HYDROData_Zone.h" +#include + +#include + #include #include +#include + #include #include +#include + +#include + +#include #include +#include +#include +#include + #define CALCULATION_REGIONS_PREF GetName() + "_Reg" #define CALCULATION_ZONES_PREF GetName() + "_Zone" +#define CALCULATION_GROUPS_PREF GetName() + "_" #define PYTHON_CALCULATION_ID "KIND_CALCULATION" +#define EXPORT_NAME "HYDRO_" + GetName() + IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity) @@ -49,12 +70,7 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) 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 ); @@ -65,14 +81,22 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) 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(); + + anIter.Init( aGroups ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_SplittedShapesGroup) aGroup = + Handle(HYDROData_SplittedShapesGroup)::DownCast( anIter.Value() ); + if ( aGroup.IsNull() ) + continue; + + HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aGroup ); + } } HYDROData_Entity::SetName( theName ); @@ -126,64 +150,115 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre return aResList; } -void HYDROData_CalculationCase::SplitGeometryObjects() +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() const +{ + HYDROData_SequenceOfObjects aResSeq = HYDROData_Entity::GetAllReferenceObjects(); + + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); + if ( !aBoundaryPolyline.IsNull() ) + aResSeq.Append( aBoundaryPolyline ); + + HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions(); + aResSeq.Append( aSeqOfRegions ); + + return aResSeq; +} + +void HYDROData_CalculationCase::Update() { - // At first we remove previously created regions + HYDROData_Entity::Update(); + + // At first we remove previously created objects RemoveRegions(); + RemoveSplittedGroups(); Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( aDocument.IsNull() ) return; - Handle(HYDROData_Polyline) aBoundaryPolyline = GetBoundaryPolyline(); + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); if ( aGeomObjects.IsEmpty() ) return; - HYDROData_SplitToZonesTool::SplitDataList aSplitedZones = - HYDROData_SplitToZonesTool::SplitToZones( aGeomObjects, aBoundaryPolyline ); - if ( aSplitedZones.isEmpty() ) + HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + + HYDROData_SplitToZonesTool::SplitDataList aSplitedObjects = + HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline ); + if ( aSplitedObjects.isEmpty() ) return; QString aRegsPref = CALCULATION_REGIONS_PREF; QString aZonesPref = CALCULATION_ZONES_PREF; + QMap aSplittedEdgesGroupsMap; + // Create result regions for case, by default one zone for one region - HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitedZones ); + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitedObjects ); while( anIter.hasNext() ) { const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); - // Create new region - Handle(HYDROData_Region) aRegion = addNewRegion(); + if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) + { + // Create new region + Handle(HYDROData_Region) aRegion = addNewRegion(); - QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref ); - aRegion->SetName( aRegionName ); + QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref ); + aRegion->SetName( aRegionName ); - // Add the zone for region - Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone(); + // Add the zone for region + Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone(); - QString aZoneName = HYDROData_Tool::GenerateObjectName( aDocument, aZonesPref ); - aRegionZone->SetName( aZoneName ); + QString aZoneName = HYDROData_Tool::GenerateObjectName( aDocument, aZonesPref ); + aRegionZone->SetName( aZoneName ); - aRegionZone->SetShape( aSplitData.Face() ); + aRegionZone->SetShape( aSplitData.Face() ); - // Add the reference object for zone - for ( int i = 0, n = aSplitData.ObjectNames.length(); i < n; ++i ) + // Add the reference object for zone + for ( int i = 0, n = aSplitData.ObjectNames.length(); i < n; ++i ) + { + const QString& anObjName = aSplitData.ObjectNames.at( i ); + + Handle(HYDROData_Object) aRefObject = Handle(HYDROData_Object)::DownCast( + HYDROData_Tool::FindObjectByName( aDocument, anObjName ) ); + if ( aRefObject.IsNull() ) + continue; + + aRegionZone->AddGeometryObject( aRefObject ); + } + } + else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge ) { - const QString& anObjName = aSplitData.ObjectNames.at( i ); - - Handle(HYDROData_Object) aRefObject = Handle(HYDROData_Object)::DownCast( - HYDROData_Tool::FindObjectByName( aDocument, anObjName ) ); - if ( aRefObject.IsNull() ) + // Create new edges group + if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) continue; - aRegionZone->AddGeometryObject( aRefObject ); + QString anObjName = aSplitData.ObjectNames.first(); + if ( anObjName.isEmpty() ) + continue; + + Handle(HYDROData_SplittedShapesGroup) aSplittedGroup; + if ( !aSplittedEdgesGroupsMap.contains( anObjName ) ) + { + aSplittedGroup = addNewSplittedGroup(); + + QString aCalcGroupName = CALCULATION_GROUPS_PREF + anObjName; + aSplittedGroup->SetName( aCalcGroupName ); + + aSplittedEdgesGroupsMap.insert( anObjName, aSplittedGroup ); + } + else + { + aSplittedGroup = aSplittedEdgesGroupsMap[ anObjName ]; + } + + if ( aSplittedGroup.IsNull() ) + continue; + + aSplittedGroup->AddShape( aSplitData.Shape ); } } - - // The splitted data is up to date - SetToUpdate( false ); } bool HYDROData_CalculationCase::AddGeometryObject( const Handle(HYDROData_Object)& theObject ) @@ -196,7 +271,7 @@ bool HYDROData_CalculationCase::AddGeometryObject( const Handle(HYDROData_Object AddReferenceObject( theObject, DataTag_GeometryObject ); - // Indicate model of the need to update zones splitting + // Indicate model of the need to update splitting SetToUpdate( true ); return true; @@ -214,7 +289,7 @@ void HYDROData_CalculationCase::RemoveGeometryObject( const Handle(HYDROData_Obj RemoveReferenceObject( theObject->Label(), DataTag_GeometryObject ); - // Indicate model of the need to update zones splitting + // Indicate model of the need to update splitting SetToUpdate( true ); } @@ -222,13 +297,53 @@ void HYDROData_CalculationCase::RemoveGeometryObjects() { ClearReferenceObjects( DataTag_GeometryObject ); - // Indicate model of the need to update zones splitting + // Indicate model of the need to update splitting + SetToUpdate( true ); +} + +bool HYDROData_CalculationCase::AddGeometryGroup( const Handle(HYDROData_ShapesGroup)& theGroup ) +{ + if ( theGroup.IsNull() ) + return false; + + if ( HasReference( theGroup, DataTag_GeometryGroup ) ) + return false; // Object is already in reference list + + AddReferenceObject( theGroup, DataTag_GeometryGroup ); + + // Indicate model of the need to update splitting + SetToUpdate( true ); + + return true; +} + +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetGeometryGroups() const +{ + return GetReferenceObjects( DataTag_GeometryGroup ); +} + +void HYDROData_CalculationCase::RemoveGeometryGroup( const Handle(HYDROData_ShapesGroup)& theGroup ) +{ + if ( theGroup.IsNull() ) + return; + + RemoveReferenceObject( theGroup->Label(), DataTag_GeometryGroup ); + + // Indicate model of the need to update splitting + SetToUpdate( true ); +} + +void HYDROData_CalculationCase::RemoveGeometryGroups() +{ + ClearReferenceObjects( DataTag_GeometryGroup ); + + // Indicate model of the need to update splitting SetToUpdate( true ); } -void HYDROData_CalculationCase::SetBoundaryPolyline( const Handle(HYDROData_Polyline)& thePolyline ) +void HYDROData_CalculationCase::SetBoundaryPolyline( const Handle(HYDROData_PolylineXY)& thePolyline ) { - Handle(HYDROData_Polyline) aPrevPolyline = GetBoundaryPolyline(); + Handle(HYDROData_PolylineXY) aPrevPolyline = GetBoundaryPolyline(); SetReferenceObject( thePolyline, DataTag_Polyline ); @@ -236,15 +351,15 @@ void HYDROData_CalculationCase::SetBoundaryPolyline( const Handle(HYDROData_Poly SetToUpdate( !IsEqual( aPrevPolyline, thePolyline ) || IsMustBeUpdated() ); } -Handle(HYDROData_Polyline) HYDROData_CalculationCase::GetBoundaryPolyline() const +Handle(HYDROData_PolylineXY) HYDROData_CalculationCase::GetBoundaryPolyline() const { - return Handle(HYDROData_Polyline)::DownCast( + return Handle(HYDROData_PolylineXY)::DownCast( GetReferenceObject( DataTag_Polyline ) ); } void HYDROData_CalculationCase::RemoveBoundaryPolyline() { - Handle(HYDROData_Polyline) aPrevPolyline = GetBoundaryPolyline(); + Handle(HYDROData_PolylineXY) aPrevPolyline = GetBoundaryPolyline(); ClearReferenceObjects( DataTag_Polyline ); @@ -356,8 +471,142 @@ void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& th void HYDROData_CalculationCase::RemoveRegions() { - ClearReferenceObjects( DataTag_Region ); - myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes( true ); + myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes(); +} + +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplittedGroups() const +{ + return GetReferenceObjects( DataTag_SplittedGroups ); +} + +void HYDROData_CalculationCase::RemoveSplittedGroups() +{ + myLab.FindChild( DataTag_SplittedGroups ).ForgetAllAttributes(); +} + +double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const +{ + double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); + + Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); + if ( aZone.IsNull() ) + return aResAltitude; + + HYDROData_Zone::MergeAltitudesType aZoneMergeType = aZone->GetMergeType(); + if ( !aZone->IsMergingNeed() ) + { + aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN; + } + else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) + { + return aResAltitude; + } + + if ( aZoneMergeType == HYDROData_Zone::Merge_Object ) + { + Handle(HYDROData_IAltitudeObject) aMergeAltitude = aZone->GetMergeAltitude(); + if ( !aMergeAltitude.IsNull() ) + aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint ); + } + else + { + HYDROData_SequenceOfObjects aZoneObjects = aZone->GetGeometryObjects(); + HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Object) aZoneObj = + Handle(HYDROData_Object)::DownCast( anIter.Value() ); + if ( aZoneObj.IsNull() ) + continue; + + Handle(HYDROData_IAltitudeObject) anObjAltitude = aZoneObj->GetAltitudeObject(); + if ( anObjAltitude.IsNull() ) + continue; + + double aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint ); + if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ) + continue; + + if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) + { + aResAltitude = aPointAltitude; + break; + } + else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMIN ) + { + if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) || + aResAltitude > aPointAltitude ) + { + aResAltitude = aPointAltitude; + } + } + else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMAX ) + { + if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) || + aResAltitude < aPointAltitude ) + { + aResAltitude = aPointAltitude; + } + } + } + } + + return aResAltitude; +} + +Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint ) const +{ + Handle(HYDROData_Zone) aResZone; + + HYDROData_SequenceOfObjects aRegions = GetRegions(); + + HYDROData_SequenceOfObjects::Iterator anIter( aRegions ); + for ( ; anIter.More() && aResZone.IsNull(); anIter.Next() ) + { + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( anIter.Value() ); + if ( aRegion.IsNull() ) + continue; + + HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); + HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); + for ( ; aZonesIter.More() && aResZone.IsNull(); aZonesIter.Next() ) + { + Handle(HYDROData_Zone) aRegZone = + Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); + if ( aRegZone.IsNull() ) + continue; + + PointClassification aPointRelation = GetPointClassification( thePoint, aRegZone ); + if ( aPointRelation != POINT_OUT ) + aResZone = aRegZone; // We found the desired zone + } + } + + return aResZone; +} + +HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPointClassification( + const gp_XY& thePoint, + const Handle(HYDROData_Zone)& theZone ) const +{ + PointClassification aRes = POINT_OUT; + if ( theZone.IsNull() ) + return aRes; + + 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 ); + if (State == TopAbs_OUT) + aRes = POINT_OUT; + else if(State == TopAbs_IN) + aRes = POINT_IN; + else if(State == TopAbs_ON) + aRes = POINT_ON; + return aRes; } Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion() @@ -371,13 +620,23 @@ Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion() return aNewRegion; } -TopoDS_Shell HYDROData_CalculationCase::GetShell() +Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup() { - TopoDS_Shell aShell; + TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild(); - // Make shell containing all region shapes - BRepBuilderAPI_Sewing aSewing( Precision::Confusion()*10.0 ); + Handle(HYDROData_SplittedShapesGroup) aNewGroup = + Handle(HYDROData_SplittedShapesGroup)::DownCast( + HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) ); + AddReferenceObject( aNewGroup, DataTag_SplittedGroups ); + return aNewGroup; +} + +bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, + SALOMEDS::Study_ptr theStudy ) +{ + // Get faces + TopTools_ListOfShape aFaces; HYDROData_SequenceOfObjects aCaseRegions = GetRegions(); HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); for ( ; aRegionIter.More(); aRegionIter.Next() ) { @@ -388,82 +647,162 @@ TopoDS_Shell HYDROData_CalculationCase::GetShell() } TopoDS_Shape aRegionShape = aRegion->GetShape(); - if( !aRegionShape.IsNull() ) { - aSewing.Add( aRegionShape ); - } - } // regions iterator - - aSewing.Perform(); - TopoDS_Shape aSewedShape = aSewing.SewedShape(); + aFaces.Append( aRegionShape ); + } - if ( aSewedShape.ShapeType() == TopAbs_FACE && aCaseRegions.Length() ==1 ) { - // create shell from one face - BRep_Builder aBuilder; - aBuilder.MakeShell( aShell ); - aBuilder.Add( aShell, aSewedShape); - } else { - TopExp_Explorer anExpShells( aSewedShape, TopAbs_SHELL ); - Standard_Integer aNbOfShells = 0; - for ( ; anExpShells.More(); anExpShells.Next() ) { - aShell = TopoDS::Shell( anExpShells.Current() ); - aNbOfShells++; - } + // Get groups + HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups(); - if ( aNbOfShells != 1 ) { - aShell.Nullify(); - BRep_Builder aBuilder; - aBuilder.MakeShell( aShell ); + return Export( theGeomEngine, theStudy, aFaces, aSplittedGroups ); +} - TopExp_Explorer anExpFaces( aSewedShape, TopAbs_FACE ); - for ( ; anExpFaces.More(); anExpFaces.Next() ) { - TopoDS_Face aFace = TopoDS::Face( anExpFaces.Current() ); +bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, + SALOMEDS::Study_ptr theStudy, + const TopTools_ListOfShape& theFaces, + const HYDROData_SequenceOfObjects& theSplittedGroups ) +{ + // Sew faces + BRepBuilderAPI_Sewing aSewing( Precision::Confusion()*10.0 ); + aSewing.SetNonManifoldMode( Standard_True ); + + TopTools_ListIteratorOfListOfShape aFaceIter( theFaces ); + 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 { + TopExp_Explorer anExp( aShape, TopAbs_FACE ); + for ( ; anExp.More(); anExp.Next() ) { + TopoDS_Face aFace = TopoDS::Face( anExp.Current() ); if ( !aFace.IsNull() ) { - aBuilder.Add( aShell, aFace ); + aSewing.Add( aFace ); } } } + } // faces iterator + + aSewing.Perform(); + TopoDS_Shape aSewedShape = aSewing.SewedShape(); + + // If the sewed shape is empty - return false + if ( aSewedShape.IsNull() || !TopoDS_Iterator(aSewedShape).More() ) { + return false; } -/* TODO: old version - // Make shell - BRep_Builder aBuilder; - aBuilder.MakeShell( aShell ); + // Publish the sewed shape + QString aName = EXPORT_NAME; + GEOM::GEOM_Object_ptr aMainShape = + publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName ); - // Make shell containing all region shapes - HYDROData_SequenceOfObjects aCaseRegions = GetRegions(); - HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); - for ( ; aRegionIter.More(); aRegionIter.Next() ) { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( aRegionIter.Value() ); - if( aRegion.IsNull() ) { + if ( aMainShape->_is_nil() ) { + return false; + } + + // Create groups + TopTools_IndexedMapOfShape aMapOfSubShapes; + TopExp::MapShapes( aSewedShape, aMapOfSubShapes ); + + QHash > 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; } - TopoDS_Shape aRegionShape = aRegion->GetShape(); - - // Add shape (face or shell) corresponding to the region into the shell - if( !aRegionShape.IsNull() ) { - if ( aRegionShape.ShapeType() == TopAbs_FACE ) { - aBuilder.Add( aShell, aRegionShape ); - } else { - TopExp_Explorer anExp( aRegionShape, TopAbs_FACE ); - for( ; anExp.More(); anExp.Next() ) { - TopoDS_Face aFace = TopoDS::Face( anExp.Current() ); - if( !aFace.IsNull() ) { - aBuilder.Add( aShell, aFace ); - } + QSet 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; } } } - } // regions iterator -*/ + + if ( anIndexes.count() > 0 ) { + aGroupsData.insert( aGroup->GetName(), anIndexes ); + } + } + + if ( !aGroupsData.isEmpty() ) { + GEOM::GEOM_IGroupOperations_var aGroupOp = + theGeomEngine->GetIGroupOperations( theStudy->StudyId() ); + + foreach ( const QString& aGroupName, aGroupsData.keys() ) { + QSet 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; + anIndexes->length( aGroupIndexes.count() ); + int aListIndex = 0; + foreach ( const int anIndex, aGroupIndexes ) { + anIndexes[aListIndex++] = anIndex; + } - // Nullify shell if it is empty - if ( !aShell.IsNull() && !TopoDS_Iterator(aShell).More() ) { - aShell.Nullify(); + aGroupOp->UnionIDs( aGroup, anIndexes ); + if ( aGroupOp->IsDone() ) { + SALOMEDS::SObject_var aGroupSO = + theGeomEngine->AddInStudy( theStudy, aGroup, qPrintable( aGroupName ), aMainShape ); + } + } + } } - return aShell; + return true; } +GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM( + GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, + const TopoDS_Shape& theShape, const QString& theName ) +{ + GEOM::GEOM_Object_var aGeomObj; + + if ( theGeomEngine->_is_nil() || theStudy->_is_nil() || + theShape.IsNull() ) { + return aGeomObj._retn(); + } + + std::ostringstream aStreamShape; + // Write TopoDS_Shape in ASCII format to the stream + BRepTools::Write( theShape, aStreamShape ); + // Returns the number of bytes that have been stored in the stream's buffer. + int aSize = aStreamShape.str().size(); + // Allocate octect buffer of required size + CORBA::Octet* anOctetBuf = SALOMEDS::TMPFile::allocbuf( aSize ); + // Copy ostrstream content to the octect buffer + memcpy( anOctetBuf, aStreamShape.str().c_str(), aSize ); + // Create TMPFile + SALOMEDS::TMPFile_var aSeqFile = new SALOMEDS::TMPFile( aSize, aSize, anOctetBuf, 1 ); + + // Restore shape from the stream and get the GEOM object + GEOM::GEOM_IInsertOperations_var anInsOp = theGeomEngine->GetIInsertOperations( theStudy->StudyId() ); + aGeomObj = anInsOp->RestoreShape( aSeqFile ); + + // Puplish the GEOM object + if ( !aGeomObj->_is_nil() ) { + QString aName = GEOMBase::GetDefaultName( theName ); + + SALOMEDS::SObject_var aResultSO = + theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(), + aGeomObj, qPrintable( aName ) ); + if ( aResultSO->_is_nil() ) { + aGeomObj = GEOM::GEOM_Object::_nil(); + } + } + return aGeomObj._retn(); + }