-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
+// 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.
+// 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
%ExportedHeaderCode
#include <HYDROData_CalculationCase.h>
+#include <HYDROData_PriorityQueue.h>
%End
-class HYDROData_CalculationCase : HYDROData_Entity
+enum HYDROData_PriorityType
+{
+ LESS,
+ GREATER,
+};
+
+class HYDROData_CalculationCase : public HYDROData_Entity
{
%TypeHeaderCode
}
%End
+public:
+
+ enum PointClassification
+ {
+ POINT_OUT, ///< point is out of zone face
+ POINT_IN, ///< point is inside of zone face
+ POINT_ON ///< point is on the edge of zone face
+ };
+
+ enum AssignmentMode
+ {
+ MANUAL = 0,
+ AUTOMATIC,
+ };
+
+public:
+
+ enum DataTag
+ {
+ DataTag_First = 100, ///< first tag, to reserve
+ DataTag_GeometryObject, ///< reference geometry objects
+ DataTag_ChildRegion, ///< child regions
+ DataTag_Region, ///< reference regions
+ DataTag_Polyline, ///< reference boundary polyline
+ DataTag_GeometryGroup, ///< reference geometry groups
+ DataTag_SplitGroups, ///< reference split groups
+ DataTag_CustomRules, ///< custom rules
+ DataTag_AssignmentMode, ///< assignment mode
+ DataTag_StricklerTable, ///< reference Strickler table
+ DataTag_LandCover_Obsolete, ///< reference land covers
+ DataTag_CustomLandCoverRules_Obsolete, ///< custom rules for land covers priority
+ DataTag_AssignmentLandCoverMode_Obsolete, ///< assignment mode of land covers priority
+ DataTag_ChildLandCoverRegion_Obsolete, ///< child land cover regions
+ DataTag_LandCoverRegion_Obsolete ///< reference land cover regions
+ };
+
public:
+ /**
+ * Add new one reference geometry object for calculation case.
+ */
+ bool AddGeometryObject( HYDROData_Object theObject ) [bool ( const Handle_HYDROData_Object& )];
+ %MethodCode
+ Handle(HYDROData_Object) aRef =
+ Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryObject( aRef ):
+ sipCpp->AddGeometryObject( aRef );
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Returns all reference geometry objects of calculation case.
+ */
+ HYDROData_SequenceOfObjects GetGeometryObjects() const;
+
+ /**
+ * Removes reference geometry object from calculation case.
+ */
+ void RemoveGeometryObject( HYDROData_Object theObject )
+ [void ( const Handle_HYDROData_Object& )];
+ %MethodCode
+ Handle(HYDROData_Object) aRef =
+ Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ if ( sipSelfWasArg ) {
+ sipCpp->HYDROData_CalculationCase::RemoveGeometryObject( aRef );
+ } else {
+ sipCpp->RemoveGeometryObject( aRef );
+ }
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Removes all reference geometry objects from calculation case.
+ */
+ void RemoveGeometryObjects();
+
+
+ /**
+ * Add new one reference geometry group for calculation case.
+ */
+ bool AddGeometryGroup( HYDROData_ShapesGroup theGroup ) [bool ( const Handle_HYDROData_ShapesGroup& )];
+ %MethodCode
+ Handle(HYDROData_ShapesGroup) aRef =
+ Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryGroup( aRef ):
+ sipCpp->AddGeometryGroup( aRef );
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Returns all reference geometry groups of calculation case.
+ */
+ HYDROData_SequenceOfObjects GetGeometryGroups() const;
+
+ /**
+ * Removes reference geometry group from calculation case.
+ */
+ void RemoveGeometryGroup( HYDROData_ShapesGroup theGroup ) [void ( const Handle_HYDROData_ShapesGroup& )];
+ %MethodCode
+ Handle(HYDROData_ShapesGroup) aRef =
+ Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ if ( sipSelfWasArg ) {
+ sipCpp->HYDROData_CalculationCase::RemoveGeometryGroup( aRef );
+ } else {
+ sipCpp->RemoveGeometryGroup( aRef );
+ }
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Removes all reference geometry groups from calculation case.
+ */
+ void RemoveGeometryGroups();
+
+
+ /**
+ * Sets reference boundary polyline object for calculation case.
+ */
+ void SetBoundaryPolyline( HYDROData_PolylineXY thePolyline ) [void ( const Handle_HYDROData_PolylineXY& )];
+ %MethodCode
+ Handle(HYDROData_PolylineXY) aRef =
+ Handle(HYDROData_PolylineXY)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ if ( sipSelfWasArg ) {
+ sipCpp->HYDROData_CalculationCase::SetBoundaryPolyline( aRef );
+ } else {
+ sipCpp->SetBoundaryPolyline( aRef );
+ }
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Returns reference boundary polyline object of calculation case.
+ */
+ HYDROData_PolylineXY GetBoundaryPolyline() const [Handle_HYDROData_PolylineXY ()];
+ %MethodCode
+ Handle(HYDROData_PolylineXY) aRef;
+
+ Py_BEGIN_ALLOW_THREADS
+ aRef = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetBoundaryPolyline() :
+ sipCpp->GetBoundaryPolyline();
+ Py_END_ALLOW_THREADS
+
+ sipRes = (HYDROData_PolylineXY*)createPointer( aRef );
+ %End
+
+ /**
+ * Remove reference boundary polyline object from calculation case.
+ */
+ void RemoveBoundaryPolyline();
+
+ void SetLandCoverMap( HYDROData_LandCoverMap theLandCoverMap ) [void ( const Handle_HYDROData_LandCoverMap& )];
+ %MethodCode
+ Handle(HYDROData_LandCoverMap) aRef =
+ Handle(HYDROData_LandCoverMap)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ if ( sipSelfWasArg ) {
+ sipCpp->HYDROData_CalculationCase::SetLandCoverMap( aRef );
+ } else {
+ sipCpp->SetLandCoverMap( aRef );
+ }
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ void SetStricklerTable( HYDROData_StricklerTable theStricklerTable ) [void ( const Handle_HYDROData_StricklerTable& )];
+ %MethodCode
+ Handle(HYDROData_StricklerTable) aRef =
+ Handle(HYDROData_StricklerTable)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ if ( sipSelfWasArg ) {
+ sipCpp->HYDROData_CalculationCase::SetStricklerTable( aRef );
+ } else {
+ sipCpp->SetStricklerTable( aRef );
+ }
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Add new one child region for calculation case.
+ * The new region is added into the list of reference regions.
+ * The label of theZone is changed during this operation
+ * because of new region becomes the new parent for this zone.
+ */
+ HYDROData_Region AddNewRegion( HYDROData_Zone theZone ) [Handle_HYDROData_Region ( const Handle_HYDROData_Zone& )];
+ %MethodCode
+ Handle(HYDROData_Zone) aRef =
+ Handle(HYDROData_Zone)::DownCast( createHandle( a0 ) );
+ Handle(HYDROData_Region) aRes;
+
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddNewRegion( aRef ) :
+ sipCpp->AddNewRegion( aRef );
+ Py_END_ALLOW_THREADS
+ }
+
+ sipRes = (HYDROData_Region*)createPointer( aRes );
+ %End
+
+ /**
+ * Add new one reference region for calculation case.
+ * The label of theRegion is changed in case if old parent is not this calculation.
+ */
+ bool AddRegion( HYDROData_Region theRegion ) [bool ( const Handle_HYDROData_Region& )];
+ %MethodCode
+ Handle(HYDROData_Region) aRef =
+ Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRegion( aRef ):
+ sipCpp->AddRegion( aRef );
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Returns all reference regions of calculation case.
+ */
+ HYDROData_SequenceOfObjects GetRegions() const;
+
+ /**
+ * Updates names of regions to correct order.
+ */
+ void UpdateRegionsOrder();
+
+ /**
+ * Removes reference region from calculation case.
+ */
+ void RemoveRegion( HYDROData_Region theRegion ) [void ( const Handle_HYDROData_Region& )];
+ %MethodCode
+ Handle(HYDROData_Region) aRef =
+ Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
+ if ( !aRef.IsNull() )
+ {
+ Py_BEGIN_ALLOW_THREADS
+ if ( sipSelfWasArg ) {
+ sipCpp->HYDROData_CalculationCase::RemoveRegion( aRef );
+ } else {
+ sipCpp->RemoveRegion( aRef );
+ }
+ Py_END_ALLOW_THREADS
+ }
+ %End
+
+ /**
+ * Removes all reference regions from calculation case.
+ */
+ void RemoveRegions();
+
+
+ /**
+ * Returns all reference geometry groups of calculation case.
+ */
+ HYDROData_SequenceOfObjects GetSplitGroups() const;
+
+ /**
+ * Removes all reference geometry groups from calculation case.
+ */
+ void RemoveSplitGroups();
+
+
+ /**
+ * Exports the calculation case data (shell and groups) to GEOM module.
+ * \param theGeomEngine GEOM module engine
+ * \param theStudy SALOMEDS study, is used for publishing of GEOM objects
+ * \return true in case of success
+ */
+//TODO: virtual bool Export( GEOM::GEOM_Gen_var theGeomEngine,
+// SALOMEDS::Study_ptr theStudy );
+
+ QString Export( int theStudyId ) const;
+
+public:
+ // Public methods to work with Calculation services
+
+ /**
+ * Returns strickler coefficient for given point.
+ * \param thePoint the point to examine
+ * \return result strickler coefficient
+ */
+ double GetStricklerCoefficientForPoint( const double theCoordX,
+ const double theCoordY ) const [double ( const gp_XY& ) ];
+ %MethodCode
+ gp_XY aPnt( a0, a1 );
+
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerCoefficientForPoint( aPnt ) :
+ sipCpp->GetStricklerCoefficientForPoint( aPnt );
+ Py_END_ALLOW_THREADS
+ %End
+
+ /**
+ * Returns altitude for given point.
+ * \param thePoint the point to examine
+ * \return result altitude value
+ */
+ double GetAltitudeForPoint( const double theCoordX,
+ const double theCoordY ) const [double ( const gp_XY& )];
+ %MethodCode
+ gp_XY aPnt( a0, a1 );
+
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt ) :
+ sipCpp->GetAltitudeForPoint( aPnt );
+ Py_END_ALLOW_THREADS
+ %End
+
+ /**
+ * Returns altitude for given point on given region.
+ * \param thePoint the point to examine
+ * \param theRegion reference region to check
+ * \return result altitude value
+ */
+ double GetAltitudeForPoint( const double theCoordX,
+ const double theCoordY,
+ HYDROData_Region theRegion ) const
+ [double ( const gp_XY&, const Handle_HYDROData_Region& )];
+ %MethodCode
+ gp_XY aPnt( a0, a1 );
+ Handle(HYDROData_Region) aRefRegion =
+ Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );
+
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefRegion ) :
+ sipCpp->GetAltitudeForPoint( aPnt, aRefRegion );
+ Py_END_ALLOW_THREADS
+ %End
+
+ /**
+ * Returns altitude for given point on given zone.
+ * \param thePoint the point to examine
+ * \param theZone reference zone to check
+ * \return result altitude value
+ */
+ double GetAltitudeForPoint( const double theCoordX,
+ const double theCoordY,
+ HYDROData_Zone theZone ) const
+ [double ( const gp_XY&, const Handle_HYDROData_Zone& )];
+ %MethodCode
+ gp_XY aPnt( a0, a1 );
+ Handle(HYDROData_Zone) aRefZone =
+ Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
+
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefZone ) :
+ sipCpp->GetAltitudeForPoint( aPnt, aRefZone );
+ Py_END_ALLOW_THREADS
+ %End
+
+ /**
+ * Returns altitudes for given points on given region.
+ * \param thePoints the points to examine
+ * \param theZone reference region to check
+ * \return result altitude value
+ */
+ NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
+ const NCollection_Sequence<double>& theCoordsY,
+ HYDROData_Region theRegion,
+ int theMethod = 0) const
+ [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Region&, int)];
+ %MethodCode
+
+ NCollection_Sequence<gp_XY> aPnts;
+
+ int aLen = qMin( a0->Length(), a1->Length() );
+ for ( int i = 1; i <= aLen; ++i )
+ {
+ gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
+ aPnts.Append( aPnt );
+ }
+
+ Handle(HYDROData_Region) aRefRegion =
+ Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );
+ int aMethod = a3;
+
+ NCollection_Sequence<double> aRes;
+ Py_BEGIN_ALLOW_THREADS
+ aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefRegion, aMethod ) :
+ sipCpp->GetAltitudesForPoints( aPnts, aRefRegion, aMethod );
+ Py_END_ALLOW_THREADS
+
+ sipRes = new NCollection_Sequence<double>( aRes );
+ %End
+
+ std::vector<double> GetStricklerCoefficientForPoints( const NCollection_Sequence<double>& theCoordsX,
+ const NCollection_Sequence<double>& theCoordsY,
+ double DefValue,
+ bool UseMax ) const
+ [std::vector<double> ( const NCollection_Sequence<gp_XY>&, double, bool)];
+ %MethodCode
+ std::vector<gp_XY> aPnts;
+ int aLen = qMin( a0->Length(), a1->Length() );
+ for ( int i = 1; i <= aLen; ++i )
+ {
+ gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
+ aPnts.push_back( aPnt );
+ }
+ std::vector<double> aRes;
+ Py_BEGIN_ALLOW_THREADS
+ aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerCoefficientForPoints( aPnts, a2, a3 ) :
+ sipCpp->GetStricklerCoefficientForPoints( aPnts, a2, a3 );
+ Py_END_ALLOW_THREADS
+ sipRes = new std::vector<double>( aRes );
+ %End
+
+
+ /**
+ * Returns altitudes for given points on given zone.
+ * \param thePoints the points to examine
+ * \param theZone reference zone to check
+ * \return result altitude value
+ */
+ NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
+ const NCollection_Sequence<double>& theCoordsY,
+ HYDROData_Zone theZone,
+ int theMethod = 0) const
+ [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Zone&, int )];
+ %MethodCode
+
+ NCollection_Sequence<gp_XY> aPnts;
+
+ int aLen = qMin( a0->Length(), a1->Length() );
+ for ( int i = 1; i <= aLen; ++i )
+ {
+ gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
+ aPnts.Append( aPnt );
+ }
+
+ Handle(HYDROData_Zone) aRefZone =
+ Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
+ int aMethod = a3;
+
+ NCollection_Sequence<double> aRes;
+ Py_BEGIN_ALLOW_THREADS
+ aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefZone, aMethod ) :
+ sipCpp->GetAltitudesForPoints( aPnts, aRefZone, aMethod );
+ Py_END_ALLOW_THREADS
+
+ sipRes = new NCollection_Sequence<double>( aRes );
+ %End
+
+ /**
+ * Returns region to which the point is belongs.
+ * \param thePoint the point to examine
+ * \return result region
+ */
+ HYDROData_Region GetRegionFromPoint( const double theCoordX,
+ const double theCoordY ) const
+ [Handle_HYDROData_Region ( const gp_XY& )];
+ %MethodCode
+ Handle(HYDROData_Region) aRes;
+
+ gp_XY aPnt( a0, a1 );
+
+ Py_BEGIN_ALLOW_THREADS
+ aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetRegionFromPoint( aPnt ) :
+ sipCpp->GetRegionFromPoint( aPnt );
+ Py_END_ALLOW_THREADS
+
+ sipRes = (HYDROData_Region*)createPointer( aRes );
+ %End
+
+ /**
+ * Returns zone to which the point is belongs.
+ * \param thePoint the point to examine
+ * \return result zone
+ */
+ HYDROData_Zone GetZoneFromPoint( const double theCoordX,
+ const double theCoordY ) const
+ [Handle_HYDROData_Zone ( const gp_XY& )];
+ %MethodCode
+ Handle(HYDROData_Zone) aRes;
+
+ gp_XY aPnt( a0, a1 );
+
+ Py_BEGIN_ALLOW_THREADS
+ aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetZoneFromPoint( aPnt ) :
+ sipCpp->GetZoneFromPoint( aPnt );
+ Py_END_ALLOW_THREADS
+
+ sipRes = (HYDROData_Zone*)createPointer( aRes );
+ %End
+
+ /**
+ * Returns classification of point for given zone.
+ * \param thePoint the point to examine
+ * \param theZone the zone to examine
+ * \return result classification
+ */
+ PointClassification GetPointClassification( const double theCoordX,
+ const double theCoordY,
+ HYDROData_Zone theZone ) const
+ [PointClassification ( const gp_XY&, const Handle_HYDROData_Zone& )];
+ %MethodCode
+ gp_XY aPnt( a0, a1 );
+
+ Handle(HYDROData_Zone) aRef =
+ Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
+
+ Py_BEGIN_ALLOW_THREADS
+ sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetPointClassification( aPnt, aRef ) :
+ sipCpp->GetPointClassification( aPnt, aRef );
+ Py_END_ALLOW_THREADS
+ %End
+
+
+ void ClearRules( HYDROData_CalculationCase::DataTag theDataTag );
+
+ void AddRule( HYDROData_Entity theObject1,
+ HYDROData_PriorityType thePriority,
+ HYDROData_Entity theObject2,
+ HYDROData_Zone::MergeType theMergeType,
+ HYDROData_CalculationCase::DataTag theDataTag )
+ [void ( const Handle_HYDROData_Entity&, HYDROData_PriorityType, const Handle_HYDROData_Entity&, HYDROData_Zone::MergeType, HYDROData_CalculationCase::DataTag )];
+ %MethodCode
+ Handle(HYDROData_Entity) anObject1 =
+ Handle(HYDROData_Entity)::DownCast( createHandle( a0 ) );
+ Handle(HYDROData_Entity) anObject2 =
+ Handle(HYDROData_Entity)::DownCast( createHandle( a2 ) );
+
+ Py_BEGIN_ALLOW_THREADS
+ sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRule( anObject1, a1, anObject2, a3, a4 ) :
+ sipCpp->AddRule( anObject1, a1, anObject2, a3, a4 );
+ Py_END_ALLOW_THREADS
+ %End
+
+ QString DumpRules();
+ void SetAssignmentMode( AssignmentMode theMode );
+ AssignmentMode GetAssignmentMode() const;
protected: