From 185fe26122f4932fe3603721213c40bb14668896 Mon Sep 17 00:00:00 2001 From: rkv Date: Wed, 8 Jan 2014 05:40:25 +0000 Subject: [PATCH] SIP: CalculationCase is completed and ShapesGroup is added. --- CMake/UsePyQt4EXT.cmake | 3 + src/HYDROPy/CMakeLists.txt | 1 + src/HYDROPy/HYDROData.sip | 1 + src/HYDROPy/HYDROData_CalculationCase.sip | 285 ++++++++++++++++++++++ src/HYDROPy/HYDROData_Entity.sip | 4 + src/HYDROPy/HYDROData_Obstacle.sip | 2 +- src/HYDROPy/HYDROData_Region.sip | 10 +- src/HYDROPy/HYDROData_ShapesGroup.sip | 70 ++++++ src/HYDROPy/HYDROData_Zone.sip | 10 +- 9 files changed, 375 insertions(+), 11 deletions(-) create mode 100644 src/HYDROPy/HYDROData_ShapesGroup.sip diff --git a/CMake/UsePyQt4EXT.cmake b/CMake/UsePyQt4EXT.cmake index 361a9fef..141ba3d9 100644 --- a/CMake/UsePyQt4EXT.cmake +++ b/CMake/UsePyQt4EXT.cmake @@ -112,6 +112,9 @@ MACRO(PYQT4_WRAP_SIP_EXT outfiles) LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPygp_XY.cc) SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPygp_XY.cc) + LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_ShapesGroup.cc) + SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_ShapesGroup.cc) + LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyTCollection_AsciiString.cc) SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyTCollection_AsciiString.cc) diff --git a/src/HYDROPy/CMakeLists.txt b/src/HYDROPy/CMakeLists.txt index 6b704349..a0845cd5 100644 --- a/src/HYDROPy/CMakeLists.txt +++ b/src/HYDROPy/CMakeLists.txt @@ -85,6 +85,7 @@ SET(_sip_files2 CAS/NCollection_Sequence.sip HYDROData_SequenceOfObjects.sip HYDROData_Entity.sip + HYDROData_ShapesGroup.sip HYDROData_IPolyline.sip HYDROData_IAltitudeObject.sip HYDROData_Object.sip diff --git a/src/HYDROPy/HYDROData.sip b/src/HYDROPy/HYDROData.sip index 5d2b1f22..d539c655 100644 --- a/src/HYDROPy/HYDROData.sip +++ b/src/HYDROPy/HYDROData.sip @@ -57,6 +57,7 @@ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com %Include CAS/NCollection_Sequence.sip %Include HYDROData_SequenceOfObjects.sip %Include HYDROData_Entity.sip +%Include HYDROData_ShapesGroup.sip %Include HYDROData_IPolyline.sip %Include HYDROData_IAltitudeObject.sip //Include HYDROData_ObstacleAltitude.sip diff --git a/src/HYDROPy/HYDROData_CalculationCase.sip b/src/HYDROPy/HYDROData_CalculationCase.sip index affe7735..b6c119eb 100644 --- a/src/HYDROPy/HYDROData_CalculationCase.sip +++ b/src/HYDROPy/HYDROData_CalculationCase.sip @@ -44,8 +44,293 @@ 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 + }; + 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 ); + +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 gp_XY& thePoint ) const; + + /** + * Returns zone to which the point is belongs. + * \param thePoint the point to examine + * \return result zone + */ + HYDROData_Zone GetZoneFromPoint( const gp_XY& thePoint ) const [Handle_HYDROData_Zone ( const gp_XY& )]; + %MethodCode + Handle(HYDROData_Zone) aRes; + + Py_BEGIN_ALLOW_THREADS + aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetZoneFromPoint( *a0 ) : + sipCpp->GetZoneFromPoint( *a0 ); + 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 gp_XY& thePoint, + HYDROData_Zone theZone ) const + [PointClassification ( const gp_XY&, const Handle_HYDROData_Zone& )]; + + %MethodCode + Handle(HYDROData_Zone) aRef = + Handle(HYDROData_Zone)::DownCast( createHandle( a1 ) ); + + if ( !aRef.IsNull() ) + { + Py_BEGIN_ALLOW_THREADS + sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetPointClassification( *a0, aRef ) : + sipCpp->GetPointClassification( *a0, aRef ); + Py_END_ALLOW_THREADS + } + %End protected: diff --git a/src/HYDROPy/HYDROData_Entity.sip b/src/HYDROPy/HYDROData_Entity.sip index d53bcbd5..03074ee5 100644 --- a/src/HYDROPy/HYDROData_Entity.sip +++ b/src/HYDROPy/HYDROData_Entity.sip @@ -87,6 +87,10 @@ class HYDROData_Entity sipClass = sipClass_HYDROData_Zone; break; + case KIND_SHAPES_GROUP: + sipClass = sipClass_HYDROData_ShapesGroup; + break; + case KIND_UNKNOWN: sipClass = sipClass_HYDROData_Entity; break; diff --git a/src/HYDROPy/HYDROData_Obstacle.sip b/src/HYDROPy/HYDROData_Obstacle.sip index 06063fd1..8261e5f9 100644 --- a/src/HYDROPy/HYDROData_Obstacle.sip +++ b/src/HYDROPy/HYDROData_Obstacle.sip @@ -24,7 +24,7 @@ #include %End -class HYDROData_Obstacle : public HYDROData_ArtificialObject +class HYDROData_Obstacle : HYDROData_ArtificialObject { %TypeHeaderCode #include diff --git a/src/HYDROPy/HYDROData_Region.sip b/src/HYDROPy/HYDROData_Region.sip index 0f228ff4..78f17331 100644 --- a/src/HYDROPy/HYDROData_Region.sip +++ b/src/HYDROPy/HYDROData_Region.sip @@ -27,10 +27,6 @@ class HYDROData_Region : HYDROData_Entity { -%TypeHeaderCode -#include -%End - %ConvertToSubClassCode switch ( sipCpp->GetKind() ) { @@ -44,6 +40,10 @@ class HYDROData_Region : HYDROData_Entity } %End +%TypeHeaderCode +#include +%End + public: /** @@ -67,7 +67,7 @@ public: /** * Returns all reference zone of region. */ - //void HYDROData_SequenceOfObjects GetZones() const; + HYDROData_SequenceOfObjects GetZones() const; /** * Removes reference zone from region. diff --git a/src/HYDROPy/HYDROData_ShapesGroup.sip b/src/HYDROPy/HYDROData_ShapesGroup.sip new file mode 100644 index 00000000..ca2ccdee --- /dev/null +++ b/src/HYDROPy/HYDROData_ShapesGroup.sip @@ -0,0 +1,70 @@ +// 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 +// +// 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. +// +// 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 +// + +%ExportedHeaderCode +#include +%End + +class HYDROData_ShapesGroup : public HYDROData_Entity +{ + +%TypeHeaderCode +#include +%End + +public: + // Public methods to work with reference Shapes + + /** + * Add new one shape for the group. + */ + //virtual void AddShape( const TopoDS_Shape& theShape ); + + /** + * Sets new sequence of shapes for the group. + */ + //virtual void SetShapes( const TopTools_SequenceOfShape& theShapes ); + + /** + * Returns all shapes of the group. + */ + //virtual void GetShapes( TopTools_SequenceOfShape& theShapes ) const; + + /** + * Removes all shapes from the group. + */ + virtual void RemoveShapes(); + + +protected: + + /** + * Creates new object in the internal data structure. Use higher level objects + * to create objects with real content. + */ + HYDROData_ShapesGroup(); + + /** + * Destructs properties of the object and object itself, removes it from the document. + */ + virtual ~HYDROData_ShapesGroup(); +}; diff --git a/src/HYDROPy/HYDROData_Zone.sip b/src/HYDROPy/HYDROData_Zone.sip index 2b4f4d7d..17f7e42b 100644 --- a/src/HYDROPy/HYDROData_Zone.sip +++ b/src/HYDROPy/HYDROData_Zone.sip @@ -27,10 +27,6 @@ class HYDROData_Zone : HYDROData_Entity { -%TypeHeaderCode -#include -%End - %ConvertToSubClassCode switch ( sipCpp->GetKind() ) { @@ -44,6 +40,10 @@ class HYDROData_Zone : HYDROData_Entity } %End +%TypeHeaderCode +#include +%End + public: // Enumeration of mergin types for conflict altitudes @@ -131,7 +131,7 @@ public: /** * Returns all geometry objects of zone. */ - //HYDROData_SequenceOfObjects GetGeometryObjects() const; + HYDROData_SequenceOfObjects GetGeometryObjects() const; /** * Removes all geometry objects from zone. -- 2.39.2