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 list from install directory
396 if (myResMgr->Find("Import")) {
397 TCollection_AsciiString aFormats (myResMgr->Value("Import"));
398 TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
400 for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
401 theFormats->Append(aToken);
405 // Read Import formats from user directory
406 if (myResMgrUser->Find("Import")) {
407 TCollection_AsciiString aFormats (myResMgrUser->Value("Import"));
408 TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
410 for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
411 int aLenFormats = theFormats->Length();
412 bool isFound = false;
413 for(int aInd=1;aInd<=aLenFormats;aInd++){
414 if( theFormats->Value(aInd) == aToken){
420 theFormats->Append(aToken);
424 // Read Patterns for each supported format
425 int j = 1, len = theFormats->Length();
426 for (; j <= len; j++) {
427 TCollection_AsciiString aKey, aPattern;
428 aKey = theFormats->Value(j) + ".ImportPattern";
429 if (myResMgr->Find(aKey.ToCString()))
430 aPattern = myResMgr->Value(aKey.ToCString());
431 else if(myResMgrUser->Find(aKey.ToCString()))
432 aPattern = myResMgrUser->Value(aKey.ToCString());
434 aKey = theFormats->Value(j) + ".Pattern";
435 if (myResMgr->Find(aKey.ToCString()))
436 aPattern = myResMgr->Value(aKey.ToCString());
437 else if(myResMgrUser->Find(aKey.ToCString()))
438 aPattern = myResMgrUser->Value(aKey.ToCString());
440 aPattern = theFormats->Value(j);
441 aPattern += " Files ( *.* )";
444 thePatterns->Append(aPattern);
447 return (!theFormats->IsEmpty());
450 //=============================================================================
454 //=============================================================================
455 Standard_Boolean GEOMImpl_IInsertOperations::ExportTranslators
456 (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
457 Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
459 if (theFormats.IsNull())
460 theFormats = new TColStd_HSequenceOfAsciiString;
464 if (thePatterns.IsNull())
465 thePatterns = new TColStd_HSequenceOfAsciiString;
467 thePatterns->Clear();
469 if (!InitResMgr()) return Standard_False;
471 // Read Export formats list from install directory
472 if (myResMgr->Find("Export")) {
473 TCollection_AsciiString aFormats (myResMgr->Value("Export"));
474 TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
476 for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
477 theFormats->Append(aToken);
481 // Read Export formats list from user directory
482 if (myResMgrUser->Find("Export")) {
483 TCollection_AsciiString aFormats (myResMgrUser->Value("Export"));
484 TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
486 for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
487 int aLenFormats = theFormats->Length();
488 bool isFound = false;
489 for(int aInd=1;aInd<=aLenFormats;aInd++){
490 if( theFormats->Value(aInd) == aToken){
496 theFormats->Append(aToken);
500 // Read Patterns for each supported format
501 int j = 1, len = theFormats->Length();
502 for (; j <= len; j++) {
503 TCollection_AsciiString aKey, aPattern;
504 aKey = theFormats->Value(j) + ".ExportPattern";
505 if (myResMgr->Find(aKey.ToCString()))
506 aPattern = myResMgr->Value(aKey.ToCString());
507 else if (myResMgrUser->Find(aKey.ToCString()))
508 aPattern = myResMgrUser->Value(aKey.ToCString());
510 aKey = theFormats->Value(j) + ".Pattern";
511 if (myResMgr->Find(aKey.ToCString()))
512 aPattern = myResMgr->Value(aKey.ToCString());
513 else if (myResMgrUser->Find(aKey.ToCString()))
514 aPattern = myResMgrUser->Value(aKey.ToCString());
516 aPattern = theFormats->Value(j);
517 aPattern += " Files ( *.* )";
520 thePatterns->Append(aPattern);
523 return (!theFormats->IsEmpty());
526 //=============================================================================
530 //=============================================================================
531 Standard_Boolean GEOMImpl_IInsertOperations::IsSupported
532 (const Standard_Boolean isImport,
533 const TCollection_AsciiString& theFormat,
534 Handle(TCollection_HAsciiString)& theLibName)
536 if (!InitResMgr()) return Standard_False;
538 // Import/Export mode
539 TCollection_AsciiString aMode;
540 //Standard_CString aMode;
541 if (isImport) aMode = "Import";
542 else aMode = "Export";
544 // Read supported formats for the certain mode from install directory
545 if (myResMgr->Find(aMode.ToCString())) {
546 TCollection_AsciiString aFormats (myResMgr->Value(aMode.ToCString()));
547 if (aFormats.Search(theFormat) > -1) {
548 // Read library name for the supported format
549 TCollection_AsciiString aKey (theFormat);
552 if (myResMgr->Find(aKey.ToCString())) {
553 TCollection_AsciiString aLibName (myResMgr->Value(aKey.ToCString()));
555 if ( aLibName.Length() > 3 && aLibName.SubString(1,3) != "lib" )
556 aLibName.Prepend("lib");
561 theLibName = new TCollection_HAsciiString (aLibName);
562 return Standard_True;
567 // Read supported formats for the certain mode from user directory
568 if (myResMgrUser->Find(aMode.ToCString())) {
569 TCollection_AsciiString aFormats (myResMgrUser->Value(aMode.ToCString()));
570 if (aFormats.Search(theFormat) > -1) {
571 // Read library name for the supported format
572 TCollection_AsciiString aKey (theFormat);
575 if (myResMgrUser->Find(aKey.ToCString())) {
576 TCollection_AsciiString aLibName (myResMgrUser->Value(aKey.ToCString()));
578 if ( aLibName.Length() > 3 && aLibName.SubString(1,3) != "lib" )
579 aLibName.Prepend("lib");
584 theLibName = new TCollection_HAsciiString (aLibName);
585 return Standard_True;
590 return Standard_False;
593 //=============================================================================
597 //=============================================================================
598 Standard_Boolean GEOMImpl_IInsertOperations::InitResMgr()
600 bool isResourceFound = false;
601 bool isResourceFoundUser = false;
602 TCollection_AsciiString aUserResDir,aResDir;
604 if (myResMgr.IsNull()) {
605 // Initialize the Resource Manager
606 TCollection_AsciiString aNull;
607 aResDir = TCollection_AsciiString(getenv("GEOM_ROOT_DIR"));
609 aResDir += "\\share\\salome\\resources\\geom";
611 aResDir += "/share/salome/resources/geom";
614 myResMgr = new Resource_Manager ("ImportExport", aResDir, aNull, Standard_False);
616 isResourceFound = true;
617 if (!myResMgr->Find("Import") && !myResMgr->Find("Export")) {
618 // instead of complains in Resource_Manager
619 isResourceFound = false;
620 INFOS("No valid file \"ImportExport\" found in " << aResDir.ToCString());
623 isResourceFound = true;
625 if (myResMgrUser.IsNull()) {
626 char * dir = getenv("GEOM_ENGINE_RESOURCES_DIR");
627 TCollection_AsciiString aNull;
634 aUserResDir = getenv("HOME");
636 aUserResDir += "\\.salome\\resources";
638 aUserResDir += "/.salome/resources";
642 myResMgrUser = new Resource_Manager ("ImportExport", aNull, aUserResDir, Standard_False);
644 isResourceFoundUser = true;
646 if (!myResMgrUser->Find("Import") && !myResMgrUser->Find("Export")) {
647 // instead of complains in Resource_Manager
648 isResourceFoundUser = false;
652 isResourceFoundUser = true;
654 if(!isResourceFound && !isResourceFoundUser){
655 INFOS("No valid file \"ImportExport\" found in " << aResDir.ToCString());
656 INFOS("No valid file \"ImportExport\" found in " << aUserResDir.ToCString() );
659 return ( myResMgr->Find("Import") || myResMgr->Find("Export") ||
660 myResMgrUser->Find("Import") || myResMgrUser->Find("Export"));
663 //=============================================================================
667 //=============================================================================
668 Handle(GEOM_Object) GEOMImpl_IInsertOperations::RestoreShape (std::istringstream& theStream)
672 //Add a new result object
673 Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
675 //Add a Copy function
676 Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF);
677 if (aFunction.IsNull()) return NULL;
679 //Check if the function is set correctly
680 if (aFunction->GetDriverGUID() != GEOMImpl_CopyDriver::GetID()) return NULL;
682 //Read a shape from the stream
685 BRepTools::Read(aShape, theStream, B);
686 if (aShape.IsNull()) {
687 SetErrorCode("RestoreShape error: BREP reading failed");
691 aFunction->SetValue(aShape);
693 //Special dump to avoid restored shapes publication.
694 //See correcponding code in GEOM_Engine.cxx (method ProcessFunction)
695 //GEOM::TPythonDump(aFunction) << "#";
697 GEOM::TPythonDump(aFunction) << result
698 << " = geompy.RestoreShape(\"\") # the shape string has not been dump for performance reason";
705 int GEOMImpl_IInsertOperations::LoadTexture(const TCollection_AsciiString& theTextureFile)
709 if (theTextureFile.IsEmpty()) return 0;
711 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
712 Handle(TColStd_HArray1OfByte) aTexture;
714 Handle(TDataStd_HArray1OfByte) aTexture;
717 FILE* fp = fopen(theTextureFile.ToCString(), "r");
720 std::list<std::string> lines;
724 if ((fgets(buffer, 4096, fp)) == NULL) break;
725 int aLen = strlen(buffer);
726 if (buffer[aLen-1] == '\n') buffer[aLen-1] = '\0';
727 lines.push_back(buffer);
728 maxlen = std::max(maxlen, (int)strlen(buffer));
733 int lenbytes = maxlen/8;
734 if (maxlen%8) lenbytes++;
736 if (lenbytes == 0 || lines.empty())
739 std::list<unsigned char> bytedata;
740 std::list<std::string>::const_iterator it;
741 for (it = lines.begin(); it != lines.end(); ++it) {
742 std::string line = *it;
743 int lenline = (line.size()/8 + (line.size()%8 ? 1 : 0)) * 8;
744 for (int i = 0; i < lenline/8; i++) {
745 unsigned char byte = 0;
746 for (int j = 0; j < 8; j++)
747 byte = (byte << 1) + ( i*8+j < line.size() && line[i*8+j] != '0' ? 1 : 0 );
748 bytedata.push_back(byte);
750 for (int i = lenline/8; i < lenbytes; i++)
751 bytedata.push_back((unsigned char)0);
754 if (bytedata.empty() || bytedata.size() != lines.size()*lenbytes)
757 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
758 aTexture = new TColStd_HArray1OfByte (1, lines.size()*lenbytes);
760 aTexture = new TDataStd_HArray1OfByte (1, lines.size()*lenbytes);
763 std::list<unsigned char>::iterator bdit;
765 for (i = 1, bdit = bytedata.begin(); bdit != bytedata.end(); ++bdit, ++i)
766 aTexture->SetValue(i, (Standard_Byte)(*bdit));
768 int aTextureId = GetEngine()->addTexture(GetDocID(), lenbytes*8, lines.size(), aTexture, theTextureFile);
769 if (aTextureId > 0) SetErrorCode(OK);
773 int GEOMImpl_IInsertOperations::AddTexture(int theWidth, int theHeight,
774 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
775 const Handle(TColStd_HArray1OfByte)& theTexture)
777 const Handle(TDataStd_HArray1OfByte)& theTexture)
781 int aTextureId = GetEngine()->addTexture(GetDocID(), theWidth, theHeight, theTexture);
782 if (aTextureId > 0) SetErrorCode(OK);
786 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
787 Handle(TColStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
789 Handle(TDataStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
791 int& theWidth, int& theHeight)
795 #if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
796 Handle(TColStd_HArray1OfByte) aTexture;
798 Handle(TDataStd_HArray1OfByte) aTexture;
801 theWidth = theHeight = 0;
802 TCollection_AsciiString aFileName;
804 if (theTextureId <= 0)
807 aTexture = GetEngine()->getTexture(GetDocID(), theTextureId, theWidth, theHeight, aFileName);
809 if (theWidth > 0 && theHeight > 0 && aTexture->Length() > 0) SetErrorCode(OK);
814 std::list<int> GEOMImpl_IInsertOperations::GetAllTextures()
817 std::list<int> id_list = GetEngine()->getAllTextures(GetDocID());
822 TopAbs_ShapeEnum getGroupDimension(XAO::Group* group)
824 XAO::Dimension dim = group->getDimension();
825 TopAbs_ShapeEnum rdim;
829 rdim = TopAbs_VERTEX; break;
831 rdim = TopAbs_EDGE; break;
833 rdim = TopAbs_FACE; break;
835 rdim = TopAbs_SOLID; break;
837 rdim = TopAbs_COMPOUND; break;
842 XAO::Dimension shapeEnumToDimension(const TopAbs_ShapeEnum& shape)
847 dim = XAO::VERTEX; break;
849 dim = XAO::EDGE; break;
851 dim = XAO::FACE; break;
853 dim = XAO::SOLID; break;
855 throw SALOME_Exception("Bad type"); // TODO
860 void GEOMImpl_IInsertOperations::exportGroups(std::list<Handle(GEOM_Object)> groupList,
862 XAO::BrepGeometry* geometry)
865 std::list<Handle(GEOM_Object)>::iterator groupIterator = groupList.begin();
866 while (groupIterator != groupList.end())
868 Handle(GEOM_Object) currGroup = (*groupIterator++);
869 Handle(TColStd_HArray1OfInteger) groupIds = myGroupOperations->GetObjects(currGroup);
871 TopAbs_ShapeEnum shapeGroup = myGroupOperations->GetType(currGroup);
872 XAO::Dimension dim = shapeEnumToDimension(shapeGroup);
873 XAO::Group* group = xaoObject->addGroup(dim, currGroup->GetName().ToCString());
878 for (int i = 1; i <= groupIds->Length(); i++)
880 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
881 int index = geometry->getVertexIndexByReference(ref);
886 for (int i = 1; i <= groupIds->Length(); i++)
888 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
889 int index = geometry->getEdgeIndexByReference(ref);
894 for (int i = 1; i <= groupIds->Length(); i++)
896 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
897 int index = geometry->getFaceIndexByReference(ref);
902 for (int i = 1; i <= groupIds->Length(); i++)
904 std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
905 int index = geometry->getSolidIndexByReference(ref);
913 void GEOMImpl_IInsertOperations::exportFields(std::list<Handle(GEOM_Field)> fieldList,
915 XAO::BrepGeometry* geometry)
917 std::list<Handle(GEOM_Field)>::iterator fieldIterator = fieldList.begin();
918 while (fieldIterator != fieldList.end())
920 Handle(GEOM_Field) currField = (*fieldIterator++);
922 int fdim = currField->GetDimension();
923 int ftype = currField->GetDataType();
924 int nbComponents = currField->GetNbComponents();
925 std::string name = currField->GetName().ToCString();
927 XAO::Field* field = xaoObject->addField((XAO::Type)ftype, (XAO::Dimension)fdim, nbComponents, name);
929 Handle(TColStd_HArray1OfExtendedString) components = currField->GetComponents();
930 for (int i = components->Lower(), j = 0; i <= components->Upper(); ++i, ++j)
932 field->setComponentName(j, TCollection_AsciiString(components->Value(i)).ToCString());
935 std::list< Handle(GEOM_FieldStep)> steps = currField->GetSteps();
936 std::list<Handle(GEOM_FieldStep)>::iterator stepIterator = steps.begin();
937 while (stepIterator != steps.end())
939 Handle(GEOM_FieldStep) currStep = (*stepIterator++);
941 XAO::Step* step = field->addNewStep(currStep->GetID());
942 step->setStamp(currStep->GetStamp());
948 XAO::BooleanStep* bs = (XAO::BooleanStep*)step;
949 Handle(TColStd_HArray1OfInteger) bvalues = currStep->GetIntValues();
950 std::vector<bool> bv;
951 bv.reserve(bvalues->Upper());
952 for ( int i = bvalues->Lower(), nb = bvalues->Upper(); i <= nb; ++i )
954 bv.push_back(bvalues->Value(i) != 0);
961 XAO::IntegerStep* is = (XAO::IntegerStep*)step;
962 Handle(TColStd_HArray1OfInteger) ivalues = currStep->GetIntValues();
964 iv.reserve(ivalues->Upper());
965 for ( int i = ivalues->Lower(), nb = ivalues->Upper(); i <= nb; ++i )
967 iv.push_back(ivalues->Value(i));
974 XAO::DoubleStep* ds = (XAO::DoubleStep*)step;
975 Handle(TColStd_HArray1OfReal) dvalues = currStep->GetDoubleValues();
976 std::vector<double> dv;
977 dv.reserve(dvalues->Upper());
978 for ( int i = dvalues->Lower(), nb = dvalues->Upper(); i <= nb; ++i )
980 dv.push_back(dvalues->Value(i));
987 XAO::StringStep* ss = (XAO::StringStep*)step;
988 Handle(TColStd_HArray1OfExtendedString) svalues = currStep->GetStringValues();
989 std::vector<std::string> sv;
990 sv.reserve(svalues->Upper());
991 for ( int i = svalues->Lower(), nb = svalues->Upper(); i <= nb; ++i )
993 sv.push_back(TCollection_AsciiString(svalues->Value(i)).ToCString());
1003 void GEOMImpl_IInsertOperations::exportSubshapes(const Handle(GEOM_Object)& shape, XAO::BrepGeometry* geometry)
1005 Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects(shape, false);
1006 int nbSubObjects = subObjects->Length();
1007 // set the names of the sub shapes
1008 for (int i = 1; i <= nbSubObjects; i++)
1010 Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
1011 if (transientSubObject.IsNull())
1014 Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast(transientSubObject);
1015 if (subObject->GetType() != GEOM_GROUP)
1017 int subIndex = myShapesOperations->GetSubShapeIndex(shape, subObject);
1018 switch (subObject->GetValue().ShapeType())
1021 geometry->changeVertexName(subIndex, subObject->GetName().ToCString());
1024 geometry->changeEdgeName(subIndex, subObject->GetName().ToCString());
1027 geometry->changeFaceName(subIndex, subObject->GetName().ToCString());
1030 geometry->changeSolidName(subIndex, subObject->GetName().ToCString());
1037 //=============================================================================
1039 * Export a shape to XAO format
1040 * \param shape The shape to export
1041 * \param groups The list of groups to export
1042 * \param fields The list of fields to export
1043 * \param fileName The name of the file to exported
1044 * \return boolean indicating if export was succeful.
1046 //=============================================================================
1047 bool GEOMImpl_IInsertOperations::ExportXAO(Handle(GEOM_Object) shape,
1048 std::list<Handle(GEOM_Object)> groupList,
1049 std::list<Handle(GEOM_Field)> fieldList,
1051 const char* fileName)
1055 if (shape.IsNull()) return false;
1057 // add a new shape function with parameters
1058 Handle(GEOM_Function) lastFunction = shape->GetLastFunction();
1059 if (lastFunction.IsNull()) return false;
1061 // add a new result object
1062 Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
1064 // add an Export function
1065 Handle(GEOM_Function) exportFunction = result->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
1066 if (exportFunction.IsNull()) return false;
1067 if (exportFunction->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
1069 // create the XAO object
1070 XAO::Xao* xaoObject = new XAO::Xao();
1071 xaoObject->setAuthor(author);
1074 XAO::BrepGeometry* geometry = (XAO::BrepGeometry*)XAO::Geometry::createGeometry(XAO::BREP);
1075 TopoDS_Shape topoShape = shape->GetValue();
1076 exportFunction->SetValue(topoShape);
1077 XAO::BrepGeometry* brep = (XAO::BrepGeometry*)geometry;
1078 brep->setTopoDS_Shape(topoShape);
1080 geometry->setName(shape->GetName().ToCString());
1081 exportSubshapes(shape, geometry);
1082 xaoObject->setGeometry(geometry);
1084 exportGroups(groupList, xaoObject, geometry);
1085 exportFields(fieldList, xaoObject, geometry);
1087 // export the XAO to the file
1088 xaoObject->exportXAO(fileName);
1090 // make a Python command
1091 GEOM::TPythonDump pd(exportFunction);
1092 pd << "exported = geompy.ExportXAO(" << shape;
1096 if (groupList.size() > 0)
1098 std::list<Handle(GEOM_Object)>::iterator itGroup = groupList.begin();
1100 while (itGroup != groupList.end())
1102 pd << ", " << (*itGroup++);
1108 if (fieldList.size() > 0)
1110 std::list<Handle(GEOM_Field)>::iterator itField = fieldList.begin();
1112 while (itField != fieldList.end())
1114 pd << ", " << (*itField++);
1118 pd << "\"" << author << "\", \"" << fileName << "\")";
1126 void GEOMImpl_IInsertOperations::importSubShapes(XAO::Geometry* xaoGeometry,
1127 Handle(GEOM_Function) function, int shapeType, int dim,
1128 Handle(TColStd_HSequenceOfTransient)& subShapeList)
1130 Handle(GEOM_Object) subShape;
1131 Handle(GEOM_Function) aFunction;
1132 Handle(TColStd_HArray1OfInteger) anArray;
1134 XAO::GeometricElementList::iterator elementIterator = xaoGeometry->begin((XAO::Dimension)dim);
1135 for (; elementIterator != xaoGeometry->end((XAO::Dimension)dim); elementIterator++)
1137 XAO::GeometricElement element = elementIterator->second;
1138 if (!element.hasName())
1141 std::string name = element.getName();
1142 std::string ref = element.getReference();
1143 int iref = XAO::XaoUtils::stringToInt(ref);
1145 anArray = new TColStd_HArray1OfInteger(1, 1);
1146 anArray->SetValue(1, iref);
1148 subShape = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
1149 Handle(GEOM_Function) aFunction = subShape->AddFunction(GEOM_Object::GetSubShapeID(), 1);
1150 if (aFunction.IsNull())
1153 subShape->SetName(name.c_str());
1154 subShape->SetType(shapeType);
1156 GEOM_ISubShape aSSI(aFunction);
1157 aSSI.SetMainShape(function);
1158 aSSI.SetIndices(anArray);
1160 //aFunction->SetValue(aValue);
1161 subShapeList->Append(subShape);
1163 // Put this subshape in the list of sub-shapes of theMainShape
1164 function->AddSubShapeReference(aFunction);
1168 //=============================================================================
1170 * Import a shape from XAO format
1171 * \param fileName The name of the file to import
1172 * \param shape The imported shape
1173 * \param subShapes The list of imported groups
1174 * \param groups The list of imported groups
1175 * \param fields The list of imported fields
1176 * \return boolean indicating if import was succeful.
1178 //=============================================================================
1179 bool GEOMImpl_IInsertOperations::ImportXAO(const char* fileName,
1180 Handle(GEOM_Object)& shape,
1181 Handle(TColStd_HSequenceOfTransient)& subShapes,
1182 Handle(TColStd_HSequenceOfTransient)& groups,
1183 Handle(TColStd_HSequenceOfTransient)& fields)
1187 if (fileName == NULL || groups.IsNull() || fields.IsNull())
1191 XAO::Xao* xaoObject = new XAO::Xao();
1194 xaoObject->importXAO(fileName);
1196 catch (XAO::XAO_Exception& exc)
1199 SetErrorCode(exc.what());
1203 XAO::Geometry* xaoGeometry = xaoObject->getGeometry();
1204 if (xaoGeometry == NULL)
1207 SetErrorCode("Cannot import XAO: geometry format not supported.");
1212 shape = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
1213 Handle(GEOM_Function) function = shape->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
1214 if (function.IsNull()) return false;
1215 if (function->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
1218 if (xaoGeometry->getFormat() == XAO::BREP)
1220 XAO::BrepGeometry* brep = (XAO::BrepGeometry*)xaoGeometry;
1221 TopoDS_Shape geomShape = brep->getTopoDS_Shape();
1222 function->SetValue(geomShape);
1223 shape->SetName(xaoGeometry->getName().c_str());
1228 SetErrorCode("Cannot import XAO: geometry format not supported.");
1232 // create sub shapes with names
1233 importSubShapes(xaoGeometry, function, GEOM_POINT, XAO::VERTEX, subShapes);
1234 importSubShapes(xaoGeometry, function, GEOM_EDGE, XAO::EDGE, subShapes);
1235 importSubShapes(xaoGeometry, function, GEOM_FACE, XAO::FACE, subShapes);
1236 importSubShapes(xaoGeometry, function, GEOM_SOLID, XAO::SOLID, subShapes);
1239 int nbGroups = xaoObject->countGroups();
1240 for (int i = 0; i < nbGroups; ++i)
1242 XAO::Group* xaoGroup = xaoObject->getGroup(i);
1244 // build an array with the indexes of the sub shapes
1245 int nbElt = xaoGroup->count();
1246 Handle(TColStd_HArray1OfInteger) array = new TColStd_HArray1OfInteger(1, nbElt);
1248 for (std::set<int>::iterator it = xaoGroup->begin(); it != xaoGroup->end(); ++it)
1251 std::string ref = xaoGeometry->getElementReference(xaoGroup->getDimension(), index);
1252 array->SetValue(++j, XAO::XaoUtils::stringToInt(ref));
1255 // create the group with the array of sub shapes indexes
1256 Handle(GEOM_Object) group = GetEngine()->AddSubShape(shape, array);
1257 group->SetType(GEOM_GROUP);
1258 group->SetName(xaoGroup->getName().c_str());
1260 // Set a sub-shape type
1261 TDF_Label freeLabel = group->GetFreeLabel();
1262 TDataStd_Integer::Set(freeLabel, (Standard_Integer) getGroupDimension(xaoGroup));
1263 groups->Append(group);
1265 function = group->GetLastFunction();
1268 // create the fields
1269 int nbFields = xaoObject->countFields();
1270 for (int i = 0; i < nbFields; ++i)
1272 XAO::Field* xaoField = xaoObject->getField(i);
1274 Handle(TColStd_HArray1OfExtendedString) components = new TColStd_HArray1OfExtendedString(0, xaoField->countComponents()-1);
1275 for (int j = 0; j < xaoField->countComponents(); ++j)
1277 components->SetValue(j, (TCollection_ExtendedString)xaoField->getComponentName(j).c_str());
1280 Handle(GEOM_Field) field = myFieldOperations->CreateField(shape,
1281 xaoField->getName().c_str(),
1282 (int)xaoField->getType(),
1283 (int)xaoField->getDimension(),
1286 switch (xaoField->getType())
1290 XAO::BooleanField* bfield = (XAO::BooleanField*)xaoField;
1291 for (int j = 0; j < xaoField->countSteps(); ++j)
1293 XAO::BooleanStep* bstep = bfield->getStep(j);
1294 Handle(GEOM_FieldStep) step = field->AddStep(bstep->getStep(), bstep->getStamp());
1296 Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, bstep->countValues()-1);
1297 std::vector<bool> bvalues = bstep->getValues();
1298 for (int k = 0; k < bstep->countValues(); ++k)
1300 values->SetValue(k, bvalues[k] ? 1 : 0);
1302 step->SetValues(values);
1308 XAO::IntegerField* ifield = (XAO::IntegerField*)xaoField;
1309 for (int j = 0; j < xaoField->countSteps(); ++j)
1311 XAO::IntegerStep* istep = ifield->getStep(j);
1312 Handle(GEOM_FieldStep) step = field->AddStep(istep->getStep(), istep->getStamp());
1314 Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, istep->countValues()-1);
1315 std::vector<int> ivalues = istep->getValues();
1316 for (int k = 0; k < istep->countValues(); ++k)
1318 values->SetValue(k, ivalues[k]);
1320 step->SetValues(values);
1326 XAO::DoubleField* dfield = (XAO::DoubleField*)xaoField;
1327 for (int j = 0; j < xaoField->countSteps(); ++j)
1329 XAO::DoubleStep* dstep = dfield->getStep(j);
1330 Handle(GEOM_FieldStep) step = field->AddStep(dstep->getStep(), dstep->getStamp());
1332 Handle(TColStd_HArray1OfReal) values = new TColStd_HArray1OfReal(0, dstep->countValues()-1);
1333 std::vector<double> dvalues = dstep->getValues();
1334 for (int k = 0; k < dstep->countValues(); ++k)
1336 values->SetValue(k, dvalues[k]);
1338 step->SetValues(values);
1344 XAO::StringField* sfield = (XAO::StringField*)xaoField;
1345 for (int j = 0; j < xaoField->countSteps(); ++j)
1347 XAO::StringStep* sstep = sfield->getStep(j);
1348 Handle(GEOM_FieldStep) step = field->AddStep(sstep->getStep(), sstep->getStamp());
1350 Handle(TColStd_HArray1OfExtendedString) values = new TColStd_HArray1OfExtendedString(0, sstep->countValues()-1);
1351 std::vector<std::string> svalues = sstep->getValues();
1352 for (int k = 0; k < sstep->countValues(); ++k)
1354 values->SetValue(k, TCollection_ExtendedString(svalues[k].c_str()));
1356 step->SetValues(values);
1362 fields->Append(field);
1365 // make a Python command
1366 GEOM::TPythonDump pd(function);
1367 pd << "(imported, " << shape << ", ";
1369 // list of sub shapes
1371 int nbSubshapes = subShapes->Length();
1372 if (nbSubshapes > 0)
1374 for (int i = 1; i <= nbSubshapes; i++)
1376 Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(subShapes->Value(i));
1377 pd << obj << ((i < nbSubshapes) ? ", " : "");
1385 for (int i = 1; i <= nbGroups; i++)
1387 Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(groups->Value(i));
1388 pd << obj << ((i < nbGroups) ? ", " : "");
1397 for (int i = 1; i <= nbFields; i++)
1399 Handle(GEOM_Field) obj = Handle(GEOM_Field)::DownCast(fields->Value(i));
1400 pd << obj << ((i < nbFields) ? ", " : "");
1404 pd << ") = geompy.ImportXAO(\"" << fileName << "\")";
1412 //=============================================================================
1414 * This method creates material groups for an imported object.
1415 * \param theObject the imported object.
1417 //=============================================================================
1418 void GEOMImpl_IInsertOperations::MakeMaterialGroups
1419 (const Handle(GEOM_Object) &theObject,
1420 const Handle(TColStd_HSequenceOfTransient) &theSeq)
1422 TopoDS_Shape aResShape = theObject->GetValue();
1424 if (aResShape.IsNull() == Standard_False) {
1425 // Group shapes by material names.
1426 Handle(GEOM_Function) aFunction = theObject->GetLastFunction();
1427 DataMapOfStringListOfShape aMapMaterialShapes;
1429 // check all named shapes using iterator
1430 TDF_ChildIDIterator anIt (aFunction->GetNamingEntry(),
1431 TNaming_NamedShape::GetID(), Standard_True);
1433 for (; anIt.More(); anIt.Next()) {
1434 Handle(TNaming_NamedShape) anAttr =
1435 Handle(TNaming_NamedShape)::DownCast(anIt.Value());
1437 if (anAttr.IsNull() == Standard_False) {
1438 TDF_Label aLabel = anAttr->Label();
1439 Handle(TDataStd_Comment) aComment;
1441 if (aLabel.FindAttribute(TDataStd_Comment::GetID(), aComment)) {
1442 TCollection_ExtendedString aMatName = aComment->Get();
1443 TopoDS_Shape aShape = anAttr->Get();
1445 if (aMapMaterialShapes.IsBound(aMatName) == Standard_False) {
1446 NCollection_List<TopoDS_Shape> anEmptyList;
1448 aMapMaterialShapes.Bind(aMatName, anEmptyList);
1451 aMapMaterialShapes(aMatName).Append(aShape);
1456 if (aMapMaterialShapes.IsEmpty() == Standard_False) {
1457 // Construct groups.
1458 TopAbs_ShapeEnum aType = aResShape.ShapeType();
1460 DataMapOfStringListOfShape::Iterator aMapIter;
1462 // Check each shape type.
1463 for(i = aType; i <= TopAbs_VERTEX; i++) {
1464 DataMapOfStringListOfShape::Iterator aMapIter(aMapMaterialShapes);
1466 for (; aMapIter.More(); aMapIter.Next()) {
1467 NCollection_List<TopoDS_Shape> &aShList = aMapIter.ChangeValue();
1468 NCollection_List<TopoDS_Shape>::Iterator aShIter(aShList);
1469 NCollection_List<TopoDS_Shape> aShListSameType;
1471 while (aShIter.More()) {
1472 const TopoDS_Shape &aShape = aShIter.Value();
1474 if (i == aShape.ShapeType()) {
1475 // Treat this element.
1476 aShListSameType.Append(aShape);
1477 aShList.Remove(aShIter);
1479 // Go to the next element.
1484 if (aShListSameType.IsEmpty() == Standard_False) {
1485 // Construct a group.
1486 Handle(GEOM_Object) aGroup =
1487 MakeGroup(theObject, aMapIter.Key(), aShListSameType);
1489 if (aGroup.IsNull() == Standard_False) {
1490 theSeq->Append(aGroup);
1500 //=============================================================================
1502 * This method creates a group of shapes of certain type.
1503 * \param theObject the imported object.
1504 * \param theName the material name.
1505 * \param theShapes the list of shapes to be added to this group.
1506 * \return the created group.
1508 //=============================================================================
1509 Handle(GEOM_Object) GEOMImpl_IInsertOperations::MakeGroup
1510 (const Handle(GEOM_Object) &theObject,
1511 const TCollection_ExtendedString &theName,
1512 const NCollection_List<TopoDS_Shape> &theShapes)
1514 Handle(GEOM_Object) aGroup;
1515 TopTools_IndexedMapOfShape anIndices;
1516 Handle(TColStd_HSequenceOfInteger) aSeqIDs = new TColStd_HSequenceOfInteger;
1517 NCollection_List<TopoDS_Shape>::Iterator anIter(theShapes);
1519 TopExp::MapShapes(theObject->GetValue(), anIndices);
1521 // Compose shape IDs.
1522 for (; anIter.More(); anIter.Next()) {
1523 const TopoDS_Shape &aShape = anIter.Value();
1524 const Standard_Integer anIndex = anIndices.FindIndex(aShape);
1527 aSeqIDs->Append(anIndex);
1531 if (aSeqIDs->IsEmpty() == Standard_False) {
1533 const TopAbs_ShapeEnum aType = theShapes.First().ShapeType();
1535 aGroup = myGroupOperations->CreateGroup(theObject, aType);
1537 if (aGroup.IsNull() == Standard_False) {
1538 aGroup->GetLastFunction()->SetDescription("");
1539 myGroupOperations->UnionIDs(aGroup, aSeqIDs);
1540 aGroup->GetLastFunction()->SetDescription("");
1542 // Compose the group name.
1543 TCollection_AsciiString aGroupName(theName);
1547 aGroupName += "_VERTEX";
1550 aGroupName += "_EDGE";
1553 aGroupName += "_WIRE";
1556 aGroupName += "_FACE";
1559 aGroupName += "_SHELL";
1562 aGroupName += "_SOLID";
1564 case TopAbs_COMPSOLID:
1565 aGroupName += "_COMPSOLID";
1567 case TopAbs_COMPOUND:
1568 aGroupName += "_COMPOUND";
1571 aGroupName += "_SHAPE";
1575 aGroup->SetName(aGroupName.ToCString());