]> SALOME platform Git repositories - modules/geom.git/blob - src/XAOPlugin/XAOPlugin_IOperations.cxx
Salome HOME
bos #29484 Merge branch 'vsr/29484'
[modules/geom.git] / src / XAOPlugin / XAOPlugin_IOperations.cxx
1 // Copyright (C) 2014-2021  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 // internal includes
21 #include "XAOPlugin_IOperations.hxx"
22 #include "XAOPlugin_Driver.hxx"
23 #include "XAOPlugin_IImportExport.hxx"
24
25 // KERNEL includes
26 #include <Basics_DirUtils.hxx>
27 #include <utilities.h>
28 #include <Utils_SALOME_Exception.hxx>
29
30 // GEOM includes
31 #include <GEOM_PythonDump.hxx>
32 #include <GEOMImpl_Types.hxx>
33 #include <GEOMImpl_IGroupOperations.hxx>
34 #include <GEOMImpl_IShapesOperations.hxx>
35 #include <GEOMImpl_IFieldOperations.hxx>
36 #include <GEOM_ISubShape.hxx>
37 #include <GEOM_Object.hxx>
38 #include <GEOM_Field.hxx>
39
40 #include <XAO_Geometry.hxx>
41 #include <XAO_BrepGeometry.hxx>
42 #include <XAO_Xao.hxx>
43 #include <XAO_Group.hxx>
44 #include <XAO_Field.hxx>
45 #include <XAO_BooleanField.hxx>
46 #include <XAO_IntegerField.hxx>
47 #include <XAO_DoubleField.hxx>
48 #include <XAO_StringField.hxx>
49 #include <XAO_DoubleStep.hxx>
50 #include <XAO_StringStep.hxx>
51
52 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
53
54 // OCC includes
55 #include <TColStd_HArray1OfByte.hxx>
56 #include <TColStd_HArray1OfReal.hxx>
57 #include <TDataStd_Integer.hxx>
58
59 #include <TopExp.hxx>
60
61 XAO::Dimension shapeEnumToDimension(const TopAbs_ShapeEnum& shape)
62 {
63   XAO::Dimension dim;
64   switch( shape ) {
65   case TopAbs_VERTEX:
66     dim = XAO::VERTEX; break;
67   case TopAbs_EDGE:
68     dim = XAO::EDGE; break;
69   case TopAbs_FACE:
70     dim = XAO::FACE; break;
71   case TopAbs_SOLID:
72     dim = XAO::SOLID; break;
73   default:
74     throw SALOME_Exception("Bad type"); // TODO
75   }
76   return dim;
77 }
78
79 TopAbs_ShapeEnum getGroupDimension(XAO::Group* group)
80 {
81   XAO::Dimension dim = group->getDimension();
82   TopAbs_ShapeEnum rdim;
83   switch ( dim )
84   {
85   case XAO::VERTEX:
86     rdim = TopAbs_VERTEX; break;
87   case XAO::EDGE:
88     rdim = TopAbs_EDGE; break;
89   case XAO::FACE:
90     rdim = TopAbs_FACE; break;
91   case XAO::SOLID:
92     rdim = TopAbs_SOLID; break;
93   default:
94     rdim = TopAbs_COMPOUND; break;
95   }
96   return rdim;
97 }
98
99 //=============================================================================
100 /*!
101  *  Constructor
102  */
103 //=============================================================================
104 XAOPlugin_IOperations::XAOPlugin_IOperations( GEOM_Engine* theEngine )
105 : GEOMImpl_IBaseIEOperations( theEngine )
106 {
107   MESSAGE( "XAOPlugin_IOperations::XAOPlugin_IOperations" );
108 }
109
110 //=============================================================================
111 /*!
112  *  Destructor
113  */
114 //=============================================================================
115 XAOPlugin_IOperations::~XAOPlugin_IOperations()
116 {
117   MESSAGE( "XAOPlugin_IOperations::~XAOPlugin_IOperations" );
118 }
119
120 bool XAOPlugin_IOperations::exportGroups( std::list<Handle(GEOM_Object)> groupList,
121                                           XAO::Xao* xaoObject,
122                                           XAO::BrepGeometry* geometry )
123 {
124   // add the groups
125   std::list<Handle(GEOM_Object)>::iterator groupIterator = groupList.begin();
126   while (groupIterator != groupList.end())
127   {
128     Handle(GEOM_Object) currGroup = (*groupIterator++);
129     if (currGroup->GetType() != GEOM_GROUP) {
130       SetErrorCode("Error when export groups: you could perform this operation only with group.");
131       return false;
132     }
133     Handle(TColStd_HArray1OfInteger) groupIds = myGroupOperations->GetObjects(currGroup);
134
135     TopAbs_ShapeEnum shapeGroup = myGroupOperations->GetType(currGroup);
136     XAO::Dimension dim = shapeEnumToDimension(shapeGroup);
137     XAO::Group* group = xaoObject->addGroup(dim, currGroup->GetName().ToCString());
138
139     // Group can be empty
140     if (groupIds.IsNull()) continue;
141
142     switch (shapeGroup)
143     {
144     case TopAbs_VERTEX:
145       for (int i = 1; i <= groupIds->Length(); i++)
146       {
147         std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
148         int index = geometry->getVertexIndexByReference(ref);
149         group->add(index);
150       }
151       break;
152     case TopAbs_EDGE:
153       for (int i = 1; i <= groupIds->Length(); i++)
154       {
155         std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
156         int index = geometry->getEdgeIndexByReference(ref);
157         group->add(index);
158       }
159       break;
160     case TopAbs_FACE:
161       for (int i = 1; i <= groupIds->Length(); i++)
162       {
163         std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
164         int index = geometry->getFaceIndexByReference(ref);
165         group->add(index);
166       }
167       break;
168     case TopAbs_SOLID:
169       for (int i = 1; i <= groupIds->Length(); i++)
170       {
171         std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
172         int index = geometry->getSolidIndexByReference(ref);
173         group->add(index);
174       }
175       break;
176     default:
177       ;
178     }
179   }
180   return true;
181 }
182
183 void XAOPlugin_IOperations::exportFields( std::list<Handle(GEOM_Field)> fieldList,
184                                           XAO::Xao* xaoObject,
185                                           XAO::BrepGeometry* /*geometry*/ )
186 {
187   std::list<Handle(GEOM_Field)>::iterator fieldIterator = fieldList.begin();
188   while (fieldIterator != fieldList.end())
189   {
190     Handle(GEOM_Field) currField = (*fieldIterator++);
191
192     int fdim = currField->GetDimension();
193     int ftype = currField->GetDataType();
194     int nbComponents = currField->GetNbComponents();
195     std::string name = currField->GetName().ToCString();
196
197     XAO::Field* field = xaoObject->addField((XAO::Type)ftype, (XAO::Dimension)fdim, nbComponents, name);
198
199     Handle(TColStd_HArray1OfExtendedString) components = currField->GetComponents();
200     for (int i = components->Lower(), j = 0; i <= components->Upper(); ++i, ++j)
201     {
202       field->setComponentName(j, TCollection_AsciiString(components->Value(i)).ToCString());
203     }
204
205     std::list< Handle(GEOM_FieldStep)> steps = currField->GetSteps();
206     std::list<Handle(GEOM_FieldStep)>::iterator stepIterator = steps.begin();
207     while (stepIterator != steps.end())
208     {
209       Handle(GEOM_FieldStep) currStep = (*stepIterator++);
210
211       XAO::Step* step = field->addNewStep(currStep->GetID());
212       step->setStamp(currStep->GetStamp());
213
214       switch (ftype)
215       {
216         case 0: // bool
217         {
218           XAO::BooleanStep* bs = (XAO::BooleanStep*)step;
219           Handle(TColStd_HArray1OfInteger) bvalues = currStep->GetIntValues();
220           std::vector<bool> bv;
221           bv.reserve(bvalues->Upper());
222           for ( int i = bvalues->Lower(), nb = bvalues->Upper(); i <= nb; ++i )
223           {
224             bv.push_back(bvalues->Value(i) != 0);
225           }
226           bs->setValues(bv);
227           break;
228         }
229         case 1: // integer
230         {
231           XAO::IntegerStep* is = (XAO::IntegerStep*)step;
232           Handle(TColStd_HArray1OfInteger) ivalues = currStep->GetIntValues();
233           std::vector<int> iv;
234           iv.reserve(ivalues->Upper());
235           for ( int i = ivalues->Lower(), nb = ivalues->Upper(); i <= nb; ++i )
236           {
237             iv.push_back(ivalues->Value(i));
238           }
239           is->setValues(iv);
240           break;
241         }
242         case 2: // double
243         {
244           XAO::DoubleStep* ds = (XAO::DoubleStep*)step;
245           Handle(TColStd_HArray1OfReal) dvalues = currStep->GetDoubleValues();
246           std::vector<double> dv;
247           dv.reserve(dvalues->Upper());
248           for ( int i = dvalues->Lower(), nb = dvalues->Upper(); i <= nb; ++i )
249           {
250             dv.push_back(dvalues->Value(i));
251           }
252           ds->setValues(dv);
253             break;
254         }
255         case 3: // string
256         {
257           XAO::StringStep* ss = (XAO::StringStep*)step;
258           Handle(TColStd_HArray1OfExtendedString) svalues = currStep->GetStringValues();
259           std::vector<std::string> sv;
260           sv.reserve(svalues->Upper());
261           for ( int i = svalues->Lower(), nb = svalues->Upper(); i <= nb; ++i )
262           {
263             sv.push_back(TCollection_AsciiString(svalues->Value(i)).ToCString());
264           }
265           ss->setValues(sv);
266           break;
267         }
268       }
269     }
270   }
271 }
272
273 void XAOPlugin_IOperations::exportSubshapes( const Handle(GEOM_Object)& shape, XAO::BrepGeometry* geometry )
274 {
275   Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects( shape, GEOMImpl_IShapesOperations::SubShapes );
276   int nbSubObjects = subObjects->Length();
277   if (!nbSubObjects) return;
278
279   TopoDS_Shape aMainShape = shape->GetValue();
280   if (aMainShape.IsNull()) return;
281   TopTools_IndexedMapOfShape anIndices;
282   TopExp::MapShapes(aMainShape, anIndices);
283
284   // set the names of the sub shapes
285   for (int i = 1; i <= nbSubObjects; i++)
286   {
287     Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
288     if (transientSubObject.IsNull())
289       continue;
290
291     Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast( transientSubObject );
292     if (subObject->GetType() != GEOM_GROUP)
293     {
294       TopoDS_Shape aSubShape = subObject->GetValue();
295       if (aSubShape.IsNull()) continue;
296
297       // Do not call GEOMImpl_IShapesOperations::GetSubShapeIndex() here
298       // for time optimization reason (it invokes TopExp::MapShapes())
299       //int subIndex = myShapesOperations->GetSubShapeIndex( shape, subObject );
300       int subIndex = anIndices.FindIndex(aSubShape);
301       if (!subIndex) continue;
302
303       switch (aSubShape.ShapeType())
304       {
305       case TopAbs_VERTEX:
306         geometry->changeVertexName(subIndex, subObject->GetName().ToCString());
307         break;
308       case TopAbs_EDGE:
309         geometry->changeEdgeName(subIndex, subObject->GetName().ToCString());
310         break;
311       case TopAbs_FACE:
312         geometry->changeFaceName(subIndex, subObject->GetName().ToCString());
313         break;
314       case TopAbs_SOLID:
315         geometry->changeSolidName(subIndex, subObject->GetName().ToCString());
316         break;
317       default:
318         ;
319       }
320     }
321   }
322 }
323
324 //=============================================================================
325 /*!
326  *  Export a shape to XAO format
327  *  \param shape The shape to export
328  *  \param groups The list of groups to export
329  *  \param fields The list of fields to export
330  *  \param fileName The name of the file to exported
331  *  \return boolean indicating if export was succeful.
332  */
333 //=============================================================================
334 bool XAOPlugin_IOperations::ExportXAO( Handle(GEOM_Object) shape,
335                                        std::list<Handle(GEOM_Object)> groupList,
336                                        std::list<Handle(GEOM_Field)> fieldList,
337                                        const char* author,
338                                        const char* fileName,
339                                        const char* shapeFileName )
340 {
341   SetErrorCode(KO);
342
343   if (shape.IsNull()) return false;
344
345   // add a new shape function with parameters
346   Handle(GEOM_Function) lastFunction = shape->GetLastFunction();
347   if (lastFunction.IsNull()) return false;
348
349   // add a new result object
350   Handle(GEOM_Object) result = GetEngine()->AddObject(GEOM_IMPORT);
351
352   // add an Export function
353   Handle(GEOM_Function) exportFunction = result->AddFunction(XAOPlugin_Driver::GetID(), EXPORT_SHAPE);
354   if (exportFunction.IsNull()) return false;
355   if (exportFunction->GetDriverGUID() != XAOPlugin_Driver::GetID()) return false;
356
357   // create the XAO object
358   XAO::Xao* xaoObject = new XAO::Xao();
359   xaoObject->setAuthor(author);
360
361   // add the geometry
362   XAO::BrepGeometry* geometry = (XAO::BrepGeometry*)XAO::Geometry::createGeometry(XAO::BREP);
363   TopoDS_Shape topoShape = shape->GetValue();
364   exportFunction->SetValue(topoShape);
365   XAO::BrepGeometry* brep = (XAO::BrepGeometry*)geometry;
366   brep->setTopoDS_Shape(topoShape);
367
368   geometry->setName(shape->GetName().ToCString());
369   exportSubshapes(shape, geometry);
370   xaoObject->setGeometry(geometry);
371
372   if (!exportGroups(groupList, xaoObject, geometry)) return false;
373   exportFields(fieldList, xaoObject, geometry);
374
375   // export the XAO to the file
376   xaoObject->exportXAO(fileName, shapeFileName);
377
378   // make a Python command
379   GEOM::TPythonDump pd(exportFunction);
380   std::string convFileName = Kernel_Utils::BackSlashToSlash(fileName);
381   pd << "exported = geompy.ExportXAO(" << shape;
382
383   // list of groups
384   pd << ", [";
385   if (groupList.size() > 0)
386   {
387     std::list<Handle(GEOM_Object)>::iterator itGroup = groupList.begin();
388     pd << (*itGroup++);
389     while (itGroup != groupList.end())
390     {
391       pd << ", " << (*itGroup++);
392     }
393   }
394
395   // list of fields
396   pd << "], [";
397   if (fieldList.size() > 0)
398   {
399     std::list<Handle(GEOM_Field)>::iterator itField = fieldList.begin();
400     pd << (*itField++);
401     while (itField != fieldList.end())
402     {
403       pd << ", " << (*itField++);
404     }
405   }
406   pd << "], ";
407   pd << "\"" << author << "\", \"" << convFileName.c_str() << "\", \"" << shapeFileName << "\")";
408
409   SetErrorCode(OK);
410   delete xaoObject;
411
412   return true;
413 }
414
415 void XAOPlugin_IOperations::importSubShapes( XAO::Geometry* xaoGeometry,
416                                              Handle(GEOM_Function) function, int shapeType, int dim,
417                                              Handle(TColStd_HSequenceOfTransient)& subShapeList )
418 {
419   Handle(GEOM_Object) subShape;
420   Handle(GEOM_Function) aFunction;
421   Handle(TColStd_HArray1OfInteger) anArray;
422
423   XAO::GeometricElementList::iterator elementIterator = xaoGeometry->begin((XAO::Dimension)dim);
424   for (; elementIterator != xaoGeometry->end((XAO::Dimension)dim); elementIterator++)
425   {
426     XAO::GeometricElement element = elementIterator->second;
427     if (!element.hasName())
428       continue;
429
430     std::string name = element.getName();
431     std::string ref = element.getReference();
432     int iref = XAO::XaoUtils::stringToInt(ref);
433
434     anArray = new TColStd_HArray1OfInteger(1, 1);
435     anArray->SetValue(1, iref);
436
437     subShape = GetEngine()->AddObject(GEOM_SUBSHAPE);
438     Handle(GEOM_Function) aFunction = subShape->AddFunction(GEOM_Object::GetSubShapeID(), 1);
439     if (aFunction.IsNull())
440       return;
441
442     subShape->SetName(name.c_str());
443     subShape->SetType(shapeType);
444
445     GEOM_ISubShape aSSI(aFunction);
446     aSSI.SetMainShape(function);
447     aSSI.SetIndices(anArray);
448
449     //aFunction->SetValue(aValue);
450     subShapeList->Append(subShape);
451
452     // Put this subshape in the list of sub-shapes of theMainShape
453     function->AddSubShapeReference(aFunction);
454   }
455 }
456
457 //=============================================================================
458 /*!
459  *  Import a shape from XAO format
460  *  \param fileName The name of the file to import
461  *  \param shape The imported shape
462  *  \param subShapes The list of imported groups
463  *  \param groups The list of imported groups
464  *  \param fields The list of imported fields
465  *  \return boolean indicating if import was succeful.
466  */
467 //=============================================================================
468 bool XAOPlugin_IOperations::ImportXAO( const char* fileName,
469                                        Handle(GEOM_Object)& shape,
470                                        Handle(TColStd_HSequenceOfTransient)& subShapes,
471                                        Handle(TColStd_HSequenceOfTransient)& groups,
472                                        Handle(TColStd_HSequenceOfTransient)& fields )
473 {
474   SetErrorCode(KO);
475
476   if (fileName == NULL || groups.IsNull() || fields.IsNull())
477     return false;
478
479   // Read the XAO
480   XAO::Xao* xaoObject = new XAO::Xao();
481   try
482   {
483     xaoObject->importXAO(fileName);
484   }
485   catch (XAO::XAO_Exception& exc)
486   {
487     delete xaoObject;
488     SetErrorCode(exc.what());
489     return false;
490   }
491
492   XAO::Geometry* xaoGeometry = xaoObject->getGeometry();
493   if (xaoGeometry == NULL)
494   {
495     delete xaoObject;
496     SetErrorCode("Cannot import XAO: geometry format not supported.");
497     return false;
498   }
499
500   // create the shape
501   shape = GetEngine()->AddObject(GEOM_IMPORT);
502   Handle(GEOM_Function) function = shape->AddFunction(XAOPlugin_Driver::GetID(), IMPORT_SHAPE);
503   if (function.IsNull()) return false;
504   if (function->GetDriverGUID() != XAOPlugin_Driver::GetID()) return false;
505
506   function->SetString( XAOPlugin_Driver::GetFileNameTag(), fileName );
507
508   // set the geometry
509   if (xaoGeometry->getFormat() == XAO::BREP)
510   {
511     XAO::BrepGeometry* brep = (XAO::BrepGeometry*)xaoGeometry;
512     TopoDS_Shape geomShape = brep->getTopoDS_Shape();
513     function->SetValue(geomShape);
514     shape->SetName(xaoGeometry->getName().c_str());
515   }
516   else
517   {
518     delete xaoObject;
519     SetErrorCode("Cannot import XAO: geometry format not supported.");
520     return false;
521   }
522
523   // create sub shapes with names
524   importSubShapes(xaoGeometry, function, GEOM_POINT, XAO::VERTEX, subShapes);
525   importSubShapes(xaoGeometry, function, GEOM_EDGE, XAO::EDGE, subShapes);
526   importSubShapes(xaoGeometry, function, GEOM_FACE, XAO::FACE, subShapes);
527   importSubShapes(xaoGeometry, function, GEOM_SOLID, XAO::SOLID, subShapes);
528
529   // create groups
530   int nbGroups = xaoObject->countGroups();
531   for (int i = 0; i < nbGroups; ++i)
532   {
533     XAO::Group* xaoGroup = xaoObject->getGroup(i);
534
535     // build an array with the indexes of the sub shapes
536     int nbElt = xaoGroup->count();
537     Handle(TColStd_HArray1OfInteger) array;
538     if (nbElt > 0) {
539       array = new TColStd_HArray1OfInteger(1, nbElt);
540       int j = 0;
541       for (std::set<int>::iterator it = xaoGroup->begin(); it != xaoGroup->end(); ++it) {
542         int index = (*it);
543         std::string ref = xaoGeometry->getElementReference(xaoGroup->getDimension(), index);
544         array->SetValue(++j, XAO::XaoUtils::stringToInt(ref));
545       }
546     }
547     else { // empty group
548       array = new TColStd_HArray1OfInteger(1, 1);
549       array->SetValue(1, -1);
550     }
551
552     // create the group with the array of sub shapes indexes
553     Handle(GEOM_Object) group = GetEngine()->AddSubShape(shape, array);
554     group->SetType(GEOM_GROUP);
555     group->SetName(xaoGroup->getName().c_str());
556
557     // Set a sub-shape type
558     TDF_Label freeLabel = group->GetFreeLabel();
559     TDataStd_Integer::Set(freeLabel, (Standard_Integer) getGroupDimension(xaoGroup));
560     groups->Append(group);
561   }
562
563   // create the fields
564   int nbFields = xaoObject->countFields();
565   for (int i = 0; i < nbFields; ++i)
566   {
567     XAO::Field* xaoField = xaoObject->getField(i);
568
569     Handle(TColStd_HArray1OfExtendedString) components = new TColStd_HArray1OfExtendedString(0, xaoField->countComponents()-1);
570     for (int j = 0; j < xaoField->countComponents(); ++j)
571     {
572         components->SetValue(j, (TCollection_ExtendedString)xaoField->getComponentName(j).c_str());
573     }
574
575     Handle(GEOM_Field) field = myFieldOperations->CreateField(shape,
576                  xaoField->getName().c_str(),
577                  (int)xaoField->getType(),
578                  (int)xaoField->getDimension(),
579                  components);
580
581     switch (xaoField->getType())
582     {
583         case XAO::BOOLEAN:
584         {
585             XAO::BooleanField* bfield = (XAO::BooleanField*)xaoField;
586             for (int j = 0; j < xaoField->countSteps(); ++j)
587             {
588                 XAO::BooleanStep* bstep = bfield->getStep(j);
589                 Handle(GEOM_FieldStep) step = field->AddStep(bstep->getStep(), bstep->getStamp());
590
591                 Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, bstep->countValues()-1);
592                 std::vector<bool> bvalues = bstep->getValues();
593                 for (int k = 0; k < bstep->countValues(); ++k)
594                 {
595                     values->SetValue(k, bvalues[k] ? 1 : 0);
596                 }
597                 step->SetValues(values);
598             }
599             break;
600         }
601         case XAO::INTEGER:
602         {
603             XAO::IntegerField* ifield = (XAO::IntegerField*)xaoField;
604             for (int j = 0; j < xaoField->countSteps(); ++j)
605             {
606                 XAO::IntegerStep* istep = ifield->getStep(j);
607                 Handle(GEOM_FieldStep) step = field->AddStep(istep->getStep(), istep->getStamp());
608
609                 Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, istep->countValues()-1);
610                 std::vector<int> ivalues = istep->getValues();
611                 for (int k = 0; k < istep->countValues(); ++k)
612                 {
613                     values->SetValue(k, ivalues[k]);
614                 }
615                 step->SetValues(values);
616             }
617             break;
618         }
619         case XAO::DOUBLE:
620         {
621             XAO::DoubleField* dfield = (XAO::DoubleField*)xaoField;
622             for (int j = 0; j < xaoField->countSteps(); ++j)
623             {
624                 XAO::DoubleStep* dstep = dfield->getStep(j);
625                 Handle(GEOM_FieldStep) step = field->AddStep(dstep->getStep(), dstep->getStamp());
626
627                 Handle(TColStd_HArray1OfReal) values = new TColStd_HArray1OfReal(0, dstep->countValues()-1);
628                 std::vector<double> dvalues = dstep->getValues();
629                 for (int k = 0; k < dstep->countValues(); ++k)
630                 {
631                     values->SetValue(k, dvalues[k]);
632                 }
633                 step->SetValues(values);
634             }
635             break;
636         }
637         case XAO::STRING:
638         {
639             XAO::StringField* sfield = (XAO::StringField*)xaoField;
640             for (int j = 0; j < xaoField->countSteps(); ++j)
641             {
642                 XAO::StringStep* sstep = sfield->getStep(j);
643                 Handle(GEOM_FieldStep) step = field->AddStep(sstep->getStep(), sstep->getStamp());
644
645                 Handle(TColStd_HArray1OfExtendedString) values = new TColStd_HArray1OfExtendedString(0, sstep->countValues()-1);
646                 std::vector<std::string> svalues = sstep->getValues();
647                 for (int k = 0; k < sstep->countValues(); ++k)
648                 {
649                     values->SetValue(k, TCollection_ExtendedString(svalues[k].c_str()));
650                 }
651                 step->SetValues(values);
652             }
653             break;
654         }
655     }
656
657     fields->Append(field);
658   }
659
660   // make a Python command
661   GEOM::TPythonDump pd(function);
662   pd << "(imported, " << shape << ", ";
663
664   // list of sub shapes
665   pd << "[";
666   int nbSubshapes = subShapes->Length();
667   if (nbSubshapes > 0)
668   {
669     for (int i = 1; i <= nbSubshapes; i++)
670     {
671       Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(subShapes->Value(i));
672       pd << obj << ((i < nbSubshapes) ? ", " : "");
673     }
674   }
675   pd << "], [";
676
677   // list of groups
678   if (nbGroups > 0)
679   {
680     for (int i = 1; i <= nbGroups; i++)
681     {
682       Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(groups->Value(i));
683       pd << obj << ((i < nbGroups) ? ", " : "");
684     }
685   }
686
687   pd << "], [";
688
689   // list of fields
690   if (nbFields > 0)
691   {
692     for (int i = 1; i <= nbFields; i++)
693     {
694       Handle(GEOM_Field) obj = Handle(GEOM_Field)::DownCast(fields->Value(i));
695       pd << obj << ((i < nbFields) ? ", " : "");
696     }
697   }
698   std::string convFileName =  Kernel_Utils::BackSlashToSlash( fileName );
699   pd << "]";
700   pd << ") = geompy.ImportXAO(\"" << convFileName.c_str() << "\")";
701
702   delete xaoObject;
703   SetErrorCode(OK);
704
705   return true;
706 }