1 // Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 #include <Standard_Stream.hxx>
25 #include <GEOMImpl_IInsertOperations.hxx>
27 #include <GEOMImpl_CopyDriver.hxx>
28 #include <GEOMImpl_ExportDriver.hxx>
29 #include <GEOMImpl_ImportDriver.hxx>
30 #include <GEOMImpl_ICopy.hxx>
31 #include <GEOMImpl_IImportExport.hxx>
32 #include <GEOMImpl_Types.hxx>
33 #include "GEOMImpl_IShapesOperations.hxx"
34 #include "GEOMImpl_IGroupOperations.hxx"
35 #include "GEOMImpl_IFieldOperations.hxx"
36 #include "GEOMImpl_XAODriver.hxx"
37 #include "GEOMImpl_IImportExportXAO.hxx"
39 #include <GEOM_Function.hxx>
40 #include <GEOM_PythonDump.hxx>
41 #include "GEOM_ISubShape.hxx"
43 #include <XAO_Xao.hxx>
44 #include <XAO_Geometry.hxx>
45 #include <XAO_BrepGeometry.hxx>
46 #include <XAO_Group.hxx>
47 #include <XAO_Field.hxx>
48 #include <XAO_XaoUtils.hxx>
49 #include <XAO_BooleanField.hxx>
50 #include <XAO_IntegerField.hxx>
51 #include <XAO_DoubleField.hxx>
52 #include <XAO_StringField.hxx>
53 #include <XAO_BooleanStep.hxx>
54 #include <XAO_IntegerStep.hxx>
55 #include <XAO_DoubleStep.hxx>
56 #include <XAO_StringStep.hxx>
58 #include <Basics_OCCTVersion.hxx>
60 #include "utilities.h"
62 #include <Utils_ExceptHandlers.hxx>
64 #include <TFunction_DriverTable.hxx>
65 #include <TFunction_Driver.hxx>
66 #include <TFunction_Logbook.hxx>
67 #include <TDF_ChildIDIterator.hxx>
68 #include <TDF_Tool.hxx>
69 #include <TDataStd_Integer.hxx>
70 #include <TNaming_NamedShape.hxx>
71 #include <TDataStd_Comment.hxx>
72 #include <TopTools_IndexedMapOfShape.hxx>
76 #include <TopoDS_Vertex.hxx>
77 #include <BRep_Builder.hxx>
78 #include <BRep_Tool.hxx>
79 #include <BRepTools.hxx>
82 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
83 #include <TColStd_HArray1OfByte.hxx>
84 #include <TColStd_HArray1OfReal.hxx>
86 #include <TDataStd_HArray1OfByte.hxx>
89 #include <Standard_Failure.hxx>
90 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
93 * This function returns the input format name from the original format name.
95 static TCollection_AsciiString GetImportFormatName
96 (const TCollection_AsciiString& theFormatName)
98 return theFormatName.Token("_");
101 //=============================================================================
105 //=============================================================================
106 GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID)
107 : GEOM_IOperations(theEngine, theDocID)
109 MESSAGE("GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations");
110 myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID());
111 myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
112 myFieldOperations = new GEOMImpl_IFieldOperations(GetEngine(), GetDocID());
115 //=============================================================================
119 //=============================================================================
120 GEOMImpl_IInsertOperations::~GEOMImpl_IInsertOperations()
122 MESSAGE("GEOMImpl_IInsertOperations::~GEOMImpl_IInsertOperations");
123 delete myShapesOperations;
124 delete myGroupOperations;
125 delete myFieldOperations;
128 //=============================================================================
132 //=============================================================================
133 Handle(GEOM_Object) GEOMImpl_IInsertOperations::MakeCopy (Handle(GEOM_Object) theOriginal)
137 if (theOriginal.IsNull()) return NULL;
139 //Add a new Copy object
140 Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
142 //Add a Copy function for creation a copy object
143 Handle(GEOM_Function) aFunction = aCopy->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITH_REF);
145 //Check if the function is set correctly
146 if(aFunction->GetDriverGUID() != GEOMImpl_CopyDriver::GetID()) return NULL;
148 GEOMImpl_ICopy aCI(aFunction);
150 Handle(GEOM_Function) aRefFunction = theOriginal->GetLastFunction();
151 if (aRefFunction.IsNull()) return NULL;
153 aCI.SetOriginal(aRefFunction);
155 //Compute the Copy value
157 #if OCC_VERSION_LARGE > 0x06010000
160 if (!GetSolver()->ComputeFunction(aFunction)) {
161 SetErrorCode("Copy driver failed");
165 catch (Standard_Failure) {
166 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
167 SetErrorCode(aFail->GetMessageString());
171 //Make a Python command
172 GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeCopy(" << theOriginal << ")";
178 //=============================================================================
182 //=============================================================================
183 void GEOMImpl_IInsertOperations::Export
184 (const Handle(GEOM_Object) theOriginal,
185 const TCollection_AsciiString& theFileName,
186 const TCollection_AsciiString& theFormatName)
190 if (theOriginal.IsNull()) return;
192 Handle(GEOM_Function) aRefFunction = theOriginal->GetLastFunction();
193 if (aRefFunction.IsNull()) return; //There is no function which creates an object to be exported
195 //Add a new result object
196 Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
198 //Add an Export function
199 Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_ExportDriver::GetID(), EXPORT_SHAPE);
200 if (aFunction.IsNull()) return;
202 //Check if the function is set correctly
203 if (aFunction->GetDriverGUID() != GEOMImpl_ExportDriver::GetID()) return;
205 Handle(TCollection_HAsciiString) aHLibName;
206 if (!IsSupported(Standard_False, theFormatName, aHLibName)) {
209 TCollection_AsciiString aLibName = aHLibName->String();
212 GEOMImpl_IImportExport aCI (aFunction);
213 aCI.SetOriginal(aRefFunction);
214 aCI.SetFileName(theFileName);
215 aCI.SetFormatName(theFormatName);
216 aCI.SetPluginName(aLibName);
220 #if OCC_VERSION_LARGE > 0x06010000
223 if (!GetSolver()->ComputeFunction(aFunction)) {
224 SetErrorCode("Not enough space on disk, or you haven't permissions to write this directory");
228 catch (Standard_Failure) {
229 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
230 SetErrorCode(aFail->GetMessageString());
234 //Make a Python command
235 GEOM::TPythonDump(aFunction) << "geompy.Export(" << theOriginal << ", \""
236 << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";
241 //=============================================================================
245 //=============================================================================
246 Handle(TColStd_HSequenceOfTransient) GEOMImpl_IInsertOperations::Import
247 (const TCollection_AsciiString& theFileName,
248 const TCollection_AsciiString& theFormatName)
252 if (theFileName.IsEmpty() || theFormatName.IsEmpty()) return NULL;
254 //Add a new result object
255 Handle(GEOM_Object) anImported = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
257 //Add an Import function
258 Handle(GEOM_Function) aFunction =
259 anImported->AddFunction(GEOMImpl_ImportDriver::GetID(), IMPORT_SHAPE);
261 if (aFunction.IsNull()) return NULL;
263 //Check if the function is set correctly
264 if (aFunction->GetDriverGUID() != GEOMImpl_ImportDriver::GetID()) return NULL;
266 Handle(TCollection_HAsciiString) aHLibName;
268 (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
271 TCollection_AsciiString aLibName = aHLibName->String();
274 GEOMImpl_IImportExport aCI (aFunction);
275 aCI.SetFileName(theFileName);
276 aCI.SetFormatName(theFormatName);
277 aCI.SetPluginName(aLibName);
280 Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
283 #if OCC_VERSION_LARGE > 0x06010000
286 if (!GetSolver()->ComputeFunction(aFunction)) {
287 SetErrorCode("Import driver failed");
291 aSeq->Append(anImported);
293 // Greate material groups.
294 MakeMaterialGroups(anImported, aSeq);
296 catch (Standard_Failure) {
297 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
298 SetErrorCode(aFail->GetMessageString());
302 //Make a Python command
303 if (theFormatName != "IGES_UNIT") {
304 GEOM::TPythonDump pd (aFunction);
305 if (theFormatName == "BREP")
306 pd << anImported << " = geompy.ImportBREP(\"" << theFileName.ToCString() << "\")";
307 else if (theFormatName == "IGES")
308 pd << anImported << " = geompy.ImportIGES(\"" << theFileName.ToCString() << "\")";
309 else if (theFormatName == "IGES_SCALE")
310 pd << anImported << " = geompy.ImportIGES(\"" << theFileName.ToCString() << "\", True)";
311 else if (theFormatName == "STEP")
312 pd << anImported << " = geompy.ImportSTEP(\"" << theFileName.ToCString() << "\")";
313 else if (theFormatName == "STEP_SCALE")
314 pd << anImported << " = geompy.ImportSTEP(\"" << theFileName.ToCString() << "\", True)";
316 pd << anImported << " = geompy.ImportFile(\""
317 << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";
324 if (theFormatName == "IGES_UNIT") {
325 TopoDS_Shape S = aFunction->GetValue();
326 TopoDS_Vertex V = TopoDS::Vertex(S);
327 gp_Pnt P = BRep_Tool::Pnt(V);
328 double scale = P.X();
329 TCollection_AsciiString aUnitName = "UNIT_M";
330 if (fabs(scale-0.01) < 1.e-6)
331 aUnitName = "UNIT_CM";
332 else if (fabs(scale-0.001) < 1.e-6)
333 aUnitName = "UNIT_MM";
334 //cout<<"IIO: aUnitName = "<<aUnitName.ToCString()<<endl;
335 SetErrorCode(aUnitName);
342 //=============================================================================
346 //=============================================================================
347 TCollection_AsciiString GEOMImpl_IInsertOperations::ReadValue
348 (const TCollection_AsciiString& theFileName,
349 const TCollection_AsciiString& theFormatName,
350 const TCollection_AsciiString& theParameterName)
354 TCollection_AsciiString aValue, anError;
356 if (theFileName.IsEmpty() || theFormatName.IsEmpty() || theParameterName.IsEmpty()) return aValue;
358 Handle(TCollection_HAsciiString) aHLibName;
360 (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
363 TCollection_AsciiString aLibName = aHLibName->String();
365 aValue = GEOMImpl_ImportDriver::ReadValue(theFileName, aLibName, theParameterName, anError);
366 if (anError.IsEmpty())
369 SetErrorCode(anError.ToCString());
374 //=============================================================================
378 //=============================================================================
379 Standard_Boolean GEOMImpl_IInsertOperations::ImportTranslators
380 (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
381 Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
383 if (theFormats.IsNull())
384 theFormats = new TColStd_HSequenceOfAsciiString;
388 if (thePatterns.IsNull())
389 thePatterns = new TColStd_HSequenceOfAsciiString;
391 thePatterns->Clear();
393 if (!InitResMgr()) return Standard_False;
395 // Read Import formats from directories
396 Handle(Resource_Manager) aResMgr;
397 Handle(TColStd_HSequenceOfAsciiString) aFormatsToAdd;
398 for(int index = 0; index < myResMgrList.size(); index++) {
399 int anOldLen = theFormats->Length();
400 aResMgr = myResMgrList.at(index);
401 if (aResMgr->Find("Import")) {
402 TCollection_AsciiString aFormats (aResMgr->Value("Import"));
403 TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
404 for (int i = 1; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
405 int aLenFormats = theFormats->Length();
406 bool isFound = false;
407 for(int aInd=1;aInd<=aLenFormats;aInd++){
408 if( theFormats->Value(aInd) == aToken ){
414 theFormats->Append(aToken);
418 // Read Patterns for each supported format
419 for (int j = anOldLen+1; j <= theFormats->Length(); j++) {
420 TCollection_AsciiString aKey, aPattern;
421 aKey = theFormats->Value(j) + ".ImportPattern";
422 if (aResMgr->Find(aKey.ToCString()))
423 aPattern = aResMgr->Value(aKey.ToCString());
425 aKey = theFormats->Value(j) + ".Pattern";
426 if (aResMgr->Find(aKey.ToCString()))
427 aPattern = aResMgr->Value(aKey.ToCString());
429 aPattern = theFormats->Value(j);
430 aPattern += " Files ( *.* )";
433 thePatterns->Append(aPattern);
437 return (!theFormats->IsEmpty());
440 //=============================================================================
444 //=============================================================================
445 Standard_Boolean GEOMImpl_IInsertOperations::ExportTranslators
446 (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
447 Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
449 if (theFormats.IsNull())
450 theFormats = new TColStd_HSequenceOfAsciiString;
454 if (thePatterns.IsNull())
455 thePatterns = new TColStd_HSequenceOfAsciiString;
457 thePatterns->Clear();
459 if (!InitResMgr()) return Standard_False;
461 // Read Export formats list from directories
462 Handle(Resource_Manager) aResMgr;
463 for(int index=0; index < myResMgrList.size(); index++) {
464 int anOldLen = theFormats->Length();
465 aResMgr = myResMgrList.at(index);
466 if (aResMgr->Find("Export")) {
467 TCollection_AsciiString aFormats (aResMgr->Value("Export"));
468 TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
469 for (int i = 1; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
470 int aLenFormats = theFormats->Length();
471 bool isFound = false;
472 for(int aInd=1;aInd<=aLenFormats;aInd++){
473 if( theFormats->Value(aInd) == aToken){
479 theFormats->Append(aToken);
483 // Read Patterns for each supported format
484 for (int j = anOldLen+1; j <= theFormats->Length(); j++) {
485 TCollection_AsciiString aKey, aPattern;
486 aKey = theFormats->Value(j) + ".ExportPattern";
487 if (aResMgr->Find(aKey.ToCString()))
488 aPattern = aResMgr->Value(aKey.ToCString());
490 aKey = theFormats->Value(j) + ".Pattern";
491 if (aResMgr->Find(aKey.ToCString()))
492 aPattern = aResMgr->Value(aKey.ToCString());
494 aPattern = theFormats->Value(j);
495 aPattern += " Files ( *.* )";
498 thePatterns->Append(aPattern);
502 return (!theFormats->IsEmpty());
505 //=============================================================================
509 //=============================================================================
510 Standard_Boolean GEOMImpl_IInsertOperations::IsSupported
511 (const Standard_Boolean isImport,
512 const TCollection_AsciiString& theFormat,
513 Handle(TCollection_HAsciiString)& theLibName)
515 if (!InitResMgr()) return Standard_False;
517 // Import/Export mode
518 TCollection_AsciiString aMode;
519 //Standard_CString aMode;
520 if (isImport) aMode = "Import";
521 else aMode = "Export";
523 // Read supported formats for the certain mode from user directory
524 Handle(Resource_Manager) aResMgr;
525 for(int index=0; index < myResMgrList.size(); index++) {
526 aResMgr = myResMgrList.at(index);
527 if (aResMgr->Find(aMode.ToCString())) {
528 TCollection_AsciiString aFormats (aResMgr->Value(aMode.ToCString()));
529 if (aFormats.Search(theFormat) > -1) {
530 // Read library name for the supported format
531 TCollection_AsciiString aKey (theFormat);
534 if (aResMgr->Find(aKey.ToCString())) {
535 TCollection_AsciiString aLibName (aResMgr->Value(aKey.ToCString()));
537 if ( aLibName.Length() > 3 && aLibName.SubString(1,3) != "lib" )
538 aLibName.Prepend("lib");
543 theLibName = new TCollection_HAsciiString (aLibName);
544 return Standard_True;
550 return Standard_False;
553 //=============================================================================
557 //=============================================================================
558 Standard_Boolean GEOMImpl_IInsertOperations::InitResMgr()
560 bool isResourceFound = false;
561 TCollection_AsciiString aNull;
563 myResMgrList.clear();
565 // Initialize the GEOM Resource Manager
566 TCollection_AsciiString aResDir = TCollection_AsciiString(getenv("GEOM_ROOT_DIR"));
568 aResDir += "\\share\\salome\\resources\\geom";
570 aResDir += "/share/salome/resources/geom";
572 Handle(Resource_Manager) aGeomResMgr = new Resource_Manager ("ImportExport", aResDir, aNull, Standard_False);
573 if ( aGeomResMgr->Find("Import") || aGeomResMgr->Find("Export") ) {
574 myResMgrList.push_back( aGeomResMgr );
575 isResourceFound = true;
578 // Initialize the user's Resource Manager
579 TCollection_AsciiString aResDirsStr = getenv("GEOM_ENGINE_RESOURCES_DIR");
580 if ( !aResDirsStr.IsEmpty() )
582 std::string aSep = ":";
586 aResDir = aResDirsStr.Token(aSep.c_str(), 1);
587 for (int i = 1; !aResDir.IsEmpty(); aResDir = aResDirsStr.Token(aSep.c_str(), ++i)) {
588 Handle(Resource_Manager) anUserResMgr = new Resource_Manager ("ImportExport", aNull, aResDir, Standard_False);
589 if (anUserResMgr->Find("Import") || anUserResMgr->Find("Export")) {
590 myResMgrList.push_back( anUserResMgr );
591 isResourceFound = true;
597 aResDir = getenv("HOME");
599 aResDir += "\\.config\\salome";
601 aResDir += "/.config/salome";
603 Handle(Resource_Manager) anUserResMgr = new Resource_Manager ("ImportExport", aNull, aResDir, Standard_False);
604 if (anUserResMgr->Find("Import") || anUserResMgr->Find("Export")) {
605 myResMgrList.push_back( anUserResMgr );
606 isResourceFound = true;
609 return isResourceFound;
612 //=============================================================================
616 //=============================================================================
617 Handle(GEOM_Object) GEOMImpl_IInsertOperations::RestoreShape (std::istringstream& theStream)
621 //Add a new result object
622 Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
624 //Add a Copy function
625 Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF);
626 if (aFunction.IsNull()) return NULL;
628 //Check if the function is set correctly
629 if (aFunction->GetDriverGUID() != GEOMImpl_CopyDriver::GetID()) return NULL;
631 //Read a shape from the stream
634 BRepTools::Read(aShape, theStream, B);
635 if (aShape.IsNull()) {
636 SetErrorCode("RestoreShape error: BREP reading failed");
640 aFunction->SetValue(aShape);
642 //Special dump to avoid restored shapes publication.
643 //See correcponding code in GEOM_Engine.cxx (method ProcessFunction)
644 //GEOM::TPythonDump(aFunction) << "#";
646 GEOM::TPythonDump(aFunction) << result
647 << " = geompy.RestoreShape(\"\") # the shape string has not been dump for performance reason";
654 int GEOMImpl_IInsertOperations::LoadTexture(const TCollection_AsciiString& theTextureFile)
658 if (theTextureFile.IsEmpty()) return 0;
660 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
661 Handle(TColStd_HArray1OfByte) aTexture;
663 Handle(TDataStd_HArray1OfByte) aTexture;
666 FILE* fp = fopen(theTextureFile.ToCString(), "r");
669 std::list<std::string> lines;
673 if ((fgets(buffer, 4096, fp)) == NULL) break;
674 int aLen = strlen(buffer);
675 if (buffer[aLen-1] == '\n') buffer[aLen-1] = '\0';
676 lines.push_back(buffer);
677 maxlen = std::max(maxlen, (int)strlen(buffer));
682 int lenbytes = maxlen/8;
683 if (maxlen%8) lenbytes++;
685 if (lenbytes == 0 || lines.empty())
688 std::list<unsigned char> bytedata;
689 std::list<std::string>::const_iterator it;
690 for (it = lines.begin(); it != lines.end(); ++it) {
691 std::string line = *it;
692 int lenline = (line.size()/8 + (line.size()%8 ? 1 : 0)) * 8;
693 for (int i = 0; i < lenline/8; i++) {
694 unsigned char byte = 0;
695 for (int j = 0; j < 8; j++)
696 byte = (byte << 1) + ( i*8+j < line.size() && line[i*8+j] != '0' ? 1 : 0 );
697 bytedata.push_back(byte);
699 for (int i = lenline/8; i < lenbytes; i++)
700 bytedata.push_back((unsigned char)0);
703 if (bytedata.empty() || bytedata.size() != lines.size()*lenbytes)
706 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
707 aTexture = new TColStd_HArray1OfByte (1, lines.size()*lenbytes);
709 aTexture = new TDataStd_HArray1OfByte (1, lines.size()*lenbytes);
712 std::list<unsigned char>::iterator bdit;
714 for (i = 1, bdit = bytedata.begin(); bdit != bytedata.end(); ++bdit, ++i)
715 aTexture->SetValue(i, (Standard_Byte)(*bdit));
717 int aTextureId = GetEngine()->addTexture(GetDocID(), lenbytes*8, lines.size(), aTexture, theTextureFile);
718 if (aTextureId > 0) SetErrorCode(OK);
722 int GEOMImpl_IInsertOperations::AddTexture(int theWidth, int theHeight,
723 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
724 const Handle(TColStd_HArray1OfByte)& theTexture)
726 const Handle(TDataStd_HArray1OfByte)& theTexture)
730 int aTextureId = GetEngine()->addTexture(GetDocID(), theWidth, theHeight, theTexture);
731 if (aTextureId > 0) SetErrorCode(OK);
735 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
736 Handle(TColStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
738 Handle(TDataStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
740 int& theWidth, int& theHeight)
744 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
745 Handle(TColStd_HArray1OfByte) aTexture;
747 Handle(TDataStd_HArray1OfByte) aTexture;
750 theWidth = theHeight = 0;
751 TCollection_AsciiString aFileName;
753 if (theTextureId <= 0)
756 aTexture = GetEngine()->getTexture(GetDocID(), theTextureId, theWidth, theHeight, aFileName);
758 if (theWidth > 0 && theHeight > 0 && aTexture->Length() > 0) SetErrorCode(OK);
763 std::list<int> GEOMImpl_IInsertOperations::GetAllTextures()
766 std::list<int> id_list = GetEngine()->getAllTextures(GetDocID());
771 TopAbs_ShapeEnum getGroupDimension(XAO::Group* group)
773 XAO::Dimension dim = group->getDimension();
774 TopAbs_ShapeEnum rdim;
778 rdim = TopAbs_VERTEX; break;
780 rdim = TopAbs_EDGE; break;
782 rdim = TopAbs_FACE; break;
784 rdim = TopAbs_SOLID; break;
786 rdim = TopAbs_COMPOUND; break;
791 XAO::Dimension shapeEnumToDimension(const TopAbs_ShapeEnum& shape)
796 dim = XAO::VERTEX; break;
798 dim = XAO::EDGE; break;
800 dim = XAO::FACE; break;
802 dim = XAO::SOLID; break;
804 throw SALOME_Exception("Bad type"); // TODO
809 void GEOMImpl_IInsertOperations::exportGroups(std::list<Handle(GEOM_Object)> groupList,
811 XAO::BrepGeometry* geometry)
814 std::list<Handle(GEOM_Object)>::iterator groupIterator = groupList.begin();
815 while (groupIterator != groupList.end())
817 Handle(GEOM_Object) currGroup = (*groupIterator++);
818 Handle(TColStd_HArray1OfInteger) groupIds = myGroupOperations->GetObjects(currGroup);
820 TopAbs_ShapeEnum shapeGroup = myGroupOperations->GetType(currGroup);
821 XAO::Dimension dim = shapeEnumToDimension(shapeGroup);
822 XAO::Group* group = xaoObject->addGroup(dim, currGroup->GetName().ToCString());
827 for (int i = 1; i <= groupIds->Length(); i++)
829 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
830 int index = geometry->getVertexIndexByReference(ref);
835 for (int i = 1; i <= groupIds->Length(); i++)
837 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
838 int index = geometry->getEdgeIndexByReference(ref);
843 for (int i = 1; i <= groupIds->Length(); i++)
845 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
846 int index = geometry->getFaceIndexByReference(ref);
851 for (int i = 1; i <= groupIds->Length(); i++)
853 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
854 int index = geometry->getSolidIndexByReference(ref);
862 void GEOMImpl_IInsertOperations::exportFields(std::list<Handle(GEOM_Field)> fieldList,
864 XAO::BrepGeometry* geometry)
866 std::list<Handle(GEOM_Field)>::iterator fieldIterator = fieldList.begin();
867 while (fieldIterator != fieldList.end())
869 Handle(GEOM_Field) currField = (*fieldIterator++);
871 int fdim = currField->GetDimension();
872 int ftype = currField->GetDataType();
873 int nbComponents = currField->GetNbComponents();
874 std::string name = currField->GetName().ToCString();
876 XAO::Field* field = xaoObject->addField((XAO::Type)ftype, (XAO::Dimension)fdim, nbComponents, name);
878 Handle(TColStd_HArray1OfExtendedString) components = currField->GetComponents();
879 for (int i = components->Lower(), j = 0; i <= components->Upper(); ++i, ++j)
881 field->setComponentName(j, TCollection_AsciiString(components->Value(i)).ToCString());
884 std::list< Handle(GEOM_FieldStep)> steps = currField->GetSteps();
885 std::list<Handle(GEOM_FieldStep)>::iterator stepIterator = steps.begin();
886 while (stepIterator != steps.end())
888 Handle(GEOM_FieldStep) currStep = (*stepIterator++);
890 XAO::Step* step = field->addNewStep(currStep->GetID());
891 step->setStamp(currStep->GetStamp());
897 XAO::BooleanStep* bs = (XAO::BooleanStep*)step;
898 Handle(TColStd_HArray1OfInteger) bvalues = currStep->GetIntValues();
899 std::vector<bool> bv;
900 bv.reserve(bvalues->Upper());
901 for ( int i = bvalues->Lower(), nb = bvalues->Upper(); i <= nb; ++i )
903 bv.push_back(bvalues->Value(i) != 0);
910 XAO::IntegerStep* is = (XAO::IntegerStep*)step;
911 Handle(TColStd_HArray1OfInteger) ivalues = currStep->GetIntValues();
913 iv.reserve(ivalues->Upper());
914 for ( int i = ivalues->Lower(), nb = ivalues->Upper(); i <= nb; ++i )
916 iv.push_back(ivalues->Value(i));
923 XAO::DoubleStep* ds = (XAO::DoubleStep*)step;
924 Handle(TColStd_HArray1OfReal) dvalues = currStep->GetDoubleValues();
925 std::vector<double> dv;
926 dv.reserve(dvalues->Upper());
927 for ( int i = dvalues->Lower(), nb = dvalues->Upper(); i <= nb; ++i )
929 dv.push_back(dvalues->Value(i));
936 XAO::StringStep* ss = (XAO::StringStep*)step;
937 Handle(TColStd_HArray1OfExtendedString) svalues = currStep->GetStringValues();
938 std::vector<std::string> sv;
939 sv.reserve(svalues->Upper());
940 for ( int i = svalues->Lower(), nb = svalues->Upper(); i <= nb; ++i )
942 sv.push_back(TCollection_AsciiString(svalues->Value(i)).ToCString());
952 void GEOMImpl_IInsertOperations::exportSubshapes(const Handle(GEOM_Object)& shape, XAO::BrepGeometry* geometry)
954 Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects(shape, false);
955 int nbSubObjects = subObjects->Length();
956 // set the names of the sub shapes
957 for (int i = 1; i <= nbSubObjects; i++)
959 Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
960 if (transientSubObject.IsNull())
963 Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast(transientSubObject);
964 if (subObject->GetType() != GEOM_GROUP)
966 int subIndex = myShapesOperations->GetSubShapeIndex(shape, subObject);
967 switch (subObject->GetValue().ShapeType())
970 geometry->changeVertexName(subIndex, subObject->GetName().ToCString());
973 geometry->changeEdgeName(subIndex, subObject->GetName().ToCString());
976 geometry->changeFaceName(subIndex, subObject->GetName().ToCString());
979 geometry->changeSolidName(subIndex, subObject->GetName().ToCString());
986 //=============================================================================
988 * Export a shape to XAO format
989 * \param shape The shape to export
990 * \param groups The list of groups to export
991 * \param fields The list of fields to export
992 * \param fileName The name of the file to exported
993 * \return boolean indicating if export was succeful.
995 //=============================================================================
996 bool GEOMImpl_IInsertOperations::ExportXAO(Handle(GEOM_Object) shape,
997 std::list<Handle(GEOM_Object)> groupList,
998 std::list<Handle(GEOM_Field)> fieldList,
1000 const char* fileName)
1004 if (shape.IsNull()) return false;
1006 // add a new shape function with parameters
1007 Handle(GEOM_Function) lastFunction = shape->GetLastFunction();
1008 if (lastFunction.IsNull()) return false;
1010 // add a new result object
1011 Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
1013 // add an Export function
1014 Handle(GEOM_Function) exportFunction = result->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
1015 if (exportFunction.IsNull()) return false;
1016 if (exportFunction->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
1018 // create the XAO object
1019 XAO::Xao* xaoObject = new XAO::Xao();
1020 xaoObject->setAuthor(author);
1023 XAO::BrepGeometry* geometry = (XAO::BrepGeometry*)XAO::Geometry::createGeometry(XAO::BREP);
1024 TopoDS_Shape topoShape = shape->GetValue();
1025 exportFunction->SetValue(topoShape);
1026 XAO::BrepGeometry* brep = (XAO::BrepGeometry*)geometry;
1027 brep->setTopoDS_Shape(topoShape);
1029 geometry->setName(shape->GetName().ToCString());
1030 exportSubshapes(shape, geometry);
1031 xaoObject->setGeometry(geometry);
1033 exportGroups(groupList, xaoObject, geometry);
1034 exportFields(fieldList, xaoObject, geometry);
1036 // export the XAO to the file
1037 xaoObject->exportXAO(fileName);
1039 // make a Python command
1040 GEOM::TPythonDump pd(exportFunction);
1041 pd << "exported = geompy.ExportXAO(" << shape;
1045 if (groupList.size() > 0)
1047 std::list<Handle(GEOM_Object)>::iterator itGroup = groupList.begin();
1049 while (itGroup != groupList.end())
1051 pd << ", " << (*itGroup++);
1057 if (fieldList.size() > 0)
1059 std::list<Handle(GEOM_Field)>::iterator itField = fieldList.begin();
1061 while (itField != fieldList.end())
1063 pd << ", " << (*itField++);
1067 pd << "\"" << author << "\", \"" << fileName << "\")";
1075 void GEOMImpl_IInsertOperations::importSubShapes(XAO::Geometry* xaoGeometry,
1076 Handle(GEOM_Function) function, int shapeType, int dim,
1077 Handle(TColStd_HSequenceOfTransient)& subShapeList)
1079 Handle(GEOM_Object) subShape;
1080 Handle(GEOM_Function) aFunction;
1081 Handle(TColStd_HArray1OfInteger) anArray;
1083 XAO::GeometricElementList::iterator elementIterator = xaoGeometry->begin((XAO::Dimension)dim);
1084 for (; elementIterator != xaoGeometry->end((XAO::Dimension)dim); elementIterator++)
1086 XAO::GeometricElement element = elementIterator->second;
1087 if (!element.hasName())
1090 std::string name = element.getName();
1091 std::string ref = element.getReference();
1092 int iref = XAO::XaoUtils::stringToInt(ref);
1094 anArray = new TColStd_HArray1OfInteger(1, 1);
1095 anArray->SetValue(1, iref);
1097 subShape = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
1098 Handle(GEOM_Function) aFunction = subShape->AddFunction(GEOM_Object::GetSubShapeID(), 1);
1099 if (aFunction.IsNull())
1102 subShape->SetName(name.c_str());
1103 subShape->SetType(shapeType);
1105 GEOM_ISubShape aSSI(aFunction);
1106 aSSI.SetMainShape(function);
1107 aSSI.SetIndices(anArray);
1109 //aFunction->SetValue(aValue);
1110 subShapeList->Append(subShape);
1112 // Put this subshape in the list of sub-shapes of theMainShape
1113 function->AddSubShapeReference(aFunction);
1117 //=============================================================================
1119 * Import a shape from XAO format
1120 * \param fileName The name of the file to import
1121 * \param shape The imported shape
1122 * \param subShapes The list of imported groups
1123 * \param groups The list of imported groups
1124 * \param fields The list of imported fields
1125 * \return boolean indicating if import was succeful.
1127 //=============================================================================
1128 bool GEOMImpl_IInsertOperations::ImportXAO(const char* fileName,
1129 Handle(GEOM_Object)& shape,
1130 Handle(TColStd_HSequenceOfTransient)& subShapes,
1131 Handle(TColStd_HSequenceOfTransient)& groups,
1132 Handle(TColStd_HSequenceOfTransient)& fields)
1136 if (fileName == NULL || groups.IsNull() || fields.IsNull())
1140 XAO::Xao* xaoObject = new XAO::Xao();
1143 xaoObject->importXAO(fileName);
1145 catch (XAO::XAO_Exception& exc)
1148 SetErrorCode(exc.what());
1152 XAO::Geometry* xaoGeometry = xaoObject->getGeometry();
1153 if (xaoGeometry == NULL)
1156 SetErrorCode("Cannot import XAO: geometry format not supported.");
1161 shape = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
1162 Handle(GEOM_Function) function = shape->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
1163 if (function.IsNull()) return false;
1164 if (function->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
1167 if (xaoGeometry->getFormat() == XAO::BREP)
1169 XAO::BrepGeometry* brep = (XAO::BrepGeometry*)xaoGeometry;
1170 TopoDS_Shape geomShape = brep->getTopoDS_Shape();
1171 function->SetValue(geomShape);
1172 shape->SetName(xaoGeometry->getName().c_str());
1177 SetErrorCode("Cannot import XAO: geometry format not supported.");
1181 // create sub shapes with names
1182 importSubShapes(xaoGeometry, function, GEOM_POINT, XAO::VERTEX, subShapes);
1183 importSubShapes(xaoGeometry, function, GEOM_EDGE, XAO::EDGE, subShapes);
1184 importSubShapes(xaoGeometry, function, GEOM_FACE, XAO::FACE, subShapes);
1185 importSubShapes(xaoGeometry, function, GEOM_SOLID, XAO::SOLID, subShapes);
1188 int nbGroups = xaoObject->countGroups();
1189 for (int i = 0; i < nbGroups; ++i)
1191 XAO::Group* xaoGroup = xaoObject->getGroup(i);
1193 // build an array with the indexes of the sub shapes
1194 int nbElt = xaoGroup->count();
1195 Handle(TColStd_HArray1OfInteger) array = new TColStd_HArray1OfInteger(1, nbElt);
1197 for (std::set<int>::iterator it = xaoGroup->begin(); it != xaoGroup->end(); ++it)
1200 std::string ref = xaoGeometry->getElementReference(xaoGroup->getDimension(), index);
1201 array->SetValue(++j, XAO::XaoUtils::stringToInt(ref));
1204 // create the group with the array of sub shapes indexes
1205 Handle(GEOM_Object) group = GetEngine()->AddSubShape(shape, array);
1206 group->SetType(GEOM_GROUP);
1207 group->SetName(xaoGroup->getName().c_str());
1209 // Set a sub-shape type
1210 TDF_Label freeLabel = group->GetFreeLabel();
1211 TDataStd_Integer::Set(freeLabel, (Standard_Integer) getGroupDimension(xaoGroup));
1212 groups->Append(group);
1214 function = group->GetLastFunction();
1217 // create the fields
1218 int nbFields = xaoObject->countFields();
1219 for (int i = 0; i < nbFields; ++i)
1221 XAO::Field* xaoField = xaoObject->getField(i);
1223 Handle(TColStd_HArray1OfExtendedString) components = new TColStd_HArray1OfExtendedString(0, xaoField->countComponents()-1);
1224 for (int j = 0; j < xaoField->countComponents(); ++j)
1226 components->SetValue(j, (TCollection_ExtendedString)xaoField->getComponentName(j).c_str());
1229 Handle(GEOM_Field) field = myFieldOperations->CreateField(shape,
1230 xaoField->getName().c_str(),
1231 (int)xaoField->getType(),
1232 (int)xaoField->getDimension(),
1235 switch (xaoField->getType())
1239 XAO::BooleanField* bfield = (XAO::BooleanField*)xaoField;
1240 for (int j = 0; j < xaoField->countSteps(); ++j)
1242 XAO::BooleanStep* bstep = bfield->getStep(j);
1243 Handle(GEOM_FieldStep) step = field->AddStep(bstep->getStep(), bstep->getStamp());
1245 Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, bstep->countValues()-1);
1246 std::vector<bool> bvalues = bstep->getValues();
1247 for (int k = 0; k < bstep->countValues(); ++k)
1249 values->SetValue(k, bvalues[k] ? 1 : 0);
1251 step->SetValues(values);
1257 XAO::IntegerField* ifield = (XAO::IntegerField*)xaoField;
1258 for (int j = 0; j < xaoField->countSteps(); ++j)
1260 XAO::IntegerStep* istep = ifield->getStep(j);
1261 Handle(GEOM_FieldStep) step = field->AddStep(istep->getStep(), istep->getStamp());
1263 Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, istep->countValues()-1);
1264 std::vector<int> ivalues = istep->getValues();
1265 for (int k = 0; k < istep->countValues(); ++k)
1267 values->SetValue(k, ivalues[k]);
1269 step->SetValues(values);
1275 XAO::DoubleField* dfield = (XAO::DoubleField*)xaoField;
1276 for (int j = 0; j < xaoField->countSteps(); ++j)
1278 XAO::DoubleStep* dstep = dfield->getStep(j);
1279 Handle(GEOM_FieldStep) step = field->AddStep(dstep->getStep(), dstep->getStamp());
1281 Handle(TColStd_HArray1OfReal) values = new TColStd_HArray1OfReal(0, dstep->countValues()-1);
1282 std::vector<double> dvalues = dstep->getValues();
1283 for (int k = 0; k < dstep->countValues(); ++k)
1285 values->SetValue(k, dvalues[k]);
1287 step->SetValues(values);
1293 XAO::StringField* sfield = (XAO::StringField*)xaoField;
1294 for (int j = 0; j < xaoField->countSteps(); ++j)
1296 XAO::StringStep* sstep = sfield->getStep(j);
1297 Handle(GEOM_FieldStep) step = field->AddStep(sstep->getStep(), sstep->getStamp());
1299 Handle(TColStd_HArray1OfExtendedString) values = new TColStd_HArray1OfExtendedString(0, sstep->countValues()-1);
1300 std::vector<std::string> svalues = sstep->getValues();
1301 for (int k = 0; k < sstep->countValues(); ++k)
1303 values->SetValue(k, TCollection_ExtendedString(svalues[k].c_str()));
1305 step->SetValues(values);
1311 fields->Append(field);
1314 // make a Python command
1315 GEOM::TPythonDump pd(function);
1316 pd << "(imported, " << shape << ", ";
1318 // list of sub shapes
1320 int nbSubshapes = subShapes->Length();
1321 if (nbSubshapes > 0)
1323 for (int i = 1; i <= nbSubshapes; i++)
1325 Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(subShapes->Value(i));
1326 pd << obj << ((i < nbSubshapes) ? ", " : "");
1334 for (int i = 1; i <= nbGroups; i++)
1336 Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(groups->Value(i));
1337 pd << obj << ((i < nbGroups) ? ", " : "");
1346 for (int i = 1; i <= nbFields; i++)
1348 Handle(GEOM_Field) obj = Handle(GEOM_Field)::DownCast(fields->Value(i));
1349 pd << obj << ((i < nbFields) ? ", " : "");
1353 pd << ") = geompy.ImportXAO(\"" << fileName << "\")";
1361 //=============================================================================
1363 * This method creates material groups for an imported object.
1364 * \param theObject the imported object.
1366 //=============================================================================
1367 void GEOMImpl_IInsertOperations::MakeMaterialGroups
1368 (const Handle(GEOM_Object) &theObject,
1369 const Handle(TColStd_HSequenceOfTransient) &theSeq)
1371 TopoDS_Shape aResShape = theObject->GetValue();
1373 if (aResShape.IsNull() == Standard_False) {
1374 // Group shapes by material names.
1375 Handle(GEOM_Function) aFunction = theObject->GetLastFunction();
1376 DataMapOfStringListOfShape aMapMaterialShapes;
1378 // check all named shapes using iterator
1379 TDF_ChildIDIterator anIt (aFunction->GetNamingEntry(),
1380 TNaming_NamedShape::GetID(), Standard_True);
1382 for (; anIt.More(); anIt.Next()) {
1383 Handle(TNaming_NamedShape) anAttr =
1384 Handle(TNaming_NamedShape)::DownCast(anIt.Value());
1386 if (anAttr.IsNull() == Standard_False) {
1387 TDF_Label aLabel = anAttr->Label();
1388 Handle(TDataStd_Comment) aComment;
1390 if (aLabel.FindAttribute(TDataStd_Comment::GetID(), aComment)) {
1391 TCollection_ExtendedString aMatName = aComment->Get();
1392 TopoDS_Shape aShape = anAttr->Get();
1394 if (aMapMaterialShapes.IsBound(aMatName) == Standard_False) {
1395 NCollection_List<TopoDS_Shape> anEmptyList;
1397 aMapMaterialShapes.Bind(aMatName, anEmptyList);
1400 aMapMaterialShapes(aMatName).Append(aShape);
1405 if (aMapMaterialShapes.IsEmpty() == Standard_False) {
1406 // Construct groups.
1407 TopAbs_ShapeEnum aType = aResShape.ShapeType();
1409 DataMapOfStringListOfShape::Iterator aMapIter;
1411 // Check each shape type.
1412 for(i = aType; i <= TopAbs_VERTEX; i++) {
1413 DataMapOfStringListOfShape::Iterator aMapIter(aMapMaterialShapes);
1415 for (; aMapIter.More(); aMapIter.Next()) {
1416 NCollection_List<TopoDS_Shape> &aShList = aMapIter.ChangeValue();
1417 NCollection_List<TopoDS_Shape>::Iterator aShIter(aShList);
1418 NCollection_List<TopoDS_Shape> aShListSameType;
1420 while (aShIter.More()) {
1421 const TopoDS_Shape &aShape = aShIter.Value();
1423 if (i == aShape.ShapeType()) {
1424 // Treat this element.
1425 aShListSameType.Append(aShape);
1426 aShList.Remove(aShIter);
1428 // Go to the next element.
1433 if (aShListSameType.IsEmpty() == Standard_False) {
1434 // Construct a group.
1435 Handle(GEOM_Object) aGroup =
1436 MakeGroup(theObject, aMapIter.Key(), aShListSameType);
1438 if (aGroup.IsNull() == Standard_False) {
1439 theSeq->Append(aGroup);
1449 //=============================================================================
1451 * This method creates a group of shapes of certain type.
1452 * \param theObject the imported object.
1453 * \param theName the material name.
1454 * \param theShapes the list of shapes to be added to this group.
1455 * \return the created group.
1457 //=============================================================================
1458 Handle(GEOM_Object) GEOMImpl_IInsertOperations::MakeGroup
1459 (const Handle(GEOM_Object) &theObject,
1460 const TCollection_ExtendedString &theName,
1461 const NCollection_List<TopoDS_Shape> &theShapes)
1463 Handle(GEOM_Object) aGroup;
1464 TopTools_IndexedMapOfShape anIndices;
1465 Handle(TColStd_HSequenceOfInteger) aSeqIDs = new TColStd_HSequenceOfInteger;
1466 NCollection_List<TopoDS_Shape>::Iterator anIter(theShapes);
1468 TopExp::MapShapes(theObject->GetValue(), anIndices);
1470 // Compose shape IDs.
1471 for (; anIter.More(); anIter.Next()) {
1472 const TopoDS_Shape &aShape = anIter.Value();
1473 const Standard_Integer anIndex = anIndices.FindIndex(aShape);
1476 aSeqIDs->Append(anIndex);
1480 if (aSeqIDs->IsEmpty() == Standard_False) {
1482 const TopAbs_ShapeEnum aType = theShapes.First().ShapeType();
1484 aGroup = myGroupOperations->CreateGroup(theObject, aType);
1486 if (aGroup.IsNull() == Standard_False) {
1487 aGroup->GetLastFunction()->SetDescription("");
1488 myGroupOperations->UnionIDs(aGroup, aSeqIDs);
1489 aGroup->GetLastFunction()->SetDescription("");
1491 // Compose the group name.
1492 TCollection_AsciiString aGroupName(theName);
1496 aGroupName += "_VERTEX";
1499 aGroupName += "_EDGE";
1502 aGroupName += "_WIRE";
1505 aGroupName += "_FACE";
1508 aGroupName += "_SHELL";
1511 aGroupName += "_SOLID";
1513 case TopAbs_COMPSOLID:
1514 aGroupName += "_COMPSOLID";
1516 case TopAbs_COMPOUND:
1517 aGroupName += "_COMPOUND";
1520 aGroupName += "_SHAPE";
1524 aGroup->SetName(aGroupName.ToCString());