]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOM_I/GEOM_IMeasureOperations_i.cc
Salome HOME
Start potring to the VTK OpenGL2 backend.
[modules/geom.git] / src / GEOM_I / GEOM_IMeasureOperations_i.cc
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 #include <Standard_Stream.hxx>
24
25 #include "GEOM_IMeasureOperations_i.hh"
26
27 #include "utilities.h"
28 #include "OpUtil.hxx"
29
30 #include "GEOM_Engine.hxx"
31 #include "GEOM_Object.hxx"
32
33 /**
34  * This function converts shape errors from theErrorsFrom to theErrorsTo.
35  * Note that theErrorsTo is not cleared at first.
36  *
37  * \param theErrorsFrom errors to be converted.
38  * \param theErrorsTo result errors.
39  */
40 static void ConvertShapeError
41     (const GEOM::GEOM_IMeasureOperations::ShapeErrors         &theErrorsFrom,
42            std::list<GEOMImpl_IMeasureOperations::ShapeError> &theErrorsTo)
43 {
44   int aNbErr = theErrorsFrom.length();
45   int i = 0;
46
47   for (; i < aNbErr; i++) {
48     const GEOM::GEOM_IMeasureOperations::ShapeError anErr = theErrorsFrom[i];
49     const GEOM::GEOM_IMeasureOperations::ShapeErrorType aType = anErr.error;
50     const GEOM::ListOfLong anIncrims = anErr.incriminated;
51     GEOMImpl_IMeasureOperations::ShapeError anErrStruct;
52
53     switch (aType) {
54     case GEOM::GEOM_IMeasureOperations::InvalidPointOnCurve:
55       anErrStruct.error = BRepCheck_InvalidPointOnCurve;
56       break;
57     case GEOM::GEOM_IMeasureOperations::InvalidPointOnCurveOnSurface:
58       anErrStruct.error = BRepCheck_InvalidPointOnCurveOnSurface;
59       break;
60     case GEOM::GEOM_IMeasureOperations::InvalidPointOnSurface:
61       anErrStruct.error = BRepCheck_InvalidPointOnSurface;
62       break;
63     case GEOM::GEOM_IMeasureOperations::No3DCurve:
64       anErrStruct.error = BRepCheck_No3DCurve;
65       break;
66     case GEOM::GEOM_IMeasureOperations::Multiple3DCurve:
67       anErrStruct.error = BRepCheck_Multiple3DCurve;
68       break;
69     case GEOM::GEOM_IMeasureOperations::Invalid3DCurve:
70       anErrStruct.error = BRepCheck_Invalid3DCurve;
71       break;
72     case GEOM::GEOM_IMeasureOperations::NoCurveOnSurface:
73       anErrStruct.error = BRepCheck_NoCurveOnSurface;
74       break;
75     case GEOM::GEOM_IMeasureOperations::InvalidCurveOnSurface:
76       anErrStruct.error = BRepCheck_InvalidCurveOnSurface;
77       break;
78     case GEOM::GEOM_IMeasureOperations::InvalidCurveOnClosedSurface:
79       anErrStruct.error = BRepCheck_InvalidCurveOnClosedSurface;
80       break;
81     case GEOM::GEOM_IMeasureOperations::InvalidSameRangeFlag:
82       anErrStruct.error = BRepCheck_InvalidSameRangeFlag;
83       break;
84     case GEOM::GEOM_IMeasureOperations::InvalidSameParameterFlag:
85       anErrStruct.error = BRepCheck_InvalidSameParameterFlag;
86       break;
87     case GEOM::GEOM_IMeasureOperations::InvalidDegeneratedFlag:
88       anErrStruct.error = BRepCheck_InvalidDegeneratedFlag;
89       break;
90     case GEOM::GEOM_IMeasureOperations::FreeEdge:
91       anErrStruct.error = BRepCheck_FreeEdge;
92       break;
93     case GEOM::GEOM_IMeasureOperations::InvalidMultiConnexity:
94       anErrStruct.error = BRepCheck_InvalidMultiConnexity;
95       break;
96     case GEOM::GEOM_IMeasureOperations::InvalidRange:
97       anErrStruct.error = BRepCheck_InvalidRange;
98       break;
99     case GEOM::GEOM_IMeasureOperations::EmptyWire:
100       anErrStruct.error = BRepCheck_EmptyWire;
101       break;
102     case GEOM::GEOM_IMeasureOperations::RedundantEdge:
103       anErrStruct.error = BRepCheck_RedundantEdge;
104       break;
105     case GEOM::GEOM_IMeasureOperations::SelfIntersectingWire:
106       anErrStruct.error = BRepCheck_SelfIntersectingWire;
107       break;
108     case GEOM::GEOM_IMeasureOperations::NoSurface:
109       anErrStruct.error = BRepCheck_NoSurface;
110       break;
111     case GEOM::GEOM_IMeasureOperations::InvalidWire:
112       anErrStruct.error = BRepCheck_InvalidWire;
113       break;
114     case GEOM::GEOM_IMeasureOperations::RedundantWire:
115       anErrStruct.error = BRepCheck_RedundantWire;
116       break;
117     case GEOM::GEOM_IMeasureOperations::IntersectingWires:
118       anErrStruct.error = BRepCheck_IntersectingWires;
119       break;
120     case GEOM::GEOM_IMeasureOperations::InvalidImbricationOfWires:
121       anErrStruct.error = BRepCheck_InvalidImbricationOfWires;
122       break;
123     case GEOM::GEOM_IMeasureOperations::EmptyShell:
124       anErrStruct.error = BRepCheck_EmptyShell;
125       break;
126     case GEOM::GEOM_IMeasureOperations::RedundantFace:
127       anErrStruct.error = BRepCheck_RedundantFace;
128       break;
129     case GEOM::GEOM_IMeasureOperations::UnorientableShape:
130       anErrStruct.error = BRepCheck_UnorientableShape;
131       break;
132     case GEOM::GEOM_IMeasureOperations::NotClosed:
133       anErrStruct.error = BRepCheck_NotClosed;
134       break;
135     case GEOM::GEOM_IMeasureOperations::NotConnected:
136       anErrStruct.error = BRepCheck_NotConnected;
137       break;
138     case GEOM::GEOM_IMeasureOperations::SubshapeNotInShape:
139       anErrStruct.error = BRepCheck_SubshapeNotInShape;
140       break;
141     case GEOM::GEOM_IMeasureOperations::BadOrientation:
142       anErrStruct.error = BRepCheck_BadOrientation;
143       break;
144     case GEOM::GEOM_IMeasureOperations::BadOrientationOfSubshape:
145       anErrStruct.error = BRepCheck_BadOrientationOfSubshape;
146       break;
147     case GEOM::GEOM_IMeasureOperations::InvalidToleranceValue:
148       anErrStruct.error = BRepCheck_InvalidToleranceValue;
149       break;
150     case GEOM::GEOM_IMeasureOperations::CheckFail:
151       anErrStruct.error = BRepCheck_CheckFail;
152       break;
153     default:
154       break;
155     }
156
157     int ii = 0;
158     int aLen = anIncrims.length();
159
160     for (; ii < aLen; ii++) {
161       anErrStruct.incriminated.push_back(anIncrims[ii]);
162     }
163
164     theErrorsTo.push_back(anErrStruct);
165   }
166 }
167
168 /**
169  * This function converts shape errors from theErrorsFrom to theErrorsTo.
170  * Note that theErrorsTo is not cleared at first.
171  *
172  * \param theErrorsFrom errors to be converted.
173  * \param theErrorsTo result errors.
174  */
175 static void ConvertShapeError
176     (const std::list<GEOMImpl_IMeasureOperations::ShapeError> &theErrorsFrom,
177            GEOM::GEOM_IMeasureOperations::ShapeErrors_out     &theErrorsTo)
178 {
179   const int aNbErr = theErrorsFrom.size();
180   GEOM::GEOM_IMeasureOperations::ShapeErrors_var anErrArray =
181     new GEOM::GEOM_IMeasureOperations::ShapeErrors;
182
183   anErrArray->length(aNbErr);
184
185   // fill the local CORBA array with values from lists
186   std::list<GEOMImpl_IMeasureOperations::ShapeError>::const_iterator
187     anIt = theErrorsFrom.begin();
188   int i = 0;
189
190   for (; anIt != theErrorsFrom.end(); i++, anIt++) {
191     GEOM::GEOM_IMeasureOperations::ShapeError_var anErrStruct =
192       new GEOM::GEOM_IMeasureOperations::ShapeError;
193
194     switch (anIt->error) {
195     case BRepCheck_InvalidPointOnCurve:
196       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidPointOnCurve;
197       break;
198     case BRepCheck_InvalidPointOnCurveOnSurface:
199       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidPointOnCurveOnSurface;
200       break;
201     case BRepCheck_InvalidPointOnSurface:
202       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidPointOnSurface;
203       break;
204     case BRepCheck_No3DCurve:
205       anErrStruct->error = GEOM::GEOM_IMeasureOperations::No3DCurve;
206       break;
207     case BRepCheck_Multiple3DCurve:
208       anErrStruct->error = GEOM::GEOM_IMeasureOperations::Multiple3DCurve;
209       break;
210     case BRepCheck_Invalid3DCurve:
211       anErrStruct->error = GEOM::GEOM_IMeasureOperations::Invalid3DCurve;
212       break;
213     case BRepCheck_NoCurveOnSurface:
214       anErrStruct->error = GEOM::GEOM_IMeasureOperations::NoCurveOnSurface;
215       break;
216     case BRepCheck_InvalidCurveOnSurface:
217       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidCurveOnSurface;
218       break;
219     case BRepCheck_InvalidCurveOnClosedSurface:
220       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidCurveOnClosedSurface;
221       break;
222     case BRepCheck_InvalidSameRangeFlag:
223       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidSameRangeFlag;
224       break;
225     case BRepCheck_InvalidSameParameterFlag:
226       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidSameParameterFlag;
227       break;
228     case BRepCheck_InvalidDegeneratedFlag:
229       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidDegeneratedFlag;
230       break;
231     case BRepCheck_FreeEdge:
232       anErrStruct->error = GEOM::GEOM_IMeasureOperations::FreeEdge;
233       break;
234     case BRepCheck_InvalidMultiConnexity:
235       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidMultiConnexity;
236       break;
237     case BRepCheck_InvalidRange:
238       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidRange;
239       break;
240     case BRepCheck_EmptyWire:
241       anErrStruct->error = GEOM::GEOM_IMeasureOperations::EmptyWire;
242       break;
243     case BRepCheck_RedundantEdge:
244       anErrStruct->error = GEOM::GEOM_IMeasureOperations::RedundantEdge;
245       break;
246     case BRepCheck_SelfIntersectingWire:
247       anErrStruct->error = GEOM::GEOM_IMeasureOperations::SelfIntersectingWire;
248       break;
249     case BRepCheck_NoSurface:
250       anErrStruct->error = GEOM::GEOM_IMeasureOperations::NoSurface;
251       break;
252     case BRepCheck_InvalidWire:
253       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidWire;
254       break;
255     case BRepCheck_RedundantWire:
256       anErrStruct->error = GEOM::GEOM_IMeasureOperations::RedundantWire;
257       break;
258     case BRepCheck_IntersectingWires:
259       anErrStruct->error = GEOM::GEOM_IMeasureOperations::IntersectingWires;
260       break;
261     case BRepCheck_InvalidImbricationOfWires:
262       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidImbricationOfWires;
263       break;
264     case BRepCheck_EmptyShell:
265       anErrStruct->error = GEOM::GEOM_IMeasureOperations::EmptyShell;
266       break;
267     case BRepCheck_RedundantFace:
268       anErrStruct->error = GEOM::GEOM_IMeasureOperations::RedundantFace;
269       break;
270     case BRepCheck_UnorientableShape:
271       anErrStruct->error = GEOM::GEOM_IMeasureOperations::UnorientableShape;
272       break;
273     case BRepCheck_NotClosed:
274       anErrStruct->error = GEOM::GEOM_IMeasureOperations::NotClosed;
275       break;
276     case BRepCheck_NotConnected:
277       anErrStruct->error = GEOM::GEOM_IMeasureOperations::NotConnected;
278       break;
279     case BRepCheck_SubshapeNotInShape:
280       anErrStruct->error = GEOM::GEOM_IMeasureOperations::SubshapeNotInShape;
281       break;
282     case BRepCheck_BadOrientation:
283       anErrStruct->error = GEOM::GEOM_IMeasureOperations::BadOrientation;
284       break;
285     case BRepCheck_BadOrientationOfSubshape:
286       anErrStruct->error = GEOM::GEOM_IMeasureOperations::BadOrientationOfSubshape;
287       break;
288     case BRepCheck_InvalidToleranceValue:
289       anErrStruct->error = GEOM::GEOM_IMeasureOperations::InvalidToleranceValue;
290       break;
291     case BRepCheck_CheckFail:
292       anErrStruct->error = GEOM::GEOM_IMeasureOperations::CheckFail;
293       break;
294     default:
295       break;
296     }
297
298     std::list<int> aIndList = anIt->incriminated;
299     GEOM::ListOfLong_var anIncrims = new GEOM::ListOfLong();
300     anIncrims->length(aIndList.size());
301
302     std::list<int>::iterator anIndIt = aIndList.begin();
303     int jj = 0;
304
305     for (; anIndIt != aIndList.end(); jj++, anIndIt++) {
306       anIncrims[jj] = *anIndIt;
307     }
308
309     anErrStruct->incriminated = anIncrims;
310
311     anErrArray[i] = anErrStruct;
312   }
313
314   // initialize out-parameter with local array
315   theErrorsTo = anErrArray._retn();
316 }
317
318 //=============================================================================
319 /*!
320  *   constructor:
321  */
322 //=============================================================================
323 GEOM_IMeasureOperations_i::GEOM_IMeasureOperations_i (PortableServer::POA_ptr thePOA,
324                                                       GEOM::GEOM_Gen_ptr theEngine,
325                                                       ::GEOMImpl_IMeasureOperations* theImpl)
326 :GEOM_IOperations_i(thePOA, theEngine, theImpl)
327 {
328   MESSAGE("GEOM_IMeasureOperations_i::GEOM_IMeasureOperations_i");
329 }
330
331 //=============================================================================
332 /*!
333  *  destructor
334  */
335 //=============================================================================
336 GEOM_IMeasureOperations_i::~GEOM_IMeasureOperations_i()
337 {
338   MESSAGE("GEOM_IMeasureOperations_i::~GEOM_IMeasureOperations_i");
339 }
340
341 //=============================================================================
342 /*!
343  *  KindOfShape
344  */
345 //=============================================================================
346 GEOM::GEOM_IKindOfShape::shape_kind GEOM_IMeasureOperations_i::KindOfShape
347                                    (GEOM::GEOM_Object_ptr  theShape,
348                                     GEOM::ListOfLong_out   theIntegers,
349                                     GEOM::ListOfDouble_out theDoubles)
350 {
351   GEOMImpl_IMeasureOperations::ShapeKind aKind = GEOMImpl_IMeasureOperations::SK_NO_SHAPE;
352
353   // allocate the CORBA arrays
354   GEOM::ListOfLong_var anIntegersArray = new GEOM::ListOfLong();
355   GEOM::ListOfDouble_var aDoublesArray = new GEOM::ListOfDouble();
356
357   //Get the reference shape
358   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
359
360   if (!aShape.IsNull()) {
361     Handle(TColStd_HSequenceOfInteger) anIntegers = new TColStd_HSequenceOfInteger;
362     Handle(TColStd_HSequenceOfReal)    aDoubles   = new TColStd_HSequenceOfReal;
363
364     // Detect kind of shape and parameters
365     aKind = GetOperations()->KindOfShape(aShape, anIntegers, aDoubles);
366
367     int nbInts = anIntegers->Length();
368     int nbDbls = aDoubles->Length();
369
370     anIntegersArray->length(nbInts);
371     aDoublesArray->length(nbDbls);
372
373     for (int ii = 0; ii < nbInts; ii++) {
374       anIntegersArray[ii] = anIntegers->Value(ii + 1);
375     }
376     for (int id = 0; id < nbDbls; id++) {
377       aDoublesArray[id] = aDoubles->Value(id + 1);
378     }
379   }
380
381   // initialize out-parameters with local arrays
382   theIntegers = anIntegersArray._retn();
383   theDoubles  = aDoublesArray._retn();
384   return (GEOM::GEOM_IKindOfShape::shape_kind)aKind;
385 }
386
387 //=============================================================================
388 /*!
389  *  GetPosition
390  */
391 //=============================================================================
392 void GEOM_IMeasureOperations_i::GetPosition
393                  (GEOM::GEOM_Object_ptr theShape,
394                   CORBA::Double& Ox, CORBA::Double& Oy, CORBA::Double& Oz,
395                   CORBA::Double& Zx, CORBA::Double& Zy, CORBA::Double& Zz,
396                   CORBA::Double& Xx, CORBA::Double& Xy, CORBA::Double& Xz)
397 {
398   //Set a not done flag
399   GetOperations()->SetNotDone();
400
401   //Set default values: global CS
402   Ox = Oy = Oz = Zx = Zy = Xy = Xz = 0.;
403   Zz = Xx = 1.;
404
405   //Get the reference shape
406   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
407   if (aShape.IsNull()) return;
408
409   // Get shape parameters
410   GetOperations()->GetPosition(aShape, Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz);
411 }
412
413 //=============================================================================
414 /*!
415  *  GetCentreOfMass
416  */
417 //=============================================================================
418 GEOM::GEOM_Object_ptr GEOM_IMeasureOperations_i::GetCentreOfMass
419                                               (GEOM::GEOM_Object_ptr theShape)
420 {
421   GEOM::GEOM_Object_var aGEOMObject;
422
423   //Set a not done flag
424   GetOperations()->SetNotDone();
425
426   //Get the reference shape
427   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
428   if (aShape.IsNull()) return aGEOMObject._retn();
429
430   // Make Point - centre of mass of theShape
431   HANDLE_NAMESPACE(GEOM_Object) anObject = GetOperations()->GetCentreOfMass(aShape);
432   if (!GetOperations()->IsDone() || anObject.IsNull())
433     return aGEOMObject._retn();
434
435   return GetObject(anObject);
436 }
437
438 //=============================================================================
439 /*!
440  *  GetVertexByIndex
441  */
442 //=============================================================================
443 GEOM::GEOM_Object_ptr GEOM_IMeasureOperations_i::GetVertexByIndex
444   (GEOM::GEOM_Object_ptr theShape, CORBA::Long theIndex)
445 {
446   GEOM::GEOM_Object_var aGEOMObject;
447
448   //Set a not done flag
449   GetOperations()->SetNotDone();
450
451   //Get the reference shape
452   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
453   if ( aShape.IsNull() ) return aGEOMObject._retn();
454
455   // Get vertex by index
456   HANDLE_NAMESPACE(GEOM_Object) anObject = GetOperations()->GetVertexByIndex(aShape, theIndex);
457   if (!GetOperations()->IsDone() || anObject.IsNull())
458     return aGEOMObject._retn();
459
460   return GetObject(anObject);
461 }
462
463 //=============================================================================
464 /*!
465  *  GetNormal
466  */
467 //=============================================================================
468 GEOM::GEOM_Object_ptr GEOM_IMeasureOperations_i::GetNormal
469                                        (GEOM::GEOM_Object_ptr theFace,
470                                         GEOM::GEOM_Object_ptr theOptionalPoint)
471 {
472   GEOM::GEOM_Object_var aGEOMObject;
473
474   //Set a not done flag
475   GetOperations()->SetNotDone();
476
477   //Get the reference shape
478   HANDLE_NAMESPACE(GEOM_Object) aFace = GetObjectImpl(theFace);
479   if (aFace.IsNull()) return aGEOMObject._retn();
480
481   // Get the OptionalPoint (can be not defined)
482   HANDLE_NAMESPACE(GEOM_Object) anOptionalPoint = GetObjectImpl(theOptionalPoint);
483
484   // Make Vector - normal to theFace (in point theOptionalPoint if the face is not planar)
485   HANDLE_NAMESPACE(GEOM_Object) anObject = GetOperations()->GetNormal(aFace, anOptionalPoint);
486   if (!GetOperations()->IsDone() || anObject.IsNull())
487     return aGEOMObject._retn();
488
489   return GetObject(anObject);
490 }
491
492 //=============================================================================
493 /*!
494  *  GetBasicProperties
495  */
496 //=============================================================================
497 void GEOM_IMeasureOperations_i::GetBasicProperties (GEOM::GEOM_Object_ptr theShape,
498                                                     CORBA::Double& theLength,
499                                                     CORBA::Double& theSurfArea,
500                                                     CORBA::Double& theVolume)
501 {
502   //Set a not done flag
503   GetOperations()->SetNotDone();
504
505   //Get the reference shape
506   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
507   if (aShape.IsNull()) return;
508
509   // Get shape parameters
510   GetOperations()->GetBasicProperties(aShape, theLength, theSurfArea, theVolume);
511 }
512
513 //=============================================================================
514 /*!
515  *  GetInertia
516  */
517 //=============================================================================
518 void GEOM_IMeasureOperations_i::GetInertia
519   (GEOM::GEOM_Object_ptr theShape,
520    CORBA::Double& I11, CORBA::Double& I12, CORBA::Double& I13,
521    CORBA::Double& I21, CORBA::Double& I22, CORBA::Double& I23,
522    CORBA::Double& I31, CORBA::Double& I32, CORBA::Double& I33,
523    CORBA::Double& Ix , CORBA::Double& Iy , CORBA::Double& Iz)
524 {
525   //Set a not done flag
526   GetOperations()->SetNotDone();
527
528   //Get the reference shape
529   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
530   if (aShape.IsNull()) return;
531
532   // Get shape parameters
533   GetOperations()->GetInertia(aShape,
534                               I11, I12, I13,
535                               I21, I22, I23,
536                               I31, I32, I33,
537                               Ix , Iy , Iz);
538 }
539
540 //=============================================================================
541 /*!
542  *  GetBoundingBox
543  */
544 //=============================================================================
545 void GEOM_IMeasureOperations_i::GetBoundingBox (GEOM::GEOM_Object_ptr theShape,
546                                                 CORBA::Boolean precise,
547                                                 CORBA::Double& Xmin, CORBA::Double& Xmax,
548                                                 CORBA::Double& Ymin, CORBA::Double& Ymax,
549                                                 CORBA::Double& Zmin, CORBA::Double& Zmax)
550 {
551   //Set a not done flag
552   GetOperations()->SetNotDone();
553
554   //Get the reference shape
555   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
556   if (aShape.IsNull()) return;
557
558   // Get shape parameters
559   GetOperations()->GetBoundingBox
560     (aShape, precise, Xmin, Xmax, Ymin, Ymax, Zmin, Zmax);
561 }
562
563 //=============================================================================
564 /*!
565  *  MakeBoundingBox
566  */
567 //=============================================================================
568 GEOM::GEOM_Object_ptr GEOM_IMeasureOperations_i::MakeBoundingBox
569                                               (GEOM::GEOM_Object_ptr theShape,
570                                                CORBA::Boolean precise)
571 {
572   GEOM::GEOM_Object_var aGEOMObject;
573
574   //Set a not done flag
575   GetOperations()->SetNotDone();
576
577   //Get the reference shape
578   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
579   if (aShape.IsNull()) return aGEOMObject._retn();
580
581   // Make Box - bounding box of theShape
582   HANDLE_NAMESPACE(GEOM_Object) anObject =
583     GetOperations()->GetBoundingBox(aShape, precise);
584   if (!GetOperations()->IsDone() || anObject.IsNull())
585     return aGEOMObject._retn();
586
587   return GetObject(anObject);
588 }
589
590 //=============================================================================
591 /*!
592  *  GetTolerance
593  */
594 //=============================================================================
595 void GEOM_IMeasureOperations_i::GetTolerance
596                                 (GEOM::GEOM_Object_ptr theShape,
597                                  CORBA::Double& FaceMin, CORBA::Double& FaceMax,
598                                  CORBA::Double& EdgeMin, CORBA::Double& EdgeMax,
599                                  CORBA::Double& VertMin, CORBA::Double& VertMax)
600 {
601   //Set a not done flag
602   GetOperations()->SetNotDone();
603
604   //Get the reference shape
605   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
606   if (aShape.IsNull()) return;
607
608   // Get shape parameters
609   GetOperations()->GetTolerance(aShape,
610                                 FaceMin, FaceMax,
611                                 EdgeMin, EdgeMax,
612                                 VertMin, VertMax);
613 }
614
615 //=============================================================================
616 /*!
617  *  CheckShape
618  */
619 //=============================================================================
620 CORBA::Boolean GEOM_IMeasureOperations_i::CheckShape
621              (GEOM::GEOM_Object_ptr                          theShape,
622               GEOM::GEOM_IMeasureOperations::ShapeErrors_out theErrors)
623 {
624   //Set a not done flag
625   GetOperations()->SetNotDone();
626
627   if (CORBA::is_nil(theShape))
628   {
629     return 0;
630   }
631
632   //Get the reference shape
633   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
634
635   if (aShape.IsNull())
636   {
637     return 0;
638   }
639
640   std::list<GEOMImpl_IMeasureOperations::ShapeError> anErrList;
641   bool isOk = GetOperations()->CheckShape(aShape, false, anErrList);
642
643   ConvertShapeError(anErrList, theErrors);
644
645   return isOk;
646 }
647
648 CORBA::Boolean GEOM_IMeasureOperations_i::CheckShapeWithGeometry
649              (GEOM::GEOM_Object_ptr                          theShape,
650               GEOM::GEOM_IMeasureOperations::ShapeErrors_out theErrors)
651 {
652   //Set a not done flag
653   GetOperations()->SetNotDone();
654
655   if (CORBA::is_nil(theShape))
656   {
657     return 0;
658   }
659
660   //Get the reference shape
661   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
662
663   if (aShape.IsNull())
664   {
665     return 0;
666   }
667
668   std::list<GEOMImpl_IMeasureOperations::ShapeError> anErrList;
669   bool isOk = GetOperations()->CheckShape(aShape, true, anErrList);
670
671   ConvertShapeError(anErrList, theErrors);
672
673   return isOk;
674 }
675
676 //=============================================================================
677 /*!
678  *  PrintShapeErrors
679  */
680 //=============================================================================
681 char* GEOM_IMeasureOperations_i::PrintShapeErrors
682              (      GEOM::GEOM_Object_ptr                       theShape,
683               const GEOM::GEOM_IMeasureOperations::ShapeErrors &theErrors)
684 {
685   //Get the reference shape
686   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
687
688   if (aShape.IsNull()) {
689     return NULL;
690   }
691
692   // Convert the errors sequence
693   std::list<GEOMImpl_IMeasureOperations::ShapeError> anErrList;
694
695   ConvertShapeError(theErrors, anErrList);
696
697   TCollection_AsciiString aDescr =
698     GetOperations()->PrintShapeErrors(aShape, anErrList);
699
700   return CORBA::string_dup(aDescr.ToCString());
701 }
702
703 //=============================================================================
704 /*!
705  *  CheckSelfIntersections
706  */
707 //=============================================================================
708 CORBA::Boolean GEOM_IMeasureOperations_i::CheckSelfIntersections (GEOM::GEOM_Object_ptr theShape,
709                                                                   CORBA::Long           theCheckLevel,
710                                                                   GEOM::ListOfLong_out  theIntersections)
711 {
712   // Set a not done flag
713   GetOperations()->SetNotDone();
714
715   bool isGood = false;
716
717   // Allocate the CORBA arrays
718   GEOM::ListOfLong_var anIntegersArray = new GEOM::ListOfLong();
719
720   // Get the reference shape
721   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
722
723   if (!aShape.IsNull()) {
724     GEOMImpl_IMeasureOperations::SICheckLevel aCheckLevel;
725
726     switch(theCheckLevel) {
727     case GEOM::SI_V_V:
728       aCheckLevel = GEOMImpl_IMeasureOperations::SI_V_V;
729       break;
730     case GEOM::SI_V_E:
731       aCheckLevel = GEOMImpl_IMeasureOperations::SI_V_E;
732       break;
733     case GEOM::SI_E_E:
734       aCheckLevel = GEOMImpl_IMeasureOperations::SI_E_E;
735       break;
736     case GEOM::SI_V_F:
737       aCheckLevel = GEOMImpl_IMeasureOperations::SI_V_F;
738       break;
739     case GEOM::SI_E_F:
740       aCheckLevel = GEOMImpl_IMeasureOperations::SI_E_F;
741       break;
742     case GEOM::SI_ALL:
743     default:
744       aCheckLevel = GEOMImpl_IMeasureOperations::SI_ALL;
745       break;
746     }
747
748     Handle(TColStd_HSequenceOfInteger) anIntegers = new TColStd_HSequenceOfInteger;
749
750     // Detect self-intersections
751     isGood = GetOperations()->CheckSelfIntersections
752       (aShape, aCheckLevel, anIntegers);
753
754     int nbInts = anIntegers->Length();
755
756     anIntegersArray->length(nbInts);
757
758     for (int ii = 0; ii < nbInts; ii++) {
759       anIntegersArray[ii] = anIntegers->Value(ii + 1);
760     }
761   }
762
763   // Initialize out-parameters with local arrays
764   theIntersections = anIntegersArray._retn();
765   return isGood;
766 }
767
768 //=============================================================================
769 /*!
770  *  CheckSelfIntersectionsFast
771  */
772 //=============================================================================
773 CORBA::Boolean GEOM_IMeasureOperations_i::CheckSelfIntersectionsFast 
774   (GEOM::GEOM_Object_ptr theShape,
775    CORBA::Float          theDeflection,
776    CORBA::Double         theTolerance,
777    GEOM::ListOfLong_out  theIntersections)
778 {
779   // Set a not done flag
780   GetOperations()->SetNotDone();
781
782   bool isGood = false;
783
784   // Allocate the CORBA arrays
785   GEOM::ListOfLong_var anIntegersArray = new GEOM::ListOfLong();
786
787   // Get the reference shape
788   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
789
790   if (!aShape.IsNull()) {
791     Handle(TColStd_HSequenceOfInteger) anIntegers = new TColStd_HSequenceOfInteger;
792
793     // Detect self-intersections
794     isGood = GetOperations()->CheckSelfIntersectionsFast
795       (aShape, theDeflection, theTolerance, anIntegers);
796
797     int nbInts = anIntegers->Length();
798
799     anIntegersArray->length(nbInts);
800
801     for (int ii = 0; ii < nbInts; ii++) {
802       anIntegersArray[ii] = anIntegers->Value(ii + 1);
803     }
804   }
805
806   // Initialize out-parameters with local arrays
807   theIntersections = anIntegersArray._retn();
808   return isGood;
809 }
810
811 //=============================================================================
812 /*!
813  *  FastIntersect
814  */
815 //=============================================================================
816 CORBA::Boolean GEOM_IMeasureOperations_i::FastIntersect (GEOM::GEOM_Object_ptr theShape1,
817                                                          GEOM::GEOM_Object_ptr theShape2,
818                                                          CORBA::Double         theTolerance,
819                                                          CORBA::Float          theDeflection,
820                                                          GEOM::ListOfLong_out  theIntersections1,
821                                                          GEOM::ListOfLong_out  theIntersections2)
822 {
823   // Set a not done flag
824   GetOperations()->SetNotDone();
825
826   bool isGood = false;
827
828   // Allocate the CORBA arrays
829   GEOM::ListOfLong_var anIntegersArray1 = new GEOM::ListOfLong();
830   GEOM::ListOfLong_var anIntegersArray2 = new GEOM::ListOfLong();
831
832   // Get the reference shape
833   HANDLE_NAMESPACE(GEOM_Object) aShape1 = GetObjectImpl(theShape1);
834   HANDLE_NAMESPACE(GEOM_Object) aShape2 = GetObjectImpl(theShape2);
835   
836   if (!aShape1.IsNull() && !aShape2.IsNull()) {
837     Handle(TColStd_HSequenceOfInteger) anIntegers1 = new TColStd_HSequenceOfInteger;
838     Handle(TColStd_HSequenceOfInteger) anIntegers2 = new TColStd_HSequenceOfInteger;
839
840     // Detect intersections
841     isGood = GetOperations()->FastIntersect
842       (aShape1, aShape2, theTolerance, theDeflection, anIntegers1, anIntegers2);
843
844     int nbInts1 = anIntegers1->Length();
845     int nbInts2 = anIntegers2->Length();
846
847     anIntegersArray1->length(nbInts1);
848     anIntegersArray2->length(nbInts2);
849
850     for (int ii = 0; ii < nbInts1; ii++) {
851       anIntegersArray1[ii] = anIntegers1->Value(ii + 1);
852     }
853     for (int ii = 0; ii < nbInts2; ii++) {
854       anIntegersArray2[ii] = anIntegers2->Value(ii + 1);
855     }
856   }
857
858   // Initialize out-parameters with local arrays
859   theIntersections1 = anIntegersArray1._retn();
860   theIntersections2 = anIntegersArray2._retn();
861   return isGood;
862 }
863
864 //=============================================================================
865 /*!
866  *  IsGoodForSolid
867  */
868 //=============================================================================
869 char* GEOM_IMeasureOperations_i::IsGoodForSolid (GEOM::GEOM_Object_ptr theShape)
870 {
871   //Set a not done flag
872   GetOperations()->SetNotDone();
873
874   //Get the reference shape
875   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
876   if (aShape.IsNull()) return CORBA::string_dup("WRN_NULL_OBJECT_OR_SHAPE");
877
878   // Get shape parameters
879   TCollection_AsciiString aDescription = GetOperations()->IsGoodForSolid(aShape);
880   return CORBA::string_dup(aDescription.ToCString());
881 }
882
883 //=============================================================================
884 /*!
885  *  WhatIs
886  */
887 //=============================================================================
888 char* GEOM_IMeasureOperations_i::WhatIs (GEOM::GEOM_Object_ptr theShape)
889 {
890   //Set a not done flag
891   GetOperations()->SetNotDone();
892
893   //Get the reference shape
894   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
895   if (aShape.IsNull()) return NULL;
896
897   // Get shape parameters
898   TCollection_AsciiString aDescription = GetOperations()->WhatIs(aShape);
899   return CORBA::string_dup(aDescription.ToCString());
900 }
901
902 //=============================================================================
903 /*!
904  *  AreCoordsInside
905  */
906 //=============================================================================
907 GEOM::ListOfBool* GEOM_IMeasureOperations_i::AreCoordsInside (GEOM::GEOM_Object_ptr theShape,
908                                                               const GEOM::ListOfDouble& theCoords,
909                                                               CORBA::Double tolerance)
910 {
911   //Set a not done flag
912   GetOperations()->SetNotDone();
913   
914   unsigned int nb_points = theCoords.length()/3;
915
916   GEOM::ListOfBool_var aResults = new GEOM::ListOfBool;
917   aResults->length(nb_points);
918   
919   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
920   
921   std::vector<double> tmp(3*nb_points);
922   for (int i = 0; i < 3*nb_points; i++)
923     tmp[i] = theCoords[i];
924   std::vector<bool> res = GetOperations()->AreCoordsInside(aShape, tmp, tolerance);
925   for (int i = 0; i < nb_points; i++)
926     aResults[i] = i < res.size() ? res[i] : false;
927   return aResults._retn();
928 }
929
930 //=============================================================================
931 /*!
932  *  GetMinDistance
933  */
934 //=============================================================================
935 CORBA::Double GEOM_IMeasureOperations_i::GetMinDistance
936   (GEOM::GEOM_Object_ptr theShape1, GEOM::GEOM_Object_ptr theShape2,
937    CORBA::Double& X1, CORBA::Double& Y1, CORBA::Double& Z1,
938    CORBA::Double& X2, CORBA::Double& Y2, CORBA::Double& Z2)
939 {
940   //Set a not done flag
941   GetOperations()->SetNotDone();
942
943   //Get the reference shape
944   HANDLE_NAMESPACE(GEOM_Object) aShape1 = GetObjectImpl(theShape1);
945   HANDLE_NAMESPACE(GEOM_Object) aShape2 = GetObjectImpl(theShape2);
946   if (aShape1.IsNull() || aShape2.IsNull()) return -1.0;
947
948   // Get shape parameters
949   return GetOperations()->GetMinDistance(aShape1, aShape2, X1, Y1, Z1, X2, Y2, Z2);
950 }
951
952 //=============================================================================
953 /*!
954  *  ClosestPoints
955  */
956 //=============================================================================
957 CORBA::Long GEOM_IMeasureOperations_i::ClosestPoints
958   (GEOM::GEOM_Object_ptr theShape1, GEOM::GEOM_Object_ptr theShape2,
959    GEOM::ListOfDouble_out theCoords)
960 {
961   //Set a not done flag
962   GetOperations()->SetNotDone();
963
964   // allocate the CORBA array
965   int nbSols = 0;
966   GEOM::ListOfDouble_var aDoublesArray = new GEOM::ListOfDouble();
967
968   //Get the reference shape
969   HANDLE_NAMESPACE(GEOM_Object) aShape1 = GetObjectImpl(theShape1);
970   HANDLE_NAMESPACE(GEOM_Object) aShape2 = GetObjectImpl(theShape2);
971
972   if (!aShape1.IsNull() && !aShape2.IsNull()) {
973     Handle(TColStd_HSequenceOfReal) aDoubles = new TColStd_HSequenceOfReal;
974     // Get shape parameters
975     nbSols = GetOperations()->ClosestPoints(aShape1, aShape2, aDoubles);
976     int nbDbls = aDoubles->Length();
977     aDoublesArray->length(nbDbls);
978     for (int id = 0; id < nbDbls; id++) {
979       aDoublesArray[id] = aDoubles->Value(id + 1);
980     }
981   }
982
983   theCoords = aDoublesArray._retn();
984   return nbSols;
985 }
986
987 //=============================================================================
988 /*!
989  *  PointCoordinates
990  */
991 //=============================================================================
992 void GEOM_IMeasureOperations_i::PointCoordinates (GEOM::GEOM_Object_ptr theShape,
993                                                   CORBA::Double& X, CORBA::Double& Y, CORBA::Double& Z)
994
995 {
996   //Set a not done flag
997   GetOperations()->SetNotDone();
998
999   //Get the reference shape
1000   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theShape);
1001   if (aShape.IsNull())
1002     return;
1003
1004   // Get shape parameters
1005   GetOperations()->PointCoordinates( aShape, X, Y, Z );
1006 }
1007
1008 //=============================================================================
1009 /*!
1010  *  GetAngle
1011  */
1012 //=============================================================================
1013 CORBA::Double GEOM_IMeasureOperations_i::GetAngle (GEOM::GEOM_Object_ptr theShape1,
1014                                                    GEOM::GEOM_Object_ptr theShape2)
1015 {
1016   //Set a not done flag
1017   GetOperations()->SetNotDone();
1018
1019   //Get the reference shapes
1020   HANDLE_NAMESPACE(GEOM_Object) aShape1 = GetObjectImpl(theShape1);
1021   HANDLE_NAMESPACE(GEOM_Object) aShape2 = GetObjectImpl(theShape2);
1022   if (aShape1.IsNull() || aShape2.IsNull()) return -1.0;
1023
1024   // Get the angle
1025   return GetOperations()->GetAngle(aShape1, aShape2);
1026 }
1027
1028 //=============================================================================
1029 /*!
1030  *  GetAngle
1031  */
1032 //=============================================================================
1033 CORBA::Double GEOM_IMeasureOperations_i::GetAngleBtwVectors (GEOM::GEOM_Object_ptr theShape1,
1034                                                              GEOM::GEOM_Object_ptr theShape2)
1035 {
1036   //Set a not done flag
1037   GetOperations()->SetNotDone();
1038
1039   //Get the reference shapes
1040   HANDLE_NAMESPACE(GEOM_Object) aShape1 = GetObjectImpl(theShape1);
1041   HANDLE_NAMESPACE(GEOM_Object) aShape2 = GetObjectImpl(theShape2);
1042   if (aShape1.IsNull() || aShape2.IsNull()) return -1.0;
1043
1044   // Get the angle
1045   return GetOperations()->GetAngleBtwVectors(aShape1, aShape2);
1046 }
1047
1048
1049 //=============================================================================
1050 /*!
1051  *  CurveCurvatureByParam
1052  */
1053 //=============================================================================
1054 CORBA::Double GEOM_IMeasureOperations_i::CurveCurvatureByParam
1055                        (GEOM::GEOM_Object_ptr theCurve, CORBA::Double theParam)
1056 {
1057   //Set a not done flag
1058   GetOperations()->SetNotDone();
1059
1060   //Get the reference shape
1061   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theCurve);
1062   if(aShape.IsNull()) return -1.0;
1063
1064   return GetOperations()->CurveCurvatureByParam(aShape,theParam);
1065 }
1066
1067 //=============================================================================
1068 /*!
1069  *  CurveCurvatureByPoint
1070  */
1071 //=============================================================================
1072 CORBA::Double GEOM_IMeasureOperations_i::CurveCurvatureByPoint
1073                (GEOM::GEOM_Object_ptr theCurve, GEOM::GEOM_Object_ptr thePoint)
1074 {
1075   //Set a not done flag
1076   GetOperations()->SetNotDone();
1077
1078   //Get the reference shape
1079   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theCurve);
1080   HANDLE_NAMESPACE(GEOM_Object) aPoint = GetObjectImpl(thePoint);
1081   if( aShape.IsNull() || aPoint.IsNull() ) return -1.0;
1082
1083   return GetOperations()->CurveCurvatureByPoint(aShape,aPoint);
1084 }
1085
1086
1087 //=============================================================================
1088 /*!
1089  *  MaxSurfaceCurvatureByParam
1090  */
1091 //=============================================================================
1092 CORBA::Double GEOM_IMeasureOperations_i::MaxSurfaceCurvatureByParam
1093                                                 (GEOM::GEOM_Object_ptr theSurf,
1094                                                  CORBA::Double theUParam,
1095                                                  CORBA::Double theVParam)
1096 {
1097   //Set a not done flag
1098   GetOperations()->SetNotDone();
1099
1100   //Get the reference shape
1101   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theSurf);
1102   if(aShape.IsNull()) return -1.0;
1103
1104   return GetOperations()->MaxSurfaceCurvatureByParam(aShape,theUParam,theVParam);
1105 }
1106
1107 //=============================================================================
1108 /*!
1109  *  MaxSurfaceCurvatureByPoint
1110  */
1111 //=============================================================================
1112 CORBA::Double GEOM_IMeasureOperations_i::MaxSurfaceCurvatureByPoint
1113                 (GEOM::GEOM_Object_ptr theSurf, GEOM::GEOM_Object_ptr thePoint)
1114 {
1115   //Set a not done flag
1116   GetOperations()->SetNotDone();
1117
1118   //Get the reference shape
1119   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theSurf);
1120   HANDLE_NAMESPACE(GEOM_Object) aPoint = GetObjectImpl(thePoint);
1121   if( aShape.IsNull() || aPoint.IsNull() ) return -1.0;
1122
1123   return GetOperations()->MaxSurfaceCurvatureByPoint(aShape,aPoint);
1124 }
1125
1126 //=============================================================================
1127 /*!
1128  *  MinSurfaceCurvatureByParam
1129  */
1130 //=============================================================================
1131 CORBA::Double GEOM_IMeasureOperations_i::MinSurfaceCurvatureByParam
1132                                                 (GEOM::GEOM_Object_ptr theSurf,
1133                                                  CORBA::Double theUParam,
1134                                                  CORBA::Double theVParam)
1135 {
1136   //Set a not done flag
1137   GetOperations()->SetNotDone();
1138
1139   //Get the reference shape
1140   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theSurf);
1141   if (aShape.IsNull()) return -1.0;
1142
1143   return GetOperations()->MinSurfaceCurvatureByParam(aShape,theUParam,theVParam);
1144 }
1145
1146 //=============================================================================
1147 /*!
1148  *  MinSurfaceCurvatureByPoint
1149  */
1150 //=============================================================================
1151 CORBA::Double GEOM_IMeasureOperations_i::MinSurfaceCurvatureByPoint
1152                 (GEOM::GEOM_Object_ptr theSurf, GEOM::GEOM_Object_ptr thePoint)
1153 {
1154   //Set a not done flag
1155   GetOperations()->SetNotDone();
1156
1157   //Get the reference shape
1158   HANDLE_NAMESPACE(GEOM_Object) aShape = GetObjectImpl(theSurf);
1159   HANDLE_NAMESPACE(GEOM_Object) aPoint = GetObjectImpl(thePoint);
1160   if (aShape.IsNull() || aPoint.IsNull()) return -1.0;
1161
1162   return GetOperations()->MinSurfaceCurvatureByPoint(aShape,aPoint);
1163 }