-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
#include <Standard_Stream.hxx>
#include <GEOMImpl_ICopy.hxx>
#include <GEOMImpl_IImportExport.hxx>
#include <GEOMImpl_Types.hxx>
+#include "GEOMImpl_IShapesOperations.hxx"
+#include "GEOMImpl_IGroupOperations.hxx"
+#include "GEOMImpl_IFieldOperations.hxx"
+#include "GEOMImpl_XAODriver.hxx"
+#include "GEOMImpl_IImportExportXAO.hxx"
#include <GEOM_Function.hxx>
#include <GEOM_PythonDump.hxx>
+#include "GEOM_ISubShape.hxx"
+
+#include <XAO_Xao.hxx>
+#include <XAO_Geometry.hxx>
+#include <XAO_BrepGeometry.hxx>
+#include <XAO_Group.hxx>
+#include <XAO_Field.hxx>
+#include <XAO_XaoUtils.hxx>
+#include <XAO_BooleanField.hxx>
+#include <XAO_IntegerField.hxx>
+#include <XAO_DoubleField.hxx>
+#include <XAO_StringField.hxx>
+#include <XAO_BooleanStep.hxx>
+#include <XAO_IntegerStep.hxx>
+#include <XAO_DoubleStep.hxx>
+#include <XAO_StringStep.hxx>
#include <Basics_OCCTVersion.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
+#include <TDF_ChildIDIterator.hxx>
#include <TDF_Tool.hxx>
+#include <TDataStd_Integer.hxx>
+#include <TNaming_NamedShape.hxx>
+#include <TDataStd_Comment.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopExp.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Vertex.hxx>
#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
#include <TColStd_HArray1OfByte.hxx>
+#include <TColStd_HArray1OfReal.hxx>
#else
#include <TDataStd_HArray1OfByte.hxx>
#endif
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+/**
+ * This function returns the input format name from the original format name.
+ */
+static TCollection_AsciiString GetImportFormatName
+ (const TCollection_AsciiString& theFormatName)
+{
+ return theFormatName.Token("_");
+}
+
//=============================================================================
/*!
* constructor
: GEOM_IOperations(theEngine, theDocID)
{
MESSAGE("GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations");
+ myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID());
+ myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
+ myFieldOperations = new GEOMImpl_IFieldOperations(GetEngine(), GetDocID());
}
//=============================================================================
GEOMImpl_IInsertOperations::~GEOMImpl_IInsertOperations()
{
MESSAGE("GEOMImpl_IInsertOperations::~GEOMImpl_IInsertOperations");
+ delete myShapesOperations;
+ delete myGroupOperations;
+ delete myFieldOperations;
}
//=============================================================================
* Import
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_IInsertOperations::Import
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_IInsertOperations::Import
(const TCollection_AsciiString& theFileName,
const TCollection_AsciiString& theFormatName)
{
if (theFileName.IsEmpty() || theFormatName.IsEmpty()) return NULL;
//Add a new result object
- Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
+ Handle(GEOM_Object) anImported = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
//Add an Import function
- Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_ImportDriver::GetID(), IMPORT_SHAPE);
- if (aFunction.IsNull()) return result;
+ Handle(GEOM_Function) aFunction =
+ anImported->AddFunction(GEOMImpl_ImportDriver::GetID(), IMPORT_SHAPE);
+
+ if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
- if (aFunction->GetDriverGUID() != GEOMImpl_ImportDriver::GetID()) return result;
+ if (aFunction->GetDriverGUID() != GEOMImpl_ImportDriver::GetID()) return NULL;
Handle(TCollection_HAsciiString) aHLibName;
- if (!IsSupported(Standard_True, theFormatName/*.SubString(1,4)*/, aHLibName)) {
- return result;
+ if (!IsSupported
+ (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
+ return NULL;
}
TCollection_AsciiString aLibName = aHLibName->String();
aCI.SetPluginName(aLibName);
//Perform the Import
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
try {
#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
SetErrorCode("Import driver failed");
return NULL;
}
+
+ aSeq->Append(anImported);
+
+ // Greate material groups.
+ MakeMaterialGroups(anImported, aSeq);
}
catch (Standard_Failure) {
Handle(Standard_Failure) aFail = Standard_Failure::Caught();
}
//Make a Python command
- if( theFormatName != "IGES_UNIT" ) {
- GEOM::TPythonDump(aFunction) << result << " = geompy.ImportFile(\""
- << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";
+ if (theFormatName != "IGES_UNIT") {
+ GEOM::TPythonDump pd (aFunction);
+ if (theFormatName == "BREP")
+ pd << aSeq << " = geompy.ImportBREP(\"" << theFileName.ToCString() << "\")";
+ else if (theFormatName == "IGES")
+ pd << aSeq << " = geompy.ImportIGES(\"" << theFileName.ToCString() << "\")";
+ else if (theFormatName == "IGES_SCALE")
+ pd << aSeq << " = geompy.ImportIGES(\"" << theFileName.ToCString() << "\", True)";
+ else if (theFormatName == "STEP")
+ pd << aSeq << " = geompy.ImportSTEP(\"" << theFileName.ToCString() << "\")";
+ else if (theFormatName == "STEP_SCALE")
+ pd << aSeq << " = geompy.ImportSTEP(\"" << theFileName.ToCString() << "\", True)";
+ else {
+ pd << aSeq << " = geompy.ImportFile(\""
+ << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";
+ }
}
SetErrorCode(OK);
gp_Pnt P = BRep_Tool::Pnt(V);
double scale = P.X();
TCollection_AsciiString aUnitName = "UNIT_M";
- if( fabs(scale-0.01) < 1.e-6 )
+ if (fabs(scale-0.01) < 1.e-6)
aUnitName = "UNIT_CM";
- else if( fabs(scale-0.001) < 1.e-6 )
+ else if (fabs(scale-0.001) < 1.e-6)
aUnitName = "UNIT_MM";
//cout<<"IIO: aUnitName = "<<aUnitName.ToCString()<<endl;
SetErrorCode(aUnitName);
}
// OLD CODE: end
- return result;
+ return aSeq;
}
//=============================================================================
if (theFileName.IsEmpty() || theFormatName.IsEmpty() || theParameterName.IsEmpty()) return aValue;
Handle(TCollection_HAsciiString) aHLibName;
- if (!IsSupported(Standard_True, theFormatName/*.SubString(1,4)*/, aHLibName)) {
+ if (!IsSupported
+ (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
return aValue;
}
TCollection_AsciiString aLibName = aHLibName->String();
if (!InitResMgr()) return Standard_False;
- // Read Import formats list from install directory
- if (myResMgr->Find("Import")) {
- TCollection_AsciiString aFormats (myResMgr->Value("Import"));
- TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
- int i = 1;
- for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
- theFormats->Append(aToken);
- }
- }
-
- // Read Import formats from user directory
- if (myResMgrUser->Find("Import")) {
- TCollection_AsciiString aFormats (myResMgrUser->Value("Import"));
- TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
- int i = 1;
- for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
- int aLenFormats = theFormats->Length();
- bool isFound = false;
- for(int aInd=1;aInd<=aLenFormats;aInd++){
- if( theFormats->Value(aInd) == aToken){
- isFound = true;
- break;
+ // Read Import formats from directories
+ Handle(Resource_Manager) aResMgr;
+ Handle(TColStd_HSequenceOfAsciiString) aFormatsToAdd;
+ for(int index = 0; index < myResMgrList.size(); index++) {
+ int anOldLen = theFormats->Length();
+ aResMgr = myResMgrList.at(index);
+ if (aResMgr->Find("Import")) {
+ TCollection_AsciiString aFormats (aResMgr->Value("Import"));
+ TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
+ for (int i = 1; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
+ int aLenFormats = theFormats->Length();
+ bool isFound = false;
+ for(int aInd=1;aInd<=aLenFormats;aInd++){
+ if( theFormats->Value(aInd) == aToken ){
+ isFound = true;
+ break;
+ }
}
+ if(!isFound)
+ theFormats->Append(aToken);
}
- if(!isFound)
- theFormats->Append(aToken);
}
- }
- // Read Patterns for each supported format
- int j = 1, len = theFormats->Length();
- for (; j <= len; j++) {
- TCollection_AsciiString aKey, aPattern;
- aKey = theFormats->Value(j) + ".ImportPattern";
- if (myResMgr->Find(aKey.ToCString()))
- aPattern = myResMgr->Value(aKey.ToCString());
- else if(myResMgrUser->Find(aKey.ToCString()))
- aPattern = myResMgrUser->Value(aKey.ToCString());
- else {
- aKey = theFormats->Value(j) + ".Pattern";
- if (myResMgr->Find(aKey.ToCString()))
- aPattern = myResMgr->Value(aKey.ToCString());
- else if(myResMgrUser->Find(aKey.ToCString()))
- aPattern = myResMgrUser->Value(aKey.ToCString());
+ // Read Patterns for each supported format
+ for (int j = anOldLen+1; j <= theFormats->Length(); j++) {
+ TCollection_AsciiString aKey, aPattern;
+ aKey = theFormats->Value(j) + ".ImportPattern";
+ if (aResMgr->Find(aKey.ToCString()))
+ aPattern = aResMgr->Value(aKey.ToCString());
else {
- aPattern = theFormats->Value(j);
- aPattern += " Files ( *.* )";
+ aKey = theFormats->Value(j) + ".Pattern";
+ if (aResMgr->Find(aKey.ToCString()))
+ aPattern = aResMgr->Value(aKey.ToCString());
+ else {
+ aPattern = theFormats->Value(j);
+ aPattern += " Files ( *.* )";
+ }
}
+ thePatterns->Append(aPattern);
}
- thePatterns->Append(aPattern);
}
return (!theFormats->IsEmpty());
if (!InitResMgr()) return Standard_False;
- // Read Export formats list from install directory
- if (myResMgr->Find("Export")) {
- TCollection_AsciiString aFormats (myResMgr->Value("Export"));
- TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
- int i = 1;
- for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
- theFormats->Append(aToken);
- }
- }
-
- // Read Export formats list from user directory
- if (myResMgrUser->Find("Export")) {
- TCollection_AsciiString aFormats (myResMgrUser->Value("Export"));
- TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
- int i = 1;
- for (; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
- int aLenFormats = theFormats->Length();
- bool isFound = false;
- for(int aInd=1;aInd<=aLenFormats;aInd++){
- if( theFormats->Value(aInd) == aToken){
- isFound = true;
- break;
+ // Read Export formats list from directories
+ Handle(Resource_Manager) aResMgr;
+ for(int index=0; index < myResMgrList.size(); index++) {
+ int anOldLen = theFormats->Length();
+ aResMgr = myResMgrList.at(index);
+ if (aResMgr->Find("Export")) {
+ TCollection_AsciiString aFormats (aResMgr->Value("Export"));
+ TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
+ for (int i = 1; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
+ int aLenFormats = theFormats->Length();
+ bool isFound = false;
+ for(int aInd=1;aInd<=aLenFormats;aInd++){
+ if( theFormats->Value(aInd) == aToken){
+ isFound = true;
+ break;
+ }
}
+ if(!isFound)
+ theFormats->Append(aToken);
}
- if(!isFound)
- theFormats->Append(aToken);
}
- }
- // Read Patterns for each supported format
- int j = 1, len = theFormats->Length();
- for (; j <= len; j++) {
- TCollection_AsciiString aKey, aPattern;
- aKey = theFormats->Value(j) + ".ExportPattern";
- if (myResMgr->Find(aKey.ToCString()))
- aPattern = myResMgr->Value(aKey.ToCString());
- else if (myResMgrUser->Find(aKey.ToCString()))
- aPattern = myResMgrUser->Value(aKey.ToCString());
- else {
- aKey = theFormats->Value(j) + ".Pattern";
- if (myResMgr->Find(aKey.ToCString()))
- aPattern = myResMgr->Value(aKey.ToCString());
- else if (myResMgrUser->Find(aKey.ToCString()))
- aPattern = myResMgrUser->Value(aKey.ToCString());
+ // Read Patterns for each supported format
+ for (int j = anOldLen+1; j <= theFormats->Length(); j++) {
+ TCollection_AsciiString aKey, aPattern;
+ aKey = theFormats->Value(j) + ".ExportPattern";
+ if (aResMgr->Find(aKey.ToCString()))
+ aPattern = aResMgr->Value(aKey.ToCString());
else {
- aPattern = theFormats->Value(j);
- aPattern += " Files ( *.* )";
+ aKey = theFormats->Value(j) + ".Pattern";
+ if (aResMgr->Find(aKey.ToCString()))
+ aPattern = aResMgr->Value(aKey.ToCString());
+ else {
+ aPattern = theFormats->Value(j);
+ aPattern += " Files ( *.* )";
+ }
}
+ thePatterns->Append(aPattern);
}
- thePatterns->Append(aPattern);
}
return (!theFormats->IsEmpty());
if (isImport) aMode = "Import";
else aMode = "Export";
- // Read supported formats for the certain mode from install directory
- if (myResMgr->Find(aMode.ToCString())) {
- TCollection_AsciiString aFormats (myResMgr->Value(aMode.ToCString()));
- if (aFormats.Search(theFormat) > -1) {
- // Read library name for the supported format
- TCollection_AsciiString aKey (theFormat);
- aKey += ".";
- aKey += aMode;
- if (myResMgr->Find(aKey.ToCString())) {
- TCollection_AsciiString aLibName (myResMgr->Value(aKey.ToCString()));
-#ifndef WNT
- aLibName += ".so";
-#else
- aLibName += ".dll";
-#endif
- theLibName = new TCollection_HAsciiString (aLibName);
- return Standard_True;
- }
- }
- }
-
// Read supported formats for the certain mode from user directory
- if (myResMgrUser->Find(aMode.ToCString())) {
- TCollection_AsciiString aFormats (myResMgrUser->Value(aMode.ToCString()));
- if (aFormats.Search(theFormat) > -1) {
- // Read library name for the supported format
- TCollection_AsciiString aKey (theFormat);
- aKey += ".";
- aKey += aMode;
- if (myResMgrUser->Find(aKey.ToCString())) {
- TCollection_AsciiString aLibName (myResMgrUser->Value(aKey.ToCString()));
- theLibName = new TCollection_HAsciiString (aLibName);
- return Standard_True;
+ Handle(Resource_Manager) aResMgr;
+ for(int index=0; index < myResMgrList.size(); index++) {
+ aResMgr = myResMgrList.at(index);
+ if (aResMgr->Find(aMode.ToCString())) {
+ TCollection_AsciiString aFormats (aResMgr->Value(aMode.ToCString()));
+ if (aFormats.Search(theFormat) > -1) {
+ // Read library name for the supported format
+ TCollection_AsciiString aKey (theFormat);
+ aKey += ".";
+ aKey += aMode;
+ if (aResMgr->Find(aKey.ToCString())) {
+ TCollection_AsciiString aLibName (aResMgr->Value(aKey.ToCString()));
+ #ifndef WIN32
+ if ( aLibName.Length() > 3 && aLibName.SubString(1,3) != "lib" )
+ aLibName.Prepend("lib");
+ aLibName += ".so";
+ #else
+ aLibName += ".dll";
+ #endif
+ theLibName = new TCollection_HAsciiString (aLibName);
+ return Standard_True;
+ }
}
}
}
//=============================================================================
Standard_Boolean GEOMImpl_IInsertOperations::InitResMgr()
{
- bool isResourceFound = false;
- bool isResourceFoundUser = false;
- TCollection_AsciiString aUserResDir,aResDir;
-
- if (myResMgr.IsNull()) {
- // Initialize the Resource Manager
- TCollection_AsciiString aNull;
- aResDir = TCollection_AsciiString(getenv("GEOM_ROOT_DIR"));
-#ifdef WNT
- aResDir += "\\share\\salome\\resources\\geom";
+ bool isResourceFound = false;
+ TCollection_AsciiString aNull;
+
+ myResMgrList.clear();
+
+ // Initialize the GEOM Resource Manager
+ TCollection_AsciiString aResDir;
+ aResDir = getenv("GEOM_ROOT_DIR");
+#ifdef WIN32
+ aResDir += "\\share\\salome\\resources\\geom";
#else
- aResDir += "/share/salome/resources/geom";
+ aResDir += "/share/salome/resources/geom";
#endif
-
- myResMgr = new Resource_Manager ("ImportExport", aResDir, aNull, Standard_False);
-
- isResourceFound = true;
- if (!myResMgr->Find("Import") && !myResMgr->Find("Export")) {
- // instead of complains in Resource_Manager
- isResourceFound = false;
- INFOS("No valid file \"ImportExport\" found in " << aResDir.ToCString());
- }
- } else
+ Handle(Resource_Manager) aGeomResMgr = new Resource_Manager ("ImportExport", aResDir, aNull, Standard_False);
+ if ( aGeomResMgr->Find("Import") || aGeomResMgr->Find("Export") ) {
+ myResMgrList.push_back( aGeomResMgr );
isResourceFound = true;
+ }
- if (myResMgrUser.IsNull()) {
- char * dir = getenv("GEOM_ENGINE_RESOURCES_DIR");
- TCollection_AsciiString aNull;
- if ( dir )
- {
- aUserResDir = dir;
+ // Initialize the user's Resource Manager
+ TCollection_AsciiString aResDirsStr;
+ aResDirsStr = getenv("GEOM_ENGINE_RESOURCES_DIR");
+ if ( !aResDirsStr.IsEmpty() )
+ {
+ std::string aSep = ":";
+#ifdef WIN32
+ aSep = ";";
+#endif
+ aResDir = aResDirsStr.Token(aSep.c_str(), 1);
+ for (int i = 1; !aResDir.IsEmpty(); aResDir = aResDirsStr.Token(aSep.c_str(), ++i)) {
+ Handle(Resource_Manager) anUserResMgr = new Resource_Manager ("ImportExport", aNull, aResDir, Standard_False);
+ if (anUserResMgr->Find("Import") || anUserResMgr->Find("Export")) {
+ myResMgrList.push_back( anUserResMgr );
+ isResourceFound = true;
+ }
}
- else
- {
- aUserResDir = getenv("HOME");
-#ifdef WNT
- aUserResDir += "\\.salome\\resources";
+ }
+ else
+ {
+ aResDir = getenv("HOME");
+#ifdef WIN32
+ aResDir += "\\.config\\salome";
#else
- aUserResDir += "/.salome/resources";
+ aResDir += "/.config/salome";
#endif
+ Handle(Resource_Manager) anUserResMgr = new Resource_Manager ("ImportExport", aNull, aResDir, Standard_False);
+ if (anUserResMgr->Find("Import") || anUserResMgr->Find("Export")) {
+ myResMgrList.push_back( anUserResMgr );
+ isResourceFound = true;
}
-
- myResMgrUser = new Resource_Manager ("ImportExport", aNull, aUserResDir, Standard_False);
-
- isResourceFoundUser = true;
-
- if (!myResMgrUser->Find("Import") && !myResMgrUser->Find("Export")) {
- // instead of complains in Resource_Manager
- isResourceFoundUser = false;
- }
-
- } else
- isResourceFoundUser = true;
-
- if(!isResourceFound && !isResourceFoundUser){
- INFOS("No valid file \"ImportExport\" found in " << aResDir.ToCString());
- INFOS("No valid file \"ImportExport\" found in " << aUserResDir.ToCString() );
}
-
- return ( myResMgr->Find("Import") || myResMgr->Find("Export") ||
- myResMgrUser->Find("Import") || myResMgrUser->Find("Export"));
+ return isResourceFound;
}
//=============================================================================
SetErrorCode(OK);
return id_list;
}
+
+TopAbs_ShapeEnum getGroupDimension(XAO::Group* group)
+{
+ XAO::Dimension dim = group->getDimension();
+ TopAbs_ShapeEnum rdim;
+ switch ( dim )
+ {
+ case XAO::VERTEX:
+ rdim = TopAbs_VERTEX; break;
+ case XAO::EDGE:
+ rdim = TopAbs_EDGE; break;
+ case XAO::FACE:
+ rdim = TopAbs_FACE; break;
+ case XAO::SOLID:
+ rdim = TopAbs_SOLID; break;
+ default:
+ rdim = TopAbs_COMPOUND; break;
+ }
+ return rdim;
+}
+
+XAO::Dimension shapeEnumToDimension(const TopAbs_ShapeEnum& shape)
+{
+ XAO::Dimension dim;
+ switch( shape ) {
+ case TopAbs_VERTEX:
+ dim = XAO::VERTEX; break;
+ case TopAbs_EDGE:
+ dim = XAO::EDGE; break;
+ case TopAbs_FACE:
+ dim = XAO::FACE; break;
+ case TopAbs_SOLID:
+ dim = XAO::SOLID; break;
+ default:
+ throw SALOME_Exception("Bad type"); // TODO
+ }
+ return dim;
+}
+
+void GEOMImpl_IInsertOperations::exportGroups(std::list<Handle(GEOM_Object)> groupList,
+ XAO::Xao* xaoObject,
+ XAO::BrepGeometry* geometry)
+{
+ // add the groups
+ std::list<Handle(GEOM_Object)>::iterator groupIterator = groupList.begin();
+ while (groupIterator != groupList.end())
+ {
+ Handle(GEOM_Object) currGroup = (*groupIterator++);
+ Handle(TColStd_HArray1OfInteger) groupIds = myGroupOperations->GetObjects(currGroup);
+
+ TopAbs_ShapeEnum shapeGroup = myGroupOperations->GetType(currGroup);
+ XAO::Dimension dim = shapeEnumToDimension(shapeGroup);
+ XAO::Group* group = xaoObject->addGroup(dim, currGroup->GetName().ToCString());
+
+ switch (shapeGroup)
+ {
+ case TopAbs_VERTEX:
+ for (int i = 1; i <= groupIds->Length(); i++)
+ {
+ std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
+ int index = geometry->getVertexIndexByReference(ref);
+ group->add(index);
+ }
+ break;
+ case TopAbs_EDGE:
+ for (int i = 1; i <= groupIds->Length(); i++)
+ {
+ std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
+ int index = geometry->getEdgeIndexByReference(ref);
+ group->add(index);
+ }
+ break;
+ case TopAbs_FACE:
+ for (int i = 1; i <= groupIds->Length(); i++)
+ {
+ std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
+ int index = geometry->getFaceIndexByReference(ref);
+ group->add(index);
+ }
+ break;
+ case TopAbs_SOLID:
+ for (int i = 1; i <= groupIds->Length(); i++)
+ {
+ std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
+ int index = geometry->getSolidIndexByReference(ref);
+ group->add(index);
+ }
+ break;
+ }
+ }
+}
+
+void GEOMImpl_IInsertOperations::exportFields(std::list<Handle(GEOM_Field)> fieldList,
+ XAO::Xao* xaoObject,
+ XAO::BrepGeometry* geometry)
+{
+ std::list<Handle(GEOM_Field)>::iterator fieldIterator = fieldList.begin();
+ while (fieldIterator != fieldList.end())
+ {
+ Handle(GEOM_Field) currField = (*fieldIterator++);
+
+ int fdim = currField->GetDimension();
+ int ftype = currField->GetDataType();
+ int nbComponents = currField->GetNbComponents();
+ std::string name = currField->GetName().ToCString();
+
+ XAO::Field* field = xaoObject->addField((XAO::Type)ftype, (XAO::Dimension)fdim, nbComponents, name);
+
+ Handle(TColStd_HArray1OfExtendedString) components = currField->GetComponents();
+ for (int i = components->Lower(), j = 0; i <= components->Upper(); ++i, ++j)
+ {
+ field->setComponentName(j, TCollection_AsciiString(components->Value(i)).ToCString());
+ }
+
+ std::list< Handle(GEOM_FieldStep)> steps = currField->GetSteps();
+ std::list<Handle(GEOM_FieldStep)>::iterator stepIterator = steps.begin();
+ while (stepIterator != steps.end())
+ {
+ Handle(GEOM_FieldStep) currStep = (*stepIterator++);
+
+ XAO::Step* step = field->addNewStep(currStep->GetID());
+ step->setStamp(currStep->GetStamp());
+
+ switch (ftype)
+ {
+ case 0: // bool
+ {
+ XAO::BooleanStep* bs = (XAO::BooleanStep*)step;
+ Handle(TColStd_HArray1OfInteger) bvalues = currStep->GetIntValues();
+ std::vector<bool> bv;
+ bv.reserve(bvalues->Upper());
+ for ( int i = bvalues->Lower(), nb = bvalues->Upper(); i <= nb; ++i )
+ {
+ bv.push_back(bvalues->Value(i) != 0);
+ }
+ bs->setValues(bv);
+ break;
+ }
+ case 1: // integer
+ {
+ XAO::IntegerStep* is = (XAO::IntegerStep*)step;
+ Handle(TColStd_HArray1OfInteger) ivalues = currStep->GetIntValues();
+ std::vector<int> iv;
+ iv.reserve(ivalues->Upper());
+ for ( int i = ivalues->Lower(), nb = ivalues->Upper(); i <= nb; ++i )
+ {
+ iv.push_back(ivalues->Value(i));
+ }
+ is->setValues(iv);
+ break;
+ }
+ case 2: // double
+ {
+ XAO::DoubleStep* ds = (XAO::DoubleStep*)step;
+ Handle(TColStd_HArray1OfReal) dvalues = currStep->GetDoubleValues();
+ std::vector<double> dv;
+ dv.reserve(dvalues->Upper());
+ for ( int i = dvalues->Lower(), nb = dvalues->Upper(); i <= nb; ++i )
+ {
+ dv.push_back(dvalues->Value(i));
+ }
+ ds->setValues(dv);
+ break;
+ }
+ case 3: // string
+ {
+ XAO::StringStep* ss = (XAO::StringStep*)step;
+ Handle(TColStd_HArray1OfExtendedString) svalues = currStep->GetStringValues();
+ std::vector<std::string> sv;
+ sv.reserve(svalues->Upper());
+ for ( int i = svalues->Lower(), nb = svalues->Upper(); i <= nb; ++i )
+ {
+ sv.push_back(TCollection_AsciiString(svalues->Value(i)).ToCString());
+ }
+ ss->setValues(sv);
+ break;
+ }
+ }
+ }
+ }
+}
+
+void GEOMImpl_IInsertOperations::exportSubshapes(const Handle(GEOM_Object)& shape, XAO::BrepGeometry* geometry)
+{
+ Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects(shape, false);
+ int nbSubObjects = subObjects->Length();
+ // set the names of the sub shapes
+ for (int i = 1; i <= nbSubObjects; i++)
+ {
+ Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
+ if (transientSubObject.IsNull())
+ continue;
+
+ Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast(transientSubObject);
+ if (subObject->GetType() != GEOM_GROUP)
+ {
+ int subIndex = myShapesOperations->GetSubShapeIndex(shape, subObject);
+ switch (subObject->GetValue().ShapeType())
+ {
+ case TopAbs_VERTEX:
+ geometry->changeVertexName(subIndex, subObject->GetName().ToCString());
+ break;
+ case TopAbs_EDGE:
+ geometry->changeEdgeName(subIndex, subObject->GetName().ToCString());
+ break;
+ case TopAbs_FACE:
+ geometry->changeFaceName(subIndex, subObject->GetName().ToCString());
+ break;
+ case TopAbs_SOLID:
+ geometry->changeSolidName(subIndex, subObject->GetName().ToCString());
+ break;
+ }
+ }
+ }
+}
+
+//=============================================================================
+/*!
+ * Export a shape to XAO format
+ * \param shape The shape to export
+ * \param groups The list of groups to export
+ * \param fields The list of fields to export
+ * \param fileName The name of the file to exported
+ * \return boolean indicating if export was succeful.
+ */
+//=============================================================================
+bool GEOMImpl_IInsertOperations::ExportXAO(Handle(GEOM_Object) shape,
+ std::list<Handle(GEOM_Object)> groupList,
+ std::list<Handle(GEOM_Field)> fieldList,
+ const char* author,
+ const char* fileName)
+{
+ SetErrorCode(KO);
+
+ if (shape.IsNull()) return false;
+
+ // add a new shape function with parameters
+ Handle(GEOM_Function) lastFunction = shape->GetLastFunction();
+ if (lastFunction.IsNull()) return false;
+
+ // add a new result object
+ Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
+
+ // add an Export function
+ Handle(GEOM_Function) exportFunction = result->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
+ if (exportFunction.IsNull()) return false;
+ if (exportFunction->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
+
+ // create the XAO object
+ XAO::Xao* xaoObject = new XAO::Xao();
+ xaoObject->setAuthor(author);
+
+ // add the geometry
+ XAO::BrepGeometry* geometry = (XAO::BrepGeometry*)XAO::Geometry::createGeometry(XAO::BREP);
+ TopoDS_Shape topoShape = shape->GetValue();
+ exportFunction->SetValue(topoShape);
+ XAO::BrepGeometry* brep = (XAO::BrepGeometry*)geometry;
+ brep->setTopoDS_Shape(topoShape);
+
+ geometry->setName(shape->GetName().ToCString());
+ exportSubshapes(shape, geometry);
+ xaoObject->setGeometry(geometry);
+
+ exportGroups(groupList, xaoObject, geometry);
+ exportFields(fieldList, xaoObject, geometry);
+
+ // export the XAO to the file
+ xaoObject->exportXAO(fileName);
+
+ // make a Python command
+ GEOM::TPythonDump pd(exportFunction);
+ pd << "exported = geompy.ExportXAO(" << shape;
+
+ // list of groups
+ pd << ", [";
+ if (groupList.size() > 0)
+ {
+ std::list<Handle(GEOM_Object)>::iterator itGroup = groupList.begin();
+ pd << (*itGroup++);
+ while (itGroup != groupList.end())
+ {
+ pd << ", " << (*itGroup++);
+ }
+ }
+
+ // list of fields
+ pd << "], [";
+ if (fieldList.size() > 0)
+ {
+ std::list<Handle(GEOM_Field)>::iterator itField = fieldList.begin();
+ pd << (*itField++);
+ while (itField != fieldList.end())
+ {
+ pd << ", " << (*itField++);
+ }
+ }
+ pd << "], ";
+ pd << "\"" << author << "\", \"" << fileName << "\")";
+
+ SetErrorCode(OK);
+ delete xaoObject;
+
+ return true;
+}
+
+void GEOMImpl_IInsertOperations::importSubShapes(XAO::Geometry* xaoGeometry,
+ Handle(GEOM_Function) function, int shapeType, int dim,
+ Handle(TColStd_HSequenceOfTransient)& subShapeList)
+{
+ Handle(GEOM_Object) subShape;
+ Handle(GEOM_Function) aFunction;
+ Handle(TColStd_HArray1OfInteger) anArray;
+
+ XAO::GeometricElementList::iterator elementIterator = xaoGeometry->begin((XAO::Dimension)dim);
+ for (; elementIterator != xaoGeometry->end((XAO::Dimension)dim); elementIterator++)
+ {
+ XAO::GeometricElement element = elementIterator->second;
+ if (!element.hasName())
+ continue;
+
+ std::string name = element.getName();
+ std::string ref = element.getReference();
+ int iref = XAO::XaoUtils::stringToInt(ref);
+
+ anArray = new TColStd_HArray1OfInteger(1, 1);
+ anArray->SetValue(1, iref);
+
+ subShape = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
+ Handle(GEOM_Function) aFunction = subShape->AddFunction(GEOM_Object::GetSubShapeID(), 1);
+ if (aFunction.IsNull())
+ return;
+
+ subShape->SetName(name.c_str());
+ subShape->SetType(shapeType);
+
+ GEOM_ISubShape aSSI(aFunction);
+ aSSI.SetMainShape(function);
+ aSSI.SetIndices(anArray);
+
+ //aFunction->SetValue(aValue);
+ subShapeList->Append(subShape);
+
+ // Put this subshape in the list of sub-shapes of theMainShape
+ function->AddSubShapeReference(aFunction);
+ }
+}
+
+//=============================================================================
+/*!
+ * Import a shape from XAO format
+ * \param fileName The name of the file to import
+ * \param shape The imported shape
+ * \param subShapes The list of imported groups
+ * \param groups The list of imported groups
+ * \param fields The list of imported fields
+ * \return boolean indicating if import was succeful.
+ */
+//=============================================================================
+bool GEOMImpl_IInsertOperations::ImportXAO(const char* fileName,
+ Handle(GEOM_Object)& shape,
+ Handle(TColStd_HSequenceOfTransient)& subShapes,
+ Handle(TColStd_HSequenceOfTransient)& groups,
+ Handle(TColStd_HSequenceOfTransient)& fields)
+{
+ SetErrorCode(KO);
+
+ if (fileName == NULL || groups.IsNull() || fields.IsNull())
+ return false;
+
+ // Read the XAO
+ XAO::Xao* xaoObject = new XAO::Xao();
+ try
+ {
+ xaoObject->importXAO(fileName);
+ }
+ catch (XAO::XAO_Exception& exc)
+ {
+ delete xaoObject;
+ SetErrorCode(exc.what());
+ return false;
+ }
+
+ XAO::Geometry* xaoGeometry = xaoObject->getGeometry();
+ if (xaoGeometry == NULL)
+ {
+ delete xaoObject;
+ SetErrorCode("Cannot import XAO: geometry format not supported.");
+ return false;
+ }
+
+ // create the shape
+ shape = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
+ Handle(GEOM_Function) function = shape->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
+ if (function.IsNull()) return false;
+ if (function->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
+
+ // set the geometry
+ if (xaoGeometry->getFormat() == XAO::BREP)
+ {
+ XAO::BrepGeometry* brep = (XAO::BrepGeometry*)xaoGeometry;
+ TopoDS_Shape geomShape = brep->getTopoDS_Shape();
+ function->SetValue(geomShape);
+ shape->SetName(xaoGeometry->getName().c_str());
+ }
+ else
+ {
+ delete xaoObject;
+ SetErrorCode("Cannot import XAO: geometry format not supported.");
+ return false;
+ }
+
+ // create sub shapes with names
+ importSubShapes(xaoGeometry, function, GEOM_POINT, XAO::VERTEX, subShapes);
+ importSubShapes(xaoGeometry, function, GEOM_EDGE, XAO::EDGE, subShapes);
+ importSubShapes(xaoGeometry, function, GEOM_FACE, XAO::FACE, subShapes);
+ importSubShapes(xaoGeometry, function, GEOM_SOLID, XAO::SOLID, subShapes);
+
+ // create groups
+ int nbGroups = xaoObject->countGroups();
+ for (int i = 0; i < nbGroups; ++i)
+ {
+ XAO::Group* xaoGroup = xaoObject->getGroup(i);
+
+ // build an array with the indexes of the sub shapes
+ int nbElt = xaoGroup->count();
+ Handle(TColStd_HArray1OfInteger) array = new TColStd_HArray1OfInteger(1, nbElt);
+ int j = 0;
+ for (std::set<int>::iterator it = xaoGroup->begin(); it != xaoGroup->end(); ++it)
+ {
+ int index = (*it);
+ std::string ref = xaoGeometry->getElementReference(xaoGroup->getDimension(), index);
+ array->SetValue(++j, XAO::XaoUtils::stringToInt(ref));
+ }
+
+ // create the group with the array of sub shapes indexes
+ Handle(GEOM_Object) group = GetEngine()->AddSubShape(shape, array);
+ group->SetType(GEOM_GROUP);
+ group->SetName(xaoGroup->getName().c_str());
+
+ // Set a sub-shape type
+ TDF_Label freeLabel = group->GetFreeLabel();
+ TDataStd_Integer::Set(freeLabel, (Standard_Integer) getGroupDimension(xaoGroup));
+ groups->Append(group);
+
+ function = group->GetLastFunction();
+ }
+
+ // create the fields
+ int nbFields = xaoObject->countFields();
+ for (int i = 0; i < nbFields; ++i)
+ {
+ XAO::Field* xaoField = xaoObject->getField(i);
+
+ Handle(TColStd_HArray1OfExtendedString) components = new TColStd_HArray1OfExtendedString(0, xaoField->countComponents()-1);
+ for (int j = 0; j < xaoField->countComponents(); ++j)
+ {
+ components->SetValue(j, (TCollection_ExtendedString)xaoField->getComponentName(j).c_str());
+ }
+
+ Handle(GEOM_Field) field = myFieldOperations->CreateField(shape,
+ xaoField->getName().c_str(),
+ (int)xaoField->getType(),
+ (int)xaoField->getDimension(),
+ components);
+
+ switch (xaoField->getType())
+ {
+ case XAO::BOOLEAN:
+ {
+ XAO::BooleanField* bfield = (XAO::BooleanField*)xaoField;
+ for (int j = 0; j < xaoField->countSteps(); ++j)
+ {
+ XAO::BooleanStep* bstep = bfield->getStep(j);
+ Handle(GEOM_FieldStep) step = field->AddStep(bstep->getStep(), bstep->getStamp());
+
+ Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, bstep->countValues()-1);
+ std::vector<bool> bvalues = bstep->getValues();
+ for (int k = 0; k < bstep->countValues(); ++k)
+ {
+ values->SetValue(k, bvalues[k] ? 1 : 0);
+ }
+ step->SetValues(values);
+ }
+ break;
+ }
+ case XAO::INTEGER:
+ {
+ XAO::IntegerField* ifield = (XAO::IntegerField*)xaoField;
+ for (int j = 0; j < xaoField->countSteps(); ++j)
+ {
+ XAO::IntegerStep* istep = ifield->getStep(j);
+ Handle(GEOM_FieldStep) step = field->AddStep(istep->getStep(), istep->getStamp());
+
+ Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, istep->countValues()-1);
+ std::vector<int> ivalues = istep->getValues();
+ for (int k = 0; k < istep->countValues(); ++k)
+ {
+ values->SetValue(k, ivalues[k]);
+ }
+ step->SetValues(values);
+ }
+ break;
+ }
+ case XAO::DOUBLE:
+ {
+ XAO::DoubleField* dfield = (XAO::DoubleField*)xaoField;
+ for (int j = 0; j < xaoField->countSteps(); ++j)
+ {
+ XAO::DoubleStep* dstep = dfield->getStep(j);
+ Handle(GEOM_FieldStep) step = field->AddStep(dstep->getStep(), dstep->getStamp());
+
+ Handle(TColStd_HArray1OfReal) values = new TColStd_HArray1OfReal(0, dstep->countValues()-1);
+ std::vector<double> dvalues = dstep->getValues();
+ for (int k = 0; k < dstep->countValues(); ++k)
+ {
+ values->SetValue(k, dvalues[k]);
+ }
+ step->SetValues(values);
+ }
+ break;
+ }
+ case XAO::STRING:
+ {
+ XAO::StringField* sfield = (XAO::StringField*)xaoField;
+ for (int j = 0; j < xaoField->countSteps(); ++j)
+ {
+ XAO::StringStep* sstep = sfield->getStep(j);
+ Handle(GEOM_FieldStep) step = field->AddStep(sstep->getStep(), sstep->getStamp());
+
+ Handle(TColStd_HArray1OfExtendedString) values = new TColStd_HArray1OfExtendedString(0, sstep->countValues()-1);
+ std::vector<std::string> svalues = sstep->getValues();
+ for (int k = 0; k < sstep->countValues(); ++k)
+ {
+ values->SetValue(k, TCollection_ExtendedString(svalues[k].c_str()));
+ }
+ step->SetValues(values);
+ }
+ break;
+ }
+ }
+
+ fields->Append(field);
+ }
+
+ // make a Python command
+ GEOM::TPythonDump pd(function);
+ pd << "(imported, " << shape << ", ";
+
+ // list of sub shapes
+ pd << "[";
+ int nbSubshapes = subShapes->Length();
+ if (nbSubshapes > 0)
+ {
+ for (int i = 1; i <= nbSubshapes; i++)
+ {
+ Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(subShapes->Value(i));
+ pd << obj << ((i < nbSubshapes) ? ", " : "");
+ }
+ }
+ pd << "], [";
+
+ // list of groups
+ if (nbGroups > 0)
+ {
+ for (int i = 1; i <= nbGroups; i++)
+ {
+ Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(groups->Value(i));
+ pd << obj << ((i < nbGroups) ? ", " : "");
+ }
+ }
+
+ pd << "], [";
+
+ // list of fields
+ if (nbFields > 0)
+ {
+ for (int i = 1; i <= nbFields; i++)
+ {
+ Handle(GEOM_Field) obj = Handle(GEOM_Field)::DownCast(fields->Value(i));
+ pd << obj << ((i < nbFields) ? ", " : "");
+ }
+ }
+ pd << "]";
+ pd << ") = geompy.ImportXAO(\"" << fileName << "\")";
+
+ delete xaoObject;
+ SetErrorCode(OK);
+
+ return true;
+}
+
+//=============================================================================
+/*!
+ * This method creates material groups for an imported object.
+ * \param theObject the imported object.
+ */
+//=============================================================================
+void GEOMImpl_IInsertOperations::MakeMaterialGroups
+ (const Handle(GEOM_Object) &theObject,
+ const Handle(TColStd_HSequenceOfTransient) &theSeq)
+{
+ TopoDS_Shape aResShape = theObject->GetValue();
+
+ if (aResShape.IsNull() == Standard_False) {
+ // Group shapes by material names.
+ Handle(GEOM_Function) aFunction = theObject->GetLastFunction();
+ DataMapOfStringListOfShape aMapMaterialShapes;
+
+ // check all named shapes using iterator
+ TDF_ChildIDIterator anIt (aFunction->GetNamingEntry(),
+ TNaming_NamedShape::GetID(), Standard_True);
+
+ for (; anIt.More(); anIt.Next()) {
+ Handle(TNaming_NamedShape) anAttr =
+ Handle(TNaming_NamedShape)::DownCast(anIt.Value());
+
+ if (anAttr.IsNull() == Standard_False) {
+ TDF_Label aLabel = anAttr->Label();
+ Handle(TDataStd_Comment) aComment;
+
+ if (aLabel.FindAttribute(TDataStd_Comment::GetID(), aComment)) {
+ TCollection_ExtendedString aMatName = aComment->Get();
+ TopoDS_Shape aShape = anAttr->Get();
+
+ if (aMapMaterialShapes.IsBound(aMatName) == Standard_False) {
+ NCollection_List<TopoDS_Shape> anEmptyList;
+
+ aMapMaterialShapes.Bind(aMatName, anEmptyList);
+ }
+
+ aMapMaterialShapes(aMatName).Append(aShape);
+ }
+ }
+ }
+
+ if (aMapMaterialShapes.IsEmpty() == Standard_False) {
+ // Construct groups.
+ TopAbs_ShapeEnum aType = aResShape.ShapeType();
+ Standard_Integer i;
+ DataMapOfStringListOfShape::Iterator aMapIter;
+
+ // Check each shape type.
+ for(i = aType; i <= TopAbs_VERTEX; i++) {
+ DataMapOfStringListOfShape::Iterator aMapIter(aMapMaterialShapes);
+
+ for (; aMapIter.More(); aMapIter.Next()) {
+ NCollection_List<TopoDS_Shape> &aShList = aMapIter.ChangeValue();
+ NCollection_List<TopoDS_Shape>::Iterator aShIter(aShList);
+ NCollection_List<TopoDS_Shape> aShListSameType;
+
+ while (aShIter.More()) {
+ const TopoDS_Shape &aShape = aShIter.Value();
+
+ if (i == aShape.ShapeType()) {
+ // Treat this element.
+ aShListSameType.Append(aShape);
+ aShList.Remove(aShIter);
+ } else {
+ // Go to the next element.
+ aShIter.Next();
+ }
+ }
+
+ if (aShListSameType.IsEmpty() == Standard_False) {
+ // Construct a group.
+ Handle(GEOM_Object) aGroup =
+ MakeGroup(theObject, aMapIter.Key(), aShListSameType);
+
+ if (aGroup.IsNull() == Standard_False) {
+ theSeq->Append(aGroup);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+
+//=============================================================================
+/*!
+ * This method creates a group of shapes of certain type.
+ * \param theObject the imported object.
+ * \param theName the material name.
+ * \param theShapes the list of shapes to be added to this group.
+ * \return the created group.
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IInsertOperations::MakeGroup
+ (const Handle(GEOM_Object) &theObject,
+ const TCollection_ExtendedString &theName,
+ const NCollection_List<TopoDS_Shape> &theShapes)
+{
+ Handle(GEOM_Object) aGroup;
+ TopTools_IndexedMapOfShape anIndices;
+ Handle(TColStd_HSequenceOfInteger) aSeqIDs = new TColStd_HSequenceOfInteger;
+ NCollection_List<TopoDS_Shape>::Iterator anIter(theShapes);
+
+ TopExp::MapShapes(theObject->GetValue(), anIndices);
+
+ // Compose shape IDs.
+ for (; anIter.More(); anIter.Next()) {
+ const TopoDS_Shape &aShape = anIter.Value();
+ const Standard_Integer anIndex = anIndices.FindIndex(aShape);
+
+ if (anIndex > 0) {
+ aSeqIDs->Append(anIndex);
+ }
+ }
+
+ if (aSeqIDs->IsEmpty() == Standard_False) {
+ // Create a group.
+ const TopAbs_ShapeEnum aType = theShapes.First().ShapeType();
+
+ aGroup = myGroupOperations->CreateGroup(theObject, aType);
+
+ if (aGroup.IsNull() == Standard_False) {
+ aGroup->GetLastFunction()->SetDescription("");
+ myGroupOperations->UnionIDs(aGroup, aSeqIDs);
+ aGroup->GetLastFunction()->SetDescription("");
+
+ // Compose the group name.
+ TCollection_AsciiString aGroupName(theName);
+
+ switch(aType) {
+ case TopAbs_VERTEX:
+ aGroupName += "_VERTEX";
+ break;
+ case TopAbs_EDGE:
+ aGroupName += "_EDGE";
+ break;
+ case TopAbs_WIRE:
+ aGroupName += "_WIRE";
+ break;
+ case TopAbs_FACE:
+ aGroupName += "_FACE";
+ break;
+ case TopAbs_SHELL:
+ aGroupName += "_SHELL";
+ break;
+ case TopAbs_SOLID:
+ aGroupName += "_SOLID";
+ break;
+ case TopAbs_COMPSOLID:
+ aGroupName += "_COMPSOLID";
+ break;
+ case TopAbs_COMPOUND:
+ aGroupName += "_COMPOUND";
+ break;
+ default:
+ aGroupName += "_SHAPE";
+ break;
+ }
+
+ aGroup->SetName(aGroupName.ToCString());
+ }
+ }
+
+ return aGroup;
+}
