]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROPy/HYDROData_CalculationCase.sip
Salome HOME
refs# 1917 + protection against null shapes wires in GetMiddlePoint()
[modules/hydro.git] / src / HYDROPy / HYDROData_CalculationCase.sip
1 // Copyright (C) 2014-2015  EDF-R&D
2 // This library is free software; you can redistribute it and/or
3 // modify it under the terms of the GNU Lesser General Public
4 // License as published by the Free Software Foundation; either
5 // version 2.1 of the License, or (at your option) any later version.
6 //
7 // This library is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 // Lesser General Public License for more details.
11 //
12 // You should have received a copy of the GNU Lesser General Public
13 // License along with this library; if not, write to the Free Software
14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
15 //
16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
17 //
18
19 %ExportedHeaderCode
20 #include <HYDROData_CalculationCase.h>
21 #include <HYDROData_PriorityQueue.h>
22 %End
23
24 enum HYDROData_PriorityType
25 {
26   LESS,
27   GREATER,
28 };
29
30 class HYDROData_CalculationCase : public HYDROData_Entity
31 {
32
33 %TypeHeaderCode
34 #include <HYDROData_CalculationCase.h>
35 %End
36
37 %ConvertToSubClassCode
38     switch ( sipCpp->GetKind() )
39     {
40       case KIND_CALCULATION:
41         sipClass = sipClass_HYDROData_CalculationCase;
42         break;
43
44       default:
45         // We don't recognise the type.
46         sipClass = NULL;
47     }
48 %End
49
50 public:
51
52   enum PointClassification
53   {
54     POINT_OUT,  ///< point is out of zone face
55     POINT_IN,   ///< point is inside of zone face
56     POINT_ON    ///< point is on the edge of zone face
57   };
58
59   enum AssignmentMode
60   {
61     MANUAL = 0,
62     AUTOMATIC,
63   };
64
65 public:
66
67   enum DataTag
68   {
69     DataTag_First = 100,               ///< first tag, to reserve
70     DataTag_GeometryObject,            ///< reference geometry objects
71     DataTag_ChildRegion,               ///< child regions
72     DataTag_Region,                    ///< reference regions
73     DataTag_Polyline,                  ///< reference boundary polyline
74     DataTag_GeometryGroup,             ///< reference geometry groups
75     DataTag_SplitGroups,               ///< reference split groups
76     DataTag_CustomRules,               ///< custom rules
77     DataTag_AssignmentMode,            ///< assignment mode
78     DataTag_StricklerTable,            ///< reference Strickler table
79     DataTag_LandCover_Obsolete,                 ///< reference land covers
80     DataTag_CustomLandCoverRules_Obsolete,      ///< custom rules for land covers priority
81     DataTag_AssignmentLandCoverMode_Obsolete,   ///< assignment mode of land covers priority
82     DataTag_ChildLandCoverRegion_Obsolete,      ///< child land cover regions
83     DataTag_LandCoverRegion_Obsolete            ///< reference land cover regions
84   };
85
86 public:      
87   /**
88    * Add new one reference geometry object for calculation case.
89    */
90   bool AddGeometryObject( HYDROData_Object theObject ) [bool ( const opencascade::handle<HYDROData_Object>& )];
91   %MethodCode
92     Handle(HYDROData_Object) aRef =
93       Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
94     if ( !aRef.IsNull() )
95     {
96       Py_BEGIN_ALLOW_THREADS
97       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryObject( aRef ):
98                                sipCpp->AddGeometryObject( aRef );
99       Py_END_ALLOW_THREADS
100     }
101   %End
102
103   /**
104    * Returns all reference geometry objects of calculation case.
105    */
106   HYDROData_SequenceOfObjects GetGeometryObjects() const;
107
108   /**
109    * Removes reference geometry object from calculation case.
110    */
111   void RemoveGeometryObject( HYDROData_Object theObject )
112   [void ( const opencascade::handle<HYDROData_Object>& )];
113   %MethodCode
114     Handle(HYDROData_Object) aRef =
115       Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
116     if ( !aRef.IsNull() )
117     {
118       Py_BEGIN_ALLOW_THREADS
119       if ( sipSelfWasArg ) {
120         sipCpp->HYDROData_CalculationCase::RemoveGeometryObject( aRef );
121       } else {
122         sipCpp->RemoveGeometryObject( aRef );
123       }
124       Py_END_ALLOW_THREADS
125     }
126   %End
127
128   /**
129    * Removes all reference geometry objects from calculation case.
130    */
131   void RemoveGeometryObjects();
132
133
134   /**
135    * Add new one reference geometry group for calculation case.
136    */
137   bool AddGeometryGroup( HYDROData_ShapesGroup theGroup ) [bool ( const opencascade::handle<HYDROData_ShapesGroup>& )];
138   %MethodCode
139     Handle(HYDROData_ShapesGroup) aRef =
140       Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
141     if ( !aRef.IsNull() )
142     {
143       Py_BEGIN_ALLOW_THREADS
144       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryGroup( aRef ):
145                                sipCpp->AddGeometryGroup( aRef );
146       Py_END_ALLOW_THREADS
147     }
148   %End
149
150   /**
151    * Returns all reference geometry groups of calculation case.
152    */
153   HYDROData_SequenceOfObjects GetGeometryGroups() const;
154
155   /**
156    * Removes reference geometry group from calculation case.
157    */
158   void RemoveGeometryGroup( HYDROData_ShapesGroup theGroup ) [void ( opencascade::handle<HYDROData_ShapesGroup>& )];
159   %MethodCode
160     Handle(HYDROData_ShapesGroup) aRef =
161       Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
162     if ( !aRef.IsNull() )
163     {
164       Py_BEGIN_ALLOW_THREADS
165       if ( sipSelfWasArg ) {
166         sipCpp->HYDROData_CalculationCase::RemoveGeometryGroup( aRef );
167       } else {
168         sipCpp->RemoveGeometryGroup( aRef );
169       }
170       Py_END_ALLOW_THREADS
171     }
172   %End
173
174   /**
175    * Removes all reference geometry groups from calculation case.
176    */
177   void RemoveGeometryGroups();
178
179      
180   /**
181    * Add new boundary polygon to calculation case.
182    */
183   bool AddBoundaryPolygon( HYDROData_BCPolygon theObject ) [bool ( const opencascade::handle<HYDROData_BCPolygon>& )];
184   %MethodCode
185     Handle(HYDROData_BCPolygon) aRef =
186       Handle(HYDROData_BCPolygon)::DownCast( createHandle( a0 ) );
187     if ( !aRef.IsNull() )
188     {
189       Py_BEGIN_ALLOW_THREADS
190       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddBoundaryPolygon( aRef ):
191                                sipCpp->AddBoundaryPolygon( aRef );
192       Py_END_ALLOW_THREADS
193     }
194   %End
195
196   /**
197    * Returns all boundary polygons of calculation case.
198    */
199   HYDROData_SequenceOfObjects GetBoundaryPolygons() const;
200
201   /**
202    * Removes boundary polygon from calculation case.
203    */
204   void RemoveBoundaryPolygon( HYDROData_BCPolygon theObject )
205   [void ( const opencascade::handle<HYDROData_BCPolygon>& )];
206   %MethodCode
207     Handle(HYDROData_BCPolygon) aRef =
208       Handle(HYDROData_BCPolygon)::DownCast( createHandle( a0 ) );
209     if ( !aRef.IsNull() )
210     {
211       Py_BEGIN_ALLOW_THREADS
212       if ( sipSelfWasArg ) {
213         sipCpp->HYDROData_CalculationCase::RemoveBoundaryPolygon( aRef );
214       } else {
215         sipCpp->RemoveBoundaryPolygon( aRef );
216       }
217       Py_END_ALLOW_THREADS
218     }
219   %End
220
221   /**
222    * Sets reference boundary polyline object for calculation case.
223    */
224   void SetBoundaryPolyline( HYDROData_PolylineXY thePolyline ) [void ( opencascade::handle<HYDROData_PolylineXY>& )];
225   %MethodCode
226     Handle(HYDROData_PolylineXY) aRef =
227       Handle(HYDROData_PolylineXY)::DownCast( createHandle( a0 ) );
228     if ( !aRef.IsNull() )
229     {
230       Py_BEGIN_ALLOW_THREADS
231       if ( sipSelfWasArg ) {
232         sipCpp->HYDROData_CalculationCase::SetBoundaryPolyline( aRef );
233       } else {
234         sipCpp->SetBoundaryPolyline( aRef );
235       }
236       Py_END_ALLOW_THREADS
237     }
238   %End
239
240   /**
241    * Returns reference boundary polyline object of calculation case.
242    */
243   HYDROData_PolylineXY GetBoundaryPolyline() const [opencascade::handle<HYDROData_PolylineXY> ()];
244   %MethodCode
245     Handle(HYDROData_PolylineXY) aRef;
246     
247     Py_BEGIN_ALLOW_THREADS
248     aRef = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetBoundaryPolyline() : 
249                            sipCpp->GetBoundaryPolyline();
250     Py_END_ALLOW_THREADS
251     
252     sipRes = (HYDROData_PolylineXY*)createPointer( aRef );
253   %End
254
255   /**
256    * Remove reference boundary polyline object from calculation case.
257    */
258   void RemoveBoundaryPolyline();
259   
260   void SetLandCoverMap( HYDROData_LandCoverMap theLandCoverMap ) [void ( const opencascade::handle<HYDROData_LandCoverMap>& )];
261   %MethodCode
262     Handle(HYDROData_LandCoverMap) aRef =
263       Handle(HYDROData_LandCoverMap)::DownCast( createHandle( a0 ) );
264     if ( !aRef.IsNull() )
265     {
266       Py_BEGIN_ALLOW_THREADS
267       if ( sipSelfWasArg ) {
268         sipCpp->HYDROData_CalculationCase::SetLandCoverMap( aRef );
269       } else {
270         sipCpp->SetLandCoverMap( aRef );
271       }
272       Py_END_ALLOW_THREADS
273     }
274   %End
275
276   void SetStricklerTable( HYDROData_StricklerTable theStricklerTable ) [void ( const opencascade::handle<HYDROData_StricklerTable>& )];
277    %MethodCode
278     Handle(HYDROData_StricklerTable) aRef =
279       Handle(HYDROData_StricklerTable)::DownCast( createHandle( a0 ) );
280     if ( !aRef.IsNull() )
281     {
282       Py_BEGIN_ALLOW_THREADS
283       if ( sipSelfWasArg ) {
284         sipCpp->HYDROData_CalculationCase::SetStricklerTable( aRef );
285       } else {
286         sipCpp->SetStricklerTable( aRef );
287       }
288       Py_END_ALLOW_THREADS
289     }
290   %End
291
292   /**
293    * Add new one child region for calculation case.
294    * The new region is added into the list of reference regions.
295    * The label of theZone is changed during this operation
296    * because of new region becomes the new parent for this zone.
297    */
298   HYDROData_Region AddNewRegion( HYDROData_Zone theZone ) [opencascade::handle<HYDROData_Region> ( opencascade::handle<HYDROData_Zone>& )];
299   %MethodCode
300     Handle(HYDROData_Zone) aRef =
301       Handle(HYDROData_Zone)::DownCast( createHandle( a0 ) );
302     Handle(HYDROData_Region) aRes;
303     
304     if ( !aRef.IsNull() )
305     {
306       Py_BEGIN_ALLOW_THREADS
307       aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddNewRegion( aRef ) : 
308                              sipCpp->AddNewRegion( aRef );
309       Py_END_ALLOW_THREADS
310     }
311     
312     sipRes = (HYDROData_Region*)createPointer( aRes );
313   %End
314
315   /**
316    * Add new one reference region for calculation case.
317    * The label of theRegion is changed in case if old parent is not this calculation.
318    */
319   bool AddRegion( HYDROData_Region theRegion ) [bool ( opencascade::handle<HYDROData_Region>& )];
320   %MethodCode
321     Handle(HYDROData_Region) aRef =
322       Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
323     if ( !aRef.IsNull() )
324     {
325       Py_BEGIN_ALLOW_THREADS
326       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRegion( aRef ):
327                                sipCpp->AddRegion( aRef );
328       Py_END_ALLOW_THREADS
329     }
330   %End
331
332   /**
333    * Returns all reference regions of calculation case.
334    */
335   HYDROData_SequenceOfObjects GetRegions() const;
336
337   /**
338    * Updates names of regions to correct order.
339    */
340   void UpdateRegionsOrder();
341
342   /**
343    * Removes reference region from calculation case.
344    */
345   void RemoveRegion( HYDROData_Region theRegion ) [void ( opencascade::handle<HYDROData_Region>& )];
346   %MethodCode
347     Handle(HYDROData_Region) aRef =
348       Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
349     if ( !aRef.IsNull() )
350     {
351       Py_BEGIN_ALLOW_THREADS
352       if ( sipSelfWasArg ) {
353         sipCpp->HYDROData_CalculationCase::RemoveRegion( aRef );
354       } else {
355         sipCpp->RemoveRegion( aRef );
356       }
357       Py_END_ALLOW_THREADS
358     }
359   %End
360
361   /**
362    * Removes all reference regions from calculation case.
363    */
364   void RemoveRegions();
365
366   
367   /**
368    * Returns all reference geometry groups of calculation case.
369    */
370   HYDROData_SequenceOfObjects GetSplitGroups() const;
371
372   /**
373    * Removes all reference geometry groups from calculation case.
374    */
375   void RemoveSplitGroups();
376
377
378   /**
379    * Exports the calculation case data (shell and groups) to GEOM module.
380    * \param theGeomEngine GEOM module engine
381    * \param theStudy SALOMEDS study, is used for publishing of GEOM objects
382    * \return true in case of success
383    */
384 //TODO:  virtual bool Export( GEOM::GEOM_Gen_var theGeomEngine,
385 //                       SALOMEDS::Study_ptr theStudy );
386         
387         QString Export( int theStudyId ) const;
388
389 public:      
390   // Public methods to work with Calculation services
391
392   /**
393    * Returns strickler coefficient for given point.
394    * \param thePoint the point to examine
395    * \return result strickler coefficient
396    */
397   double GetStricklerCoefficientForPoint( const double theCoordX,
398                                           const double theCoordY ) const [double ( const gp_XY& ) ];
399   %MethodCode
400     gp_XY aPnt( a0, a1 );
401   
402     Py_BEGIN_ALLOW_THREADS
403     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerCoefficientForPoint( aPnt ) : 
404                              sipCpp->GetStricklerCoefficientForPoint( aPnt );
405     Py_END_ALLOW_THREADS
406   %End
407
408   /**
409    * Returns altitude for given point.
410    * \param thePoint the point to examine
411    * \return result altitude value
412    */
413   double GetAltitudeForPoint( const double theCoordX,
414                               const double theCoordY ) const [double ( const gp_XY& )];
415   %MethodCode
416     gp_XY aPnt( a0, a1 );
417   
418     Py_BEGIN_ALLOW_THREADS
419     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt ) : 
420                              sipCpp->GetAltitudeForPoint( aPnt );
421     Py_END_ALLOW_THREADS
422   %End
423
424   /**
425    * Returns altitude for given point on given region.
426    * \param thePoint the point to examine
427    * \param theRegion reference region to check
428    * \return result altitude value
429    */
430   double GetAltitudeForPoint( const double     theCoordX,
431                               const double     theCoordY,
432                               HYDROData_Region theRegion ) const
433   [double ( const gp_XY&, opencascade::handle<HYDROData_Region>& )];
434   %MethodCode
435     gp_XY aPnt( a0, a1 );
436     Handle(HYDROData_Region) aRefRegion =
437       Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );
438
439     Py_BEGIN_ALLOW_THREADS
440     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefRegion ) : 
441                              sipCpp->GetAltitudeForPoint( aPnt, aRefRegion );
442     Py_END_ALLOW_THREADS
443   %End
444
445   /**
446    * Returns altitude for given point on given zone.
447    * \param thePoint the point to examine
448    * \param theZone reference zone to check
449    * \return result altitude value
450    */
451   double GetAltitudeForPoint( const double theCoordX,
452                               const double theCoordY,
453                               HYDROData_Zone theZone ) const
454   [double ( const gp_XY&, opencascade::handle<HYDROData_Zone>& )];
455   %MethodCode
456     gp_XY aPnt( a0, a1 );
457     Handle(HYDROData_Zone) aRefZone =
458       Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
459
460     Py_BEGIN_ALLOW_THREADS
461     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefZone ) : 
462                              sipCpp->GetAltitudeForPoint( aPnt, aRefZone );
463     Py_END_ALLOW_THREADS
464   %End
465
466   /**
467    * Returns altitudes for given points on given region.
468    * \param thePoints the points to examine
469    * \param theZone reference region to check
470    * \return result altitude value
471    */
472   NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
473                                                       const NCollection_Sequence<double>& theCoordsY,
474                                                       HYDROData_Region                    theRegion,
475                                                       int                                 theMethod = 0) const
476   [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, opencascade::handle<HYDROData_Region>&, int)];
477   %MethodCode
478
479     NCollection_Sequence<gp_XY> aPnts;
480
481     int aLen = qMin( a0->Length(), a1->Length() );
482     for ( int i = 1; i <= aLen; ++i )
483     {
484       gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
485       aPnts.Append( aPnt );
486     }
487
488     Handle(HYDROData_Region) aRefRegion =
489       Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );
490     int aMethod = a3;
491     
492     NCollection_Sequence<double> aRes;
493     Py_BEGIN_ALLOW_THREADS
494     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefRegion, aMethod ) : 
495                            sipCpp->GetAltitudesForPoints( aPnts, aRefRegion, aMethod );
496     Py_END_ALLOW_THREADS
497     
498     sipRes = new NCollection_Sequence<double>( aRes );
499   %End
500
501   std::vector<double> GetStricklerCoefficientForPoints( const NCollection_Sequence<double>& theCoordsX,
502                                                         const NCollection_Sequence<double>& theCoordsY,
503                                                         double DefValue,
504                                                         bool UseMax ) const
505   [std::vector<double> ( const NCollection_Sequence<gp_XY>&, double, bool)];
506   %MethodCode
507   std::vector<gp_XY> aPnts;
508   int aLen = qMin( a0->Length(), a1->Length() );
509   for ( int i = 1; i <= aLen; ++i )
510   {
511     gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
512     aPnts.push_back( aPnt );
513   }
514   std::vector<double> aRes;
515   Py_BEGIN_ALLOW_THREADS
516   aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerCoefficientForPoints( aPnts, a2, a3 ) : 
517                          sipCpp->GetStricklerCoefficientForPoints( aPnts, a2, a3 );
518   Py_END_ALLOW_THREADS
519   sipRes = new std::vector<double>( aRes );
520   %End
521
522
523   std::vector<int> GetStricklerTypeForPoints( const NCollection_Sequence<double>& theCoordsX,
524                                               const NCollection_Sequence<double>& theCoordsY ) const
525   [std::vector<int>( const NCollection_Sequence<gp_XY>& )];
526   %MethodCode
527   std::vector<gp_XY> aPnts;
528   int aLen = qMin( a0->Length(), a1->Length() );
529   for ( int i = 1; i <= aLen; ++i )
530   {
531     gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
532     aPnts.push_back( aPnt );
533   }
534   std::vector<int> aRes;
535   Py_BEGIN_ALLOW_THREADS
536   aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerTypeForPoints( aPnts ) : 
537                          sipCpp->GetStricklerTypeForPoints( aPnts );
538   Py_END_ALLOW_THREADS
539   sipRes = new std::vector<int>( aRes );
540   %End
541
542
543   /**
544    * Returns altitudes for given points on given zone.
545    * \param thePoints the points to examine
546    * \param theZone reference zone to check
547    * \return result altitude value
548    */
549   NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
550                                                       const NCollection_Sequence<double>& theCoordsY,
551                                                       HYDROData_Zone                      theZone,
552                                                       int                                 theMethod = 0) const
553   [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, opencascade::handle<HYDROData_Zone>&, int )];
554   %MethodCode
555
556     NCollection_Sequence<gp_XY> aPnts;
557
558     int aLen = qMin( a0->Length(), a1->Length() );
559     for ( int i = 1; i <= aLen; ++i )
560     {
561       gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
562       aPnts.Append( aPnt );
563     }
564
565     Handle(HYDROData_Zone) aRefZone =
566       Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
567     int aMethod = a3;
568
569     NCollection_Sequence<double> aRes;
570     Py_BEGIN_ALLOW_THREADS
571     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefZone, aMethod ) : 
572                            sipCpp->GetAltitudesForPoints( aPnts, aRefZone, aMethod );
573     Py_END_ALLOW_THREADS
574     
575     sipRes = new NCollection_Sequence<double>( aRes );
576   %End
577   
578   /**
579    * Returns region to which the point is belongs.
580    * \param thePoint the point to examine
581    * \return result region
582    */
583   HYDROData_Region GetRegionFromPoint( const double theCoordX,
584                                        const double theCoordY ) const
585   [opencascade::handle<HYDROData_Region> ( const gp_XY& )];
586   %MethodCode
587     Handle(HYDROData_Region) aRes;
588     
589     gp_XY aPnt( a0, a1 );
590   
591     Py_BEGIN_ALLOW_THREADS
592     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetRegionFromPoint( aPnt ) : 
593                            sipCpp->GetRegionFromPoint( aPnt );
594     Py_END_ALLOW_THREADS
595     
596     sipRes = (HYDROData_Region*)createPointer( aRes );
597   %End
598
599   /**
600    * Returns zone to which the point is belongs.
601    * \param thePoint the point to examine
602    * \return result zone
603    */
604   HYDROData_Zone GetZoneFromPoint( const double theCoordX,
605                                    const double theCoordY ) const
606   [opencascade::handle<HYDROData_Zone> ( const gp_XY& )];
607   %MethodCode
608     Handle(HYDROData_Zone) aRes;
609     
610     gp_XY aPnt( a0, a1 );
611   
612     Py_BEGIN_ALLOW_THREADS
613     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetZoneFromPoint( aPnt ) : 
614                            sipCpp->GetZoneFromPoint( aPnt );
615     Py_END_ALLOW_THREADS
616     
617     sipRes = (HYDROData_Zone*)createPointer( aRes );
618   %End
619
620   /**
621    * Returns classification of point for given zone.
622    * \param thePoint the point to examine
623    * \param theZone the zone to examine
624    * \return result classification
625    */
626   PointClassification GetPointClassification( const double theCoordX,
627                                               const double theCoordY,
628                                               HYDROData_Zone theZone ) const 
629   [PointClassification ( const gp_XY&, opencascade::handle<HYDROData_Zone>& )];    
630   %MethodCode
631     gp_XY aPnt( a0, a1 );
632
633     Handle(HYDROData_Zone) aRef =
634       Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
635
636     Py_BEGIN_ALLOW_THREADS
637     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetPointClassification( aPnt, aRef ) : 
638                              sipCpp->GetPointClassification( aPnt, aRef );
639     Py_END_ALLOW_THREADS
640   %End
641
642
643   void ClearRules( HYDROData_CalculationCase::DataTag theDataTag );
644
645   void AddRule( HYDROData_Entity                   theObject1,
646                 HYDROData_PriorityType             thePriority,
647                 HYDROData_Entity                   theObject2,
648                 HYDROData_Zone::MergeType          theMergeType,
649                                 HYDROData_CalculationCase::DataTag theDataTag )
650   [void ( const opencascade::handle<HYDROData_Entity>&, HYDROData_PriorityType, opencascade::handle<HYDROData_Entity>&, HYDROData_Zone::MergeType, HYDROData_CalculationCase::DataTag )];
651   %MethodCode
652     Handle(HYDROData_Entity) anObject1 = createHandle( a0 );
653     Handle(HYDROData_Entity) anObject2 = createHandle( a2 );
654
655     Py_BEGIN_ALLOW_THREADS
656     sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRule( anObject1, a1, anObject2, a3, a4 ) : 
657                     sipCpp->AddRule( anObject1, a1, anObject2, a3, a4 );
658     Py_END_ALLOW_THREADS
659   %End
660
661   QString DumpRules();
662
663   void SetAssignmentMode( AssignmentMode theMode );
664   AssignmentMode GetAssignmentMode() const;
665
666 protected:
667
668   /**
669    * Creates new object in the internal data structure. Use higher level objects 
670    * to create objects with real content.
671    */
672   HYDROData_CalculationCase();
673
674   /**
675    * Destructs properties of the object and object itself, removes it from the document.
676    */
677   ~HYDROData_CalculationCase();
678 };
679
680