X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Region.cxx;h=698cfc944925502b5744e9ae3adc281bc39b5523;hb=a95289fabbb6fbf6f32c06207422c65aafd5bd65;hp=7f4fae7a41224cdc8258ca42ce07eb77c5c95faf;hpb=b2793422d30042c499edd45b1a13e1b38f9189dd;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_Region.cxx b/src/HYDROData/HYDROData_Region.cxx index 7f4fae7a..698cfc94 100644 --- a/src/HYDROData/HYDROData_Region.cxx +++ b/src/HYDROData/HYDROData_Region.cxx @@ -1,147 +1,461 @@ +// Copyright (C) 2014-2015 EDF-R&D +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "HYDROData_Region.h" +#include "HYDROData_CalculationCase.h" #include "HYDROData_Document.h" #include "HYDROData_Iterator.h" +#include "HYDROData_Object.h" +#include "HYDROData_ShapesTool.h" #include "HYDROData_Zone.h" +#include "HYDROData_Tool.h" -#include +#include +#include +#include +#include + +#include -#include +#include +#include +#include +#include -#define PYTHON_REGION_ID "KIND_REGION" +#include +#include + +#include + +#include +#include + +//#define DEB_GET_REGION_SHAPE IMPLEMENT_STANDARD_HANDLE(HYDROData_Region, HYDROData_Entity) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Region, HYDROData_Entity) HYDROData_Region::HYDROData_Region() - : HYDROData_Entity() + : HYDROData_Entity( Geom_2d ) { - SetMergeType( Merge_ZMIN ); } HYDROData_Region::~HYDROData_Region() { } -QStringList HYDROData_Region::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +bool HYDROData_Region::CanBeUpdated() const { - QStringList aResList; - - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this ); - if ( aDocument.IsNull() ) - return aResList; - - QString aDocName = aDocument->GetDocPyName(); - QString aRegionName = GetName(); - - aResList << QString( "%1 = %2.CreateObject( %3 );" ) - .arg( aRegionName ).arg( aDocName ).arg( PYTHON_REGION_ID ); - aResList << QString( "%1.SetName( \"%2\" );" ) - .arg( aRegionName ).arg( aRegionName ); - aResList << QString( "" ); - - HYDROData_SequenceOfObjects aZones = GetZones(); - HYDROData_SequenceOfObjects::Iterator anIter( aZones ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Zone) aRefZone = - Handle(HYDROData_Zone)::DownCast( anIter.Value() ); - if ( !aRefZone.IsNull() ) - setPythonReferenceObject( theTreatedObjects, aResList, aRefZone, "AddZone" ); - } - aResList << QString( "" ); - - return aResList; + return false; } -Handle(HYDROData_Zone) HYDROData_Region::AddNewZone() +void HYDROData_Region::Remove() { - TDF_Label aNewLab = myLab.FindChild( ChildTag_Zone ).NewChild(); + Handle(HYDROData_CalculationCase) aFatherCalc = + Handle(HYDROData_CalculationCase)::DownCast( GetFatherObject() ); - return Handle(HYDROData_Zone)::DownCast( - HYDROData_Iterator::CreateObject( aNewLab, KIND_ZONE ) ); + HYDROData_Entity::Remove(); + + if ( !aFatherCalc.IsNull() ) + aFatherCalc->UpdateRegionsOrder(); } -void HYDROData_Region::RemoveChildZones() +bool HYDROData_Region::CanRemove() { - myLab.FindChild( ChildTag_Zone ).ForgetAllAttributes( true ); + return false; } -void HYDROData_Region::SetMergeType( const MergeBathymetriesType& theType ) +HYDROData_SequenceOfObjects HYDROData_Region::GetAllReferenceObjects() const { - Handle(TDataStd_Integer) anInt; - if ( !myLab.FindChild( DataTag_MergeType ).FindAttribute( TDataStd_Integer::GetID(), anInt ) ) - anInt = TDataStd_Integer::Set( myLab, 0 ); - anInt->Set( (int)theType ); + HYDROData_SequenceOfObjects aResSeq = HYDROData_Entity::GetAllReferenceObjects(); + + HYDROData_SequenceOfObjects aSeqOfZones = GetZones(); + aResSeq.Append( aSeqOfZones ); + + return aResSeq; } -HYDROData_Region::MergeBathymetriesType HYDROData_Region::GetMergeType() const +bool HYDROData_Region::AddZone( const Handle(HYDROData_Zone)& theZone ) { - MergeBathymetriesType aMergeType = Merge_ZMIN; + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + + if ( theZone.IsNull() ) + return false; - Handle(TDataStd_Integer) anInt; - if ( myLab.FindChild( DataTag_MergeType ).FindAttribute( TDataStd_Integer::GetID(), anInt ) ) - aMergeType = (MergeBathymetriesType)anInt->Get(); + if ( HasReference( theZone, DataTag_Zone ) ) + return false; // Object is already in reference list - return aMergeType; -} + // Move the zone from other region + Handle(HYDROData_Region) aFatherRegion = + Handle(HYDROData_Region)::DownCast( theZone->GetFatherObject() ); + if ( !aFatherRegion.IsNull() && aFatherRegion->Label() != myLab ) + { + Handle(HYDROData_Zone) aNewZone = addNewZone( aDocument, "", TopoDS_Face(), QStringList() ); + theZone->CopyTo( aNewZone, false ); -int HYDROData_Region::NbZones() const -{ - return NbReferenceObjects( DataTag_Zone ); -} + // To prevent changing of stored shape + aNewZone->SetShape( theZone->GetShape() ); -void HYDROData_Region::AddZone( const Handle(HYDROData_Zone)& theZone ) -{ - AddReferenceObject( theZone, DataTag_Zone ); + aFatherRegion->RemoveZone( theZone ); + + theZone->SetLabel( aNewZone->Label() ); + } + else + { + AddReferenceObject( theZone, DataTag_Zone ); + } + + return true; } -void HYDROData_Region::SetZone( const int theIndex, - const Handle(HYDROData_Zone)& theZone ) +HYDROData_SequenceOfObjects HYDROData_Region::GetZones() const { - SetReferenceObject( theZone, DataTag_Zone, theIndex ); + return GetReferenceObjects( DataTag_Zone ); } -void HYDROData_Region::InsertZone( const int theBeforeIndex, - const Handle(HYDROData_Zone)& theZone ) +void HYDROData_Region::RemoveZone( const Handle(HYDROData_Zone)& theZone ) { - InsertReferenceObject( theZone, DataTag_Zone, theBeforeIndex ); + if ( theZone.IsNull() ) + return; + + RemoveReferenceObject( theZone->Label(), DataTag_Zone ); + + // Remove zone from data model + Handle(HYDROData_Region) aFatherRegion = + Handle(HYDROData_Region)::DownCast( theZone->GetFatherObject() ); + if ( !aFatherRegion.IsNull() && aFatherRegion->Label() == myLab ) + theZone->Remove(); + + // If the last zone has been removed from region we remove this region + HYDROData_SequenceOfObjects aRefZones = GetZones(); + if ( aRefZones.IsEmpty() ) + Remove(); } -void HYDROData_Region::SetZones( const HYDROData_SequenceOfObjects& theZones ) +void HYDROData_Region::RemoveZones() { - SetReferenceObjects( theZones, DataTag_Zone ); + ClearReferenceObjects( DataTag_Zone ); + myLab.FindChild( DataTag_ChildZone ).ForgetAllAttributes( true ); } -Handle(HYDROData_Zone) HYDROData_Region::GetZone( const int theIndex ) const +Handle(HYDROData_Zone) HYDROData_Region::addNewZone( const Handle(HYDROData_Document)& theDoc, + const QString& thePrefix, + const TopoDS_Face& theFace, + const QStringList& theRefObjects ) { - return Handle(HYDROData_Zone)::DownCast( - GetReferenceObject( DataTag_Zone, theIndex ) ); + TDF_Label aNewLab = myLab.FindChild( DataTag_ChildZone ).NewChild(); + + Handle(HYDROData_Zone) aNewZone = + Handle(HYDROData_Zone)::DownCast( HYDROData_Iterator::CreateObject( aNewLab, KIND_ZONE ) ); + AddZone( aNewZone ); + + QString aZoneName = HYDROData_Tool::GenerateObjectName( theDoc, thePrefix ); + aNewZone->SetName( aZoneName ); + + aNewZone->SetShape( theFace ); + + // Add the reference object for zone + for ( int i = 0, n = theRefObjects.length(); i < n; ++i ) + { + const QString& anObjName = theRefObjects.at( i ); + Handle(HYDROData_Entity) aRefObject = theDoc->FindObjectByName( anObjName ); + if ( aRefObject.IsNull() ) + continue; + + aNewZone->AddObject( aRefObject ); + } + + return aNewZone; } -HYDROData_SequenceOfObjects HYDROData_Region::GetZones() const +void getUsedGroups( const TopoDS_Shape& theShape, + HYDROData_ShapesGroup::SeqOfGroupsDefs& theOriGroups, + HYDROData_ShapesGroup::SeqOfGroupsDefs& theUsedGroups ) { - return GetReferenceObjects( DataTag_Zone ); +#ifdef DEB_GET_REGION_SHAPE + HYDROData_ShapesTool::DumpShapeSubShapes( std::cout, "Zone face edges:", theShape, TopAbs_EDGE ); +#endif + + TopTools_IndexedMapOfShape aMapOfSubShapes; + TopExp::MapShapes( theShape, TopAbs_EDGE, aMapOfSubShapes ); + + HYDROData_ShapesGroup::SeqOfGroupsDefs::Iterator anIter( theOriGroups ); + for ( ; anIter.More(); anIter.Next() ) + { + HYDROData_ShapesGroup::GroupDefinition& anOriGroupDef = anIter.ChangeValue(); + if ( anOriGroupDef.Shapes.IsEmpty() ) + continue; + + for ( int i = 1; i <= anOriGroupDef.Shapes.Length(); ++i ) + { + TopoDS_Shape aGroupEdge = anOriGroupDef.Shapes.Value( i ); + + int aShapeIndex = aMapOfSubShapes.FindIndex( aGroupEdge ); + if ( aShapeIndex <= 0 ) + continue; + + anOriGroupDef.Shapes.Remove( i ); + --i; + + bool anIsAdded = false; + + HYDROData_ShapesGroup::SeqOfGroupsDefs::Iterator aUsedIter( theUsedGroups ); + for ( ; aUsedIter.More(); aUsedIter.Next() ) + { + HYDROData_ShapesGroup::GroupDefinition& aUsedGroupDef = aUsedIter.ChangeValue(); + if ( aUsedGroupDef.Name != anOriGroupDef.Name ) + continue; + + aUsedGroupDef.Shapes.Append( aGroupEdge ); + anIsAdded = true; + break; + } + + if ( !anIsAdded ) + { + HYDROData_ShapesGroup::GroupDefinition aUsedGroupDef; + aUsedGroupDef.Name = anOriGroupDef.Name; + aUsedGroupDef.Shapes.Append( aGroupEdge ); + theUsedGroups.Append( aUsedGroupDef ); + } + } + } } -void HYDROData_Region::RemoveZone( const Handle(HYDROData_Zone)& theZone ) +TopoDS_Shape HYDROData_Region::GetShape( HYDROData_ShapesGroup::SeqOfGroupsDefs* theSeqOfGroups ) const { - if ( theZone.IsNull() ) - return; + HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroups; + HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfUsedGroups; + if ( theSeqOfGroups ) + aSeqOfGroups = *theSeqOfGroups; - RemoveReferenceObject( theZone->Label(), DataTag_Zone ); +#ifdef DEB_GET_REGION_SHAPE + HYDROData_ShapesGroup::GroupDefinition::Dump( std::cout, aSeqOfGroups ); +#endif + + TopoDS_Shape aResShape; + + // Unite the region zones (each zone is a face) into one face (united face) + // If the zones can't be united into the single face - unite them into shell + + // Collect the list of region faces + TopTools_ListOfShape aRegionFacesList; + + HYDROData_SequenceOfObjects aZones = GetZones(); + HYDROData_SequenceOfObjects::Iterator aZoneIter( aZones ); + for ( ; aZoneIter.More(); aZoneIter.Next() ) + { + Handle(HYDROData_Zone) aZone = + Handle(HYDROData_Zone)::DownCast( aZoneIter.Value() ); + if ( aZone.IsNull() ) + continue; + + TopoDS_Shape aZoneShape = aZone->GetShape(); + if ( aZoneShape.IsNull() || aZoneShape.ShapeType() != TopAbs_FACE ) + continue; + + TopoDS_Face aZoneFace = TopoDS::Face( aZoneShape ); + aRegionFacesList.Append( aZoneFace ); + + getUsedGroups( aZoneFace, aSeqOfGroups, aSeqOfUsedGroups ); + } // zones iterator + + if ( aRegionFacesList.IsEmpty() ) + return aResShape; + + // The unite region face + TopoDS_Face aRegionFace; + + if ( aRegionFacesList.Extent() == 1 ) + { + aRegionFace = TopoDS::Face( aRegionFacesList.First() ); + } + else + { +#ifdef DEB_GET_REGION_SHAPE + HYDROData_ShapesGroup::GroupDefinition::Dump( std::cout, aSeqOfUsedGroups ); +#endif + + // Try to fuse all region faces into one common face + TopoDS_Shape aFuseShape; + TopTools_ListIteratorOfListOfShape aFaceIter( aRegionFacesList ); + for ( ; aFaceIter.More(); aFaceIter.Next() ) + { + if ( aFuseShape.IsNull() ) + { + aFuseShape = aFaceIter.Value(); + continue; + } + + BRepAlgoAPI_Fuse aFuse( aFuseShape, aFaceIter.Value() ); + if ( !aFuse.IsDone() ) + { + aFuseShape.Nullify(); + break; + } + + aFuseShape = aFuse.Shape(); + HYDROData_ShapesGroup::GroupDefinition::Update( &aSeqOfUsedGroups, &aFuse ); + } // faces iterator + +#ifdef DEB_GET_REGION_SHAPE + HYDROData_ShapesTool::DumpShapeSubShapes( std::cout, "Fused face edges:", aFuseShape, TopAbs_EDGE ); +#endif + + // Check the result of fuse operation + if ( !aFuseShape.IsNull() ) + { + ShapeUpgrade_UnifySameDomain anUnifier( aFuseShape ); + anUnifier.Build(); + + const TopoDS_Shape& anUnitedShape = anUnifier.Shape(); + + TopTools_SequenceOfShape aShapeFaces; + HYDROData_ShapesTool::ExploreShapeToShapes( anUnitedShape, TopAbs_FACE, aShapeFaces ); + if ( aShapeFaces.Length() == 1 ) + { + aRegionFace = TopoDS::Face( aShapeFaces.Value( 1 ) ); + +#ifdef DEB_GET_REGION_SHAPE + HYDROData_ShapesTool::DumpShapeSubShapes( std::cout, "Result face edges:", aRegionFace, TopAbs_EDGE ); +#endif + + HYDROData_ShapesGroup::GroupDefinition::Update( &aSeqOfUsedGroups, &anUnifier ); + + // Update the sequence of groups + if ( theSeqOfGroups ) + { + HYDROData_ShapesGroup::SeqOfGroupsDefs::Iterator aUsedIter( aSeqOfUsedGroups ); + for ( ; aUsedIter.More(); aUsedIter.Next() ) + { + const HYDROData_ShapesGroup::GroupDefinition& aUsedGroupDef = aUsedIter.Value(); + if ( aUsedGroupDef.Shapes.IsEmpty() ) + continue; + + HYDROData_ShapesGroup::SeqOfGroupsDefs::Iterator anOriIter( aSeqOfGroups ); + for ( ; anOriIter.More(); anOriIter.Next() ) + { + HYDROData_ShapesGroup::GroupDefinition& anOriGroupDef = anOriIter.ChangeValue(); + if ( anOriGroupDef.Name != aUsedGroupDef.Name ) + continue; + + HYDROData_ShapesTool::AddShapes( anOriGroupDef.Shapes, aUsedGroupDef.Shapes ); + break; + } + } + + *theSeqOfGroups = aSeqOfGroups; + } + } + } + } + + if ( !aRegionFace.IsNull() ) + { + // result shape is a face + aResShape = aRegionFace; + } + else + { + // result shape is a shell + TopoDS_Shell aShell; + BRep_Builder aBuilder; + aBuilder.MakeShell( aShell ); + + TopTools_ListIteratorOfListOfShape aFaceIter( aRegionFacesList ); + for ( ; aFaceIter.More(); aFaceIter.Next() ) + aBuilder.Add( aShell, aFaceIter.Value() ); + + aResShape = aShell; + } + + return aResShape; } -void HYDROData_Region::RemoveZone( const int theIndex ) +QStringList HYDROData_Region::DumpToPython( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects, + QString defRegName ) const { - RemoveReferenceObject( DataTag_Zone, theIndex ); + QStringList aResList; + + // Find region + findPythonReferenceObject( aResList, defRegName ); + + // Add zones + HYDROData_SequenceOfObjects aZones = GetZones(); + HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); + for ( ; aZonesIter.More(); aZonesIter.Next() ) { + Handle(HYDROData_Zone) aZone = + Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); + if ( aZone.IsNull() ) { + continue; + } + + // find zone + aZone->findPythonReferenceObject( aResList ); + theTreatedObjects.insert( aZone->GetName(), aZone ); + + // set zone merge type + QString aMergeTypeStr; + HYDROData_Zone::MergeType aMergeType = aZone->GetMergeType(); + if ( aMergeType == HYDROData_Zone::Merge_ZMIN ) { + aMergeTypeStr = "HYDROData_Zone.Merge_ZMIN"; + } else if ( aMergeType == HYDROData_Zone::Merge_ZMAX ) { + aMergeTypeStr = "HYDROData_Zone.Merge_ZMAX"; + } else if ( aMergeType == HYDROData_Zone::Merge_Object ) { + aMergeTypeStr = "HYDROData_Zone.Merge_Object"; + } + + if ( !aMergeTypeStr.isEmpty() ) { + aResList << QString( "%1.SetMergeType( %2 )" ).arg( aZone->GetObjPyName() ).arg( aMergeTypeStr ); + } + if ( aMergeType == HYDROData_Zone::Merge_Object ) { + Handle(HYDROData_Entity) aMergeObject = aZone->GetMergeObject(); + if ( !aMergeObject.IsNull() ) { + aMergeObject->findPythonReferenceObject( aResList ); + aResList << QString( "%1.SetMergeObject( %2 )" ).arg( aZone->GetObjPyName() ) + .arg( aMergeObject->GetObjPyName() ); + } + } + // set color + QColor zoneColor = aZone->GetColor(Qt::darkBlue); + aResList << QString( "%1.SetColor( QColor( %2, %3, %4 ))" ) + .arg( aZone->GetObjPyName() ).arg( zoneColor.red() ).arg( zoneColor.green() ).arg( zoneColor.blue() ); + // add zone + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aZone, "AddZone" ); + + } + + return aResList; } -void HYDROData_Region::RemoveZones() +bool HYDROData_Region::IsSubmersible() const { - ClearReferenceObjects( DataTag_Zone ); + HYDROData_SequenceOfObjects aZones = GetZones(); + HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); + for ( ; aZonesIter.More(); aZonesIter.Next() ) + { + Handle(HYDROData_Zone) aZone = + Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); + if ( !aZone->IsSubmersible() ) + return false; //if one of zones is not submersible the region is considered as not submersible + } + return true; } - -