X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROPy%2FHYDROData_CalculationCase.sip;h=e50f6850067038ec354179978e574457d15aed83;hb=474c2cd65280d793f1c81ca528bc92e1cff988e6;hp=affe7735a17c2d6aa0be80878190a230b17dd1d0;hpb=7e825ec456c9331ef0df1cb59865cc55f0d8516a;p=modules%2Fhydro.git

diff --git a/src/HYDROPy/HYDROData_CalculationCase.sip b/src/HYDROPy/HYDROData_CalculationCase.sip
index affe7735..e50f6850 100644
--- a/src/HYDROPy/HYDROData_CalculationCase.sip
+++ b/src/HYDROPy/HYDROData_CalculationCase.sip
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015  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
@@ -6,7 +6,7 @@
 // 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
@@ -22,9 +22,16 @@
 
 %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
@@ -44,8 +51,466 @@ class HYDROData_CalculationCase : HYDROData_Entity
     }
 %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:      
+  /**
+   * 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();
+
+
+  /**
+   * 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 GetSplittedGroups() const;
+
+  /**
+   * Removes all reference geometry groups from calculation case.
+   */
+  void RemoveSplittedGroups();
+
+
+  /**
+   * 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 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 ) const
+  [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Region& )];
+  %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 ) );
+
+    NCollection_Sequence<double> aRes;
+    Py_BEGIN_ALLOW_THREADS
+    aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefRegion ) : 
+                           sipCpp->GetAltitudesForPoints( aPnts, aRefRegion );
+    Py_END_ALLOW_THREADS
+    
+    sipRes = new NCollection_Sequence<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 ) const
+  [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Zone& )];
+  %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 ) );
+
+    NCollection_Sequence<double> aRes;
+    Py_BEGIN_ALLOW_THREADS
+    aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefZone ) : 
+                           sipCpp->GetAltitudesForPoints( aPnts, aRefZone );
+    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();
+
+  void AddRule( HYDROData_Object                   theObject1,
+                HYDROData_PriorityType             thePriority,
+                HYDROData_Object                   theObject2,
+                HYDROData_Zone::MergeAltitudesType theMergeType )
+  [void ( const Handle_HYDROData_Object&, HYDROData_PriorityType, const Handle_HYDROData_Object&, HYDROData_Zone::MergeAltitudesType )];
+  %MethodCode
+    Handle(HYDROData_Object) anObject1 =
+      Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
+    Handle(HYDROData_Object) anObject2 =
+      Handle(HYDROData_Object)::DownCast( createHandle( a2 ) );
+
+    Py_BEGIN_ALLOW_THREADS
+    sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRule( anObject1, a1, anObject2, a3 ) : 
+                    sipCpp->AddRule( anObject1, a1, anObject2, a3 );
+    Py_END_ALLOW_THREADS
+  %End
+
+  QString DumpRules();
 
+  void SetAssignmentMode( AssignmentMode theMode );
+  AssignmentMode GetAssignmentMode() const;
 
 protected: