X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_LandCoverMap.cxx;h=a429e381ae43931784e002cf925fac6169926e8a;hb=545854182f0363f61284d5abe34c3627d4f3b088;hp=02c73ba80cb2fd315c7340c545074bf153ecf11a;hpb=eac15201a2a8fcce36c87e965f9c2953239f409f;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_LandCoverMap.cxx b/src/HYDROData/HYDROData_LandCoverMap.cxx index 02c73ba8..a429e381 100644 --- a/src/HYDROData/HYDROData_LandCoverMap.cxx +++ b/src/HYDROData/HYDROData_LandCoverMap.cxx @@ -20,24 +20,38 @@ #include #include #include +#include +#include #include #include #include #include +#include #include #include +#include #include -#include -#include #include #include +#include #include #include #include +#include #include +#include +#include +#include +#include +#include #include +#include + +const char TELEMAC_FORMAT = 'f'; +const int TELEMAC_PRECISION = 3; + IMPLEMENT_STANDARD_HANDLE(HYDROData_LandCoverMap, HYDROData_Entity) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_LandCoverMap, HYDROData_Entity) @@ -77,8 +91,12 @@ void HYDROData_LandCoverMap::Iterator::Init( const HYDROData_LandCoverMap& theMa myIterator = 0; else myIterator = new TopoDS_Iterator( aShape ); - myIndex = 0; + theMap.myLab.FindChild( DataTag_Types ).FindAttribute( TDataStd_ExtStringArray::GetID(), myArray ); + if( myArray.IsNull() ) + myIndex = -1; + else + myIndex = myArray->Lower(); } /** @@ -89,6 +107,18 @@ HYDROData_LandCoverMap::Iterator::~Iterator() delete myIterator; } +/** + Return the current 0-based index of the iterator + @return the current index +*/ +int HYDROData_LandCoverMap::Iterator::Index() const +{ + if( myArray.IsNull() ) + return -1; + else + return myIndex - myArray->Lower(); +} + /** Return if the iterator has more elements @return if the iterator has more elements @@ -134,10 +164,23 @@ QString HYDROData_LandCoverMap::Iterator::StricklerType() const return HYDROData_Tool::toQString( myArray->Value( myIndex ) ); } +/** + Set the Strickler type for the current land cover + @param theType the Strickler type +*/ +void HYDROData_LandCoverMap::Iterator::SetStricklerType( const QString& theType ) +{ + if( myArray.IsNull() || myIndex < myArray->Lower() || myIndex > myArray->Upper() ) + return; + else + myArray->SetValue( myIndex, HYDROData_Tool::toExtString( theType ) ); +} + /** Constructor */ HYDROData_LandCoverMap::HYDROData_LandCoverMap() + : HYDROData_Entity( Geom_No ) { } @@ -158,25 +201,116 @@ const ObjectKind HYDROData_LandCoverMap::GetKind() const } /** - Import the land cover map from QGIS - @param theFileName the name of file - @return if the import is successful + Load attributes from DBF File +/// */ -bool HYDROData_LandCoverMap::ImportQGIS( const QString& theFileName ) +HYDROData_LandCoverMap::DBFStatus HYDROData_LandCoverMap::ImportDBF( const QString& theDBFFileName, + const QString& theFieldName, + const QStringList& theDBFValues, + const QStringList& theStricklerTypes, + const QList& theIndices ) { - //TODO - return false; + if (theDBFValues.size() != theStricklerTypes.size()) + return DBFStatus_DIFF_SIZE_ERROR; + HYDROData_ShapeFile aDBFImporter; + if (!aDBFImporter.DBF_OpenDBF(theDBFFileName)) + return DBFStatus_OPEN_FILE_ERROR; //cant open file + + QStringList FieldList = aDBFImporter.DBF_GetFieldList(); + int FieldNameIndex = FieldList.indexOf(theFieldName); + if (FieldNameIndex == -1) + return DBFStatus_NO_SUCH_FIELD_ERROR; //no such field + + std::vector theAttrV; + aDBFImporter.DBF_GetAttributeList(FieldNameIndex, theAttrV ); + + bool allOK = true; + Iterator anIt( *this ); + for( ; anIt.More(); anIt.Next() ) + { + int CurIndex = anIt.Index(); + HYDROData_ShapeFile::DBF_AttrValue AValue = theAttrV[theIndices[CurIndex]]; + int StricklerTypesInd = theDBFValues.indexOf(QString(AValue.myStrVal)); + if ( StricklerTypesInd != -1) + anIt.SetStricklerType(theStricklerTypes[StricklerTypesInd]); + else + allOK = false; + } + if (allOK) + return DBFStatus_OK; + else + return DBFStatus_NO_DBFVALUES_CORRESPONDENCE_WARNING; } /** - Export the land cover map to QGIS - @param theFileName the name of file - @return if the export is successful + Export attributes to DBF File +/// */ -bool HYDROData_LandCoverMap::ExportQGIS( const QString& theFileName ) const +void HYDROData_LandCoverMap::ExportDBF( const QString& theDBFFileName, + const QString& theFieldName, + const QStringList& theDBFValues, + const QStringList& theStricklerTypes) const { - //TODO - return false; + HYDROData_ShapeFile anExporter; + std::vector theAttrV; + Iterator anIt( *this ); + for( ; anIt.More(); anIt.Next() ) + { + QString CurST = anIt.StricklerType(); + HYDROData_ShapeFile::DBF_AttrValue aCurAttrV; + aCurAttrV.myIsNull = false; + int StricklerTypesInd = theStricklerTypes.indexOf(CurST); + if (StricklerTypesInd != -1) + { + aCurAttrV.myStrVal = theDBFValues[StricklerTypesInd]; + aCurAttrV.myFieldType = HYDROData_ShapeFile::DBF_FieldType_String; + theAttrV.push_back(aCurAttrV); + } + else + aCurAttrV.myIsNull = true; + } + + anExporter.DBF_WriteFieldAndValues(theDBFFileName, theFieldName, HYDROData_ShapeFile::DBF_FieldType_String, theAttrV, true); + +} + +int HashCode( const gp_Pnt& thePoint, const Standard_Integer theUpper ) +{ + int aHashX = HashCode( thePoint.X(), theUpper ); + int aHashY = HashCode( thePoint.Y(), theUpper ); + return (aHashX^aHashY)%theUpper; +} + +bool operator == ( const gp_Pnt& thePoint1, const gp_Pnt& thePoint2 ) +{ + return thePoint1.IsEqual( thePoint2, Precision::Confusion() ); +} + +bool EdgeDiscretization( const TopoDS_Edge& theEdge, + Standard_Real theDeflection, + NCollection_IndexedMap& theVerticesMap, + QList& theVerticesIds ) +{ + BRepAdaptor_Curve aCurve( theEdge ); + GCPnts_QuasiUniformDeflection aDiscrete( aCurve, theDeflection ); + if( !aDiscrete.IsDone() ) + return false; + + int n = aDiscrete.NbPoints(); + for( int i=1; i<=n; i++ ) + { + gp_Pnt aPnt = aDiscrete.Value( i ); + int anId; + if( theVerticesMap.Contains( aPnt ) ) + anId = theVerticesMap.FindIndex( aPnt ); + else + { + anId = theVerticesMap.Size(); + theVerticesMap.Add( aPnt ); + } + theVerticesIds.append( anId ); + } + return true; } /** @@ -184,10 +318,89 @@ bool HYDROData_LandCoverMap::ExportQGIS( const QString& theFileName ) const @param theFileName the name of file @return if the export is successful */ -bool HYDROData_LandCoverMap::ExportTelemac( const QString& theFileName ) const +bool HYDROData_LandCoverMap::ExportTelemac( const QString& theFileName, Standard_Real theDeflection ) const { - //TODO - return false; + TopoDS_Shape aLandCoverMapShape = GetShape(); + TopTools_ListOfShape aListOfFaces; + TopExp_Explorer anExp( aLandCoverMapShape, TopAbs_FACE ); + for( ; anExp.More(); anExp.Next() ) + aListOfFaces.Append( anExp.Current() ); + + TopoDS_Shape aShape = MergeFaces( aListOfFaces, false ); + + NCollection_IndexedMap aVerticesMap; + NCollection_IndexedDataMap< TopoDS_Edge, QList > anEdgesMap; + NCollection_IndexedDataMap< TopoDS_Face, QList > aFacesMap; + + // add into the map all edges existing in the shell + TopExp_Explorer anExp1( aShape, TopAbs_EDGE ); + for( ; anExp1.More(); anExp1.Next() ) + { + TopoDS_Edge anEdge = TopoDS::Edge( anExp1.Current() ); + QList aVerticesIdsList; + if( EdgeDiscretization( anEdge, theDeflection, aVerticesMap, aVerticesIdsList ) ) + anEdgesMap.Add( anEdge, aVerticesIdsList ); + } + + // add into the map all faces existing in the shell and correspondence between face and edges ids + TopExp_Explorer anExp2( aShape, TopAbs_FACE ); + for( ; anExp2.More(); anExp2.Next() ) + { + TopoDS_Face aFace = TopoDS::Face( anExp2.Current() ); + TopExp_Explorer anExp3( aFace, TopAbs_EDGE ); + QList anEdgesIdsList; + for( ; anExp3.More(); anExp3.Next() ) + { + TopoDS_Edge anEdge = TopoDS::Edge( anExp3.Current() ); + int anEdgeId = anEdgesMap.FindIndex( anEdge ); + anEdgesIdsList.append( anEdgeId ); + } + aFacesMap.Add( aFace, anEdgesIdsList ); + } + + QFile aFile( theFileName ); + if( !aFile.open( QFile::WriteOnly | QFile::Text ) ) + return false; + + QTextStream aStream( &aFile ); + aStream << "# nodes\n"; + NCollection_IndexedMap::Iterator anIt1( aVerticesMap ); + for( ; anIt1.More(); anIt1.Next() ) + { + gp_Pnt aPnt = anIt1.Value(); + aStream << QString::number( aPnt.X(), TELEMAC_FORMAT, TELEMAC_PRECISION ); + aStream << " "; + aStream << QString::number( aPnt.Y(), TELEMAC_FORMAT, TELEMAC_PRECISION ); + aStream << " "; + aStream << QString::number( aPnt.Z(), TELEMAC_FORMAT, TELEMAC_PRECISION ); + aStream << "\n"; + } + aStream << "\n"; + + aStream << "# edges\n"; + NCollection_IndexedDataMap< TopoDS_Edge, QList >::Iterator anIt2( anEdgesMap ); + for( ; anIt2.More(); anIt2.Next() ) + { + QList aVerticesIds = anIt2.Value(); + foreach( int anId, aVerticesIds ) + aStream << anId << " "; + aStream << "\n"; + } + aStream << "\n"; + + aStream << "# faces\n"; + NCollection_IndexedDataMap< TopoDS_Face, QList >::Iterator anIt3( aFacesMap ); + for( ; anIt3.More(); anIt3.Next() ) + { + QList anEdgesIds = anIt3.Value(); + foreach( int anId, anEdgesIds ) + aStream << anId << " "; + aStream << "\n"; + } + aStream << "\n"; + + aFile.close(); + return true; } /** @@ -265,7 +478,7 @@ bool HYDROData_LandCoverMap::Remove( const TopTools_ListOfShape& theFacesToRemov if( !aFacesToRemove.Contains( anIt.Face() ) ) aNewFaces.Add( anIt.Face(), anIt.StricklerType() ); - StoreLandCovers( aNewFaces ); + StoreLandCovers( aNewFaces ); return true; } @@ -291,22 +504,93 @@ bool HYDROData_LandCoverMap::Split( const Handle( HYDROData_PolylineXY )& thePol */ bool HYDROData_LandCoverMap::Merge( const TopTools_ListOfShape& theFaces, const QString& theType ) { - // 1. to remove the merged faces from the current map - Remove( theFaces ); + // 1. to fuse the faces into the new face + TopoDS_Shape aMergedFace = MergeFaces( theFaces, true ); + if( aMergedFace.ShapeType()==TopAbs_FACE ) + { + // 2. to remove the merged faces from the current map + Remove( theFaces ); + + // 3. to add the face into the map + return LocalPartition( TopoDS::Face( aMergedFace ), theType ); + } + return false; +} + +TopoDS_Shape HYDROData_LandCoverMap::MergeFaces( const TopTools_ListOfShape& theFaces, + bool IsToUnify, double theTolerance ) +{ + int anError; + TopTools_ListIteratorOfListOfShape anIt; + BOPCol_ListOfShape aLC; + anIt.Initialize(theFaces); + for( ; anIt.More(); anIt.Next() ) + { + if (anIt.Value().ShapeType() != TopAbs_FACE) + return TopoDS_Shape(); + aLC.Append( anIt.Value() ); + } - // 2. to fuse the faces into the new face - BRepAlgoAPI_Fuse aFuse; - aFuse.SetArguments( theFaces ); - aFuse.Build(); - if( !aFuse.IsDone() ) - return false; + BOPAlgo_PaveFiller aPF; + aPF.SetArguments( aLC ); + aPF.SetRunParallel( Standard_False ); + aPF.SetFuzzyValue( theTolerance ); - TopoDS_Shape aMergedShape = aFuse.Shape(); - if( aMergedShape.ShapeType()!=TopAbs_FACE ) - return false; + aPF.Perform(); + anError = aPF.ErrorStatus(); + if( anError ) + return TopoDS_Shape(); + + BOPAlgo_Builder anAlgo; + anIt.Initialize( theFaces ); + for( ; anIt.More(); anIt.Next() ) + anAlgo.AddArgument( anIt.Value() ); + + anAlgo.PerformWithFiller( aPF ); + anError = anAlgo.ErrorStatus(); + if( anError ) + return TopoDS_Shape(); + + const TopoDS_Shape& aMergedShape = anAlgo.Shape(); - // 3. to add the face into the map - return LocalPartition( TopoDS::Face( aMergedShape ), theType ); + BRep_Builder aBuilder; + TopoDS_Shell aShell; + aBuilder.MakeShell( aShell ); + aShell.Closed( Standard_False ); + TopExp_Explorer anExplorer( aMergedShape, TopAbs_FACE ); + for( ; anExplorer.More(); anExplorer.Next() ) + { + const TopoDS_Face& aFace = TopoDS::Face(anExplorer.Current()); + if( aFace.IsNull() ) + continue; + if( aFace.ShapeType() == TopAbs_FACE ) + { + aBuilder.Add( aShell, aFace ); + aShell.Closed( Standard_False ); + } + } + + TopoDS_Shape aResult; + if( IsToUnify ) + { + ShapeUpgrade_UnifySameDomain aUSD; + aUSD.Initialize( aShell ); + aUSD.Build(); + aResult = aUSD.Shape(); + } + else + aResult = aShell; + + anExplorer.Init( aResult, TopAbs_FACE ); + int i = 0; + TopoDS_Face anOneFace; + for( ; anExplorer.More(); anExplorer.Next(), i++ ) + anOneFace = TopoDS::Face( anExplorer.Current() ); + + if( i == 1 ) + aResult = anOneFace; + + return aResult; } /** @@ -314,14 +598,7 @@ bool HYDROData_LandCoverMap::Merge( const TopTools_ListOfShape& theFaces, const */ TopoDS_Shape HYDROData_LandCoverMap::GetShape() const { - TDF_Label aLabel = myLab.FindChild( DataTag_Shape, false ); - if ( !aLabel.IsNull() ) - { - Handle(TNaming_NamedShape) aNamedShape; - if( aLabel.FindAttribute( TNaming_NamedShape::GetID(), aNamedShape ) ) - return aNamedShape->Get(); - } - return TopoDS_Shape(); + return HYDROData_Entity::GetShape( DataTag_Shape ); } /** @@ -330,8 +607,7 @@ TopoDS_Shape HYDROData_LandCoverMap::GetShape() const */ void HYDROData_LandCoverMap::SetShape( const TopoDS_Shape& theShape ) { - TNaming_Builder aBuilder( myLab.FindChild( DataTag_Shape ) ); - aBuilder.Generated( theShape ); + HYDROData_Entity::SetShape( DataTag_Shape, theShape ); } /** @@ -428,9 +704,11 @@ bool HYDROData_LandCoverMap::LocalPartition( const TopoDS_Shape& theNewShape, co */ void HYDROData_LandCoverMap::StoreLandCovers( const HYDROData_MapOfFaceToStricklerType& theMap ) { - TopoDS_Compound aCompound; - BRep_Builder aCompoundBuilder; - aCompoundBuilder.MakeCompound( aCompound ); + TopoDS_Shell aShell; + BRep_Builder aShellBuilder; + aShellBuilder.MakeShell( aShell ); + aShell.Closed( Standard_False ); + TopTools_ListOfShape aListOfFaces; int n = theMap.Size(); Handle( TDataStd_ExtStringArray ) aTypes = @@ -439,10 +717,59 @@ void HYDROData_LandCoverMap::StoreLandCovers( const HYDROData_MapOfFaceToStrickl for( int i=0; aNFIt.More(); aNFIt.Next(), i++ ) { TopoDS_Face aFace = aNFIt.Key(); + if (aFace.IsNull()) + continue; QString aType = aNFIt.Value(); - aCompoundBuilder.Add( aCompound, aFace ); + aShellBuilder.Add( aShell, aFace ); + aListOfFaces.Append(aFace); aTypes->SetValue( i, HYDROData_Tool::toExtString( aType ) ); } + TopoDS_Shape aMF = MergeFaces(aListOfFaces, false); + + SetShape( aListOfFaces.Extent() < 2 ? aShell : MergeFaces(aListOfFaces, false)); +} + +/** + Find the land cover for the given point + @param thePoint the point laying in some land cover + @param theType the returned type + @return the found land cover's face +*/ +TopoDS_Face HYDROData_LandCoverMap::FindByPoint( const gp_Pnt2d& thePoint, QString& theType ) const +{ + //TODO: some more optimal algorithm + Iterator anIt( *this ); + for( ; anIt.More(); anIt.Next() ) + if( HYDROData_Tool::ComputePointState( thePoint.XY(), anIt.Face() ) == TopAbs_IN ) + { + theType = anIt.StricklerType(); + return anIt.Face(); + } + + theType = ""; + return TopoDS_Face(); +} + +/** + Dump to Python + @param theTreatedObjects the map of treated objects +*/ +QStringList HYDROData_LandCoverMap::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +{ + QStringList aResList = dumpObjectCreation( theTreatedObjects ); + QString aName = GetObjPyName(); + + //Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis(); + //setPythonReferenceObject( theTreatedObjects, aResList, aHydAxis, "SetHydraulicAxis" ); + + //HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles(); + //for ( int i = 1, aNb = aSeqOfProfiles.Size(); i <= aNb; ++i ) + //{ + //const Handle(HYDROData_Entity) aProfile = aSeqOfProfiles.Value( i ); + //setPythonReferenceObject( theTreatedObjects, aResList, aProfile, "AddProfile" ); + //} + + //TODO - SetShape( aCompound ); + return aResList; }