-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 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
#include <GEOMImpl_ImportDriver.hxx>
#include <GEOMImpl_ICopy.hxx>
#include <GEOMImpl_IImportExport.hxx>
+#include <GEOMImpl_ITransferData.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 "GEOMImpl_IECallBack.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 "utilities.h"
-#include <OpUtil.hxx>
#include <Utils_ExceptHandlers.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 <BRepTools.hxx>
#include <gp_Pnt.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
*/
//=============================================================================
-GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID)
-: GEOM_IOperations(theEngine, theDocID)
+GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations(GEOM_Engine* theEngine)
+: GEOM_IOperations(theEngine)
{
MESSAGE("GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations");
- myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID());
- myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
- myFieldOperations = new GEOMImpl_IFieldOperations(GetEngine(), GetDocID());
+ myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine());
+ myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine());
+ myFieldOperations = new GEOMImpl_IFieldOperations(GetEngine());
}
//=============================================================================
if (theOriginal.IsNull()) return NULL;
//Add a new Copy object
- Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
+ Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GEOM_COPY);
//Add a Copy function for creation a copy object
Handle(GEOM_Function) aFunction = aCopy->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITH_REF);
//Compute the Copy value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Copy driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
if (theOriginal.IsNull()) return;
- Handle(GEOM_Function) aRefFunction = theOriginal->GetLastFunction();
- if (aRefFunction.IsNull()) return; //There is no function which creates an object to be exported
-
- //Add a new result object
- Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
-
- //Add an Export function
- Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_ExportDriver::GetID(), EXPORT_SHAPE);
- if (aFunction.IsNull()) return;
-
- //Check if the function is set correctly
- if (aFunction->GetDriverGUID() != GEOMImpl_ExportDriver::GetID()) return;
-
- Handle(TCollection_HAsciiString) aHLibName;
- if (!IsSupported(Standard_False, theFormatName, aHLibName)) {
+ if ( !GEOMImpl_IECallBack::GetCallBack( theFormatName )->Export( theOriginal, theFileName, theFormatName ) )
return;
- }
- TCollection_AsciiString aLibName = aHLibName->String();
-
- //Set parameters
- GEOMImpl_IImportExport aCI (aFunction);
- aCI.SetOriginal(aRefFunction);
- aCI.SetFileName(theFileName);
- aCI.SetFormatName(theFormatName);
- aCI.SetPluginName(aLibName);
-
- //Perform the Export
- try {
-#if OCC_VERSION_LARGE > 0x06010000
- OCC_CATCH_SIGNALS;
-#endif
- if (!GetSolver()->ComputeFunction(aFunction)) {
- SetErrorCode("Not enough space on disk, or you haven't permissions to write this directory");
- return;
- }
- }
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
- return;
- }
-
- //Make a Python command
- GEOM::TPythonDump(aFunction) << "geompy.Export(" << theOriginal << ", \""
- << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";
-
SetErrorCode(OK);
}
if (theFileName.IsEmpty() || theFormatName.IsEmpty()) return NULL;
- //Add a new result object
- Handle(GEOM_Object) anImported = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
-
- //Add an Import function
- 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 NULL;
-
- Handle(TCollection_HAsciiString) aHLibName;
- if (!IsSupported
- (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
- return NULL;
- }
- TCollection_AsciiString aLibName = aHLibName->String();
-
- //Set parameters
- GEOMImpl_IImportExport aCI (aFunction);
- aCI.SetFileName(theFileName);
- aCI.SetFormatName(theFormatName);
- aCI.SetPluginName(aLibName);
-
- //Perform the Import
- Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
-
- try {
-#if OCC_VERSION_LARGE > 0x06010000
- OCC_CATCH_SIGNALS;
-#endif
- if (!GetSolver()->ComputeFunction(aFunction)) {
- 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();
- SetErrorCode(aFail->GetMessageString());
- return NULL;
- }
-
- //Make a Python command
- 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() << "\")";
- }
- }
-
+ Handle(TColStd_HSequenceOfTransient) aSeq =
+ GEOMImpl_IECallBack::GetCallBack( theFormatName )->Import( theFormatName, theFileName );
SetErrorCode(OK);
-
- // OLD CODE: begin
- if (theFormatName == "IGES_UNIT") {
- TopoDS_Shape S = aFunction->GetValue();
- TopoDS_Vertex V = TopoDS::Vertex(S);
- gp_Pnt P = BRep_Tool::Pnt(V);
- double scale = P.X();
- TCollection_AsciiString aUnitName = "UNIT_M";
- if (fabs(scale-0.01) < 1.e-6)
- aUnitName = "UNIT_CM";
- else if (fabs(scale-0.001) < 1.e-6)
- aUnitName = "UNIT_MM";
- //cout<<"IIO: aUnitName = "<<aUnitName.ToCString()<<endl;
- SetErrorCode(aUnitName);
- }
- // OLD CODE: end
-
return aSeq;
}
const TCollection_AsciiString& theParameterName)
{
SetErrorCode(KO);
-
- TCollection_AsciiString aValue, anError;
-
+ TCollection_AsciiString aValue;
if (theFileName.IsEmpty() || theFormatName.IsEmpty() || theParameterName.IsEmpty()) return aValue;
- Handle(TCollection_HAsciiString) aHLibName;
- if (!IsSupported
- (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
- return aValue;
- }
- TCollection_AsciiString aLibName = aHLibName->String();
-
- aValue = GEOMImpl_ImportDriver::ReadValue(theFileName, aLibName, theParameterName, anError);
- if (anError.IsEmpty())
- SetErrorCode(OK);
- else
- SetErrorCode(anError.ToCString());
+ aValue = GEOMImpl_IECallBack::GetCallBack( theFormatName )->ReadValue( theFileName, theFormatName, theParameterName );
+ SetErrorCode(OK);
return aValue;
}
-//=============================================================================
-/*!
- * ImportTranslators
- */
-//=============================================================================
-Standard_Boolean GEOMImpl_IInsertOperations::ImportTranslators
- (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
- Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
-{
- if (theFormats.IsNull())
- theFormats = new TColStd_HSequenceOfAsciiString;
- else
- theFormats->Clear();
-
- if (thePatterns.IsNull())
- thePatterns = new TColStd_HSequenceOfAsciiString;
- else
- thePatterns->Clear();
-
- if (!InitResMgr()) return Standard_False;
-
- // 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);
- }
- }
-
- // 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 {
- 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);
- }
- }
-
- return (!theFormats->IsEmpty());
-}
-
-//=============================================================================
-/*!
- * ExportTranslators
- */
-//=============================================================================
-Standard_Boolean GEOMImpl_IInsertOperations::ExportTranslators
- (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
- Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
-{
- if (theFormats.IsNull())
- theFormats = new TColStd_HSequenceOfAsciiString;
- else
- theFormats->Clear();
-
- if (thePatterns.IsNull())
- thePatterns = new TColStd_HSequenceOfAsciiString;
- else
- thePatterns->Clear();
-
- if (!InitResMgr()) return Standard_False;
-
- // 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);
- }
- }
-
- // 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 {
- 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);
- }
- }
-
- return (!theFormats->IsEmpty());
-}
-
-//=============================================================================
-/*!
- * IsSupported
- */
-//=============================================================================
-Standard_Boolean GEOMImpl_IInsertOperations::IsSupported
- (const Standard_Boolean isImport,
- const TCollection_AsciiString& theFormat,
- Handle(TCollection_HAsciiString)& theLibName)
-{
- if (!InitResMgr()) return Standard_False;
-
- // Import/Export mode
- TCollection_AsciiString aMode;
- //Standard_CString aMode;
- if (isImport) aMode = "Import";
- else aMode = "Export";
-
- // Read supported formats for the certain mode from user directory
- 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;
- }
- }
- }
- }
-
- return Standard_False;
-}
-
-//=============================================================================
-/*!
- * InitResMgr
- */
-//=============================================================================
-Standard_Boolean GEOMImpl_IInsertOperations::InitResMgr()
-{
- 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";
-#endif
- 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;
- }
-
- // 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
- {
- aResDir = getenv("HOME");
-#ifdef WIN32
- aResDir += "\\.config\\salome";
-#else
- 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;
- }
- }
- return isResourceFound;
-}
-
//=============================================================================
/*!
* RestoreShape
SetErrorCode(KO);
//Add a new result object
- Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
+ Handle(GEOM_Object) result = GetEngine()->AddObject(GEOM_COPY);
//Add a Copy function
Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF);
//See correcponding code in GEOM_Engine.cxx (method ProcessFunction)
//GEOM::TPythonDump(aFunction) << "#";
- GEOM::TPythonDump(aFunction) << result
+ bool ignore = false;
+
+ if ( const char* env_var = getenv( "GEOM_IGNORE_RESTORE_SHAPE" ) )
+ ignore = atoi( env_var ) > 1;
+
+ if ( !ignore ) {
+ GEOM::TPythonDump(aFunction) << result
<< " = geompy.RestoreShape(\"\") # the shape string has not been dump for performance reason";
+ }
SetErrorCode(OK);
if (theTextureFile.IsEmpty()) return 0;
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
Handle(TColStd_HArray1OfByte) aTexture;
-#else
- Handle(TDataStd_HArray1OfByte) aTexture;
-#endif
FILE* fp = fopen(theTextureFile.ToCString(), "r");
if (!fp) return 0;
std::list<std::string>::const_iterator it;
for (it = lines.begin(); it != lines.end(); ++it) {
std::string line = *it;
- int lenline = (line.size()/8 + (line.size()%8 ? 1 : 0)) * 8;
- for (int i = 0; i < lenline/8; i++) {
+ size_t lenline = (line.size()/8 + (line.size()%8 ? 1 : 0)) * 8;
+ for (size_t i = 0; i < lenline/8; i++) {
unsigned char byte = 0;
for (int j = 0; j < 8; j++)
byte = (byte << 1) + ( i*8+j < line.size() && line[i*8+j] != '0' ? 1 : 0 );
if (bytedata.empty() || bytedata.size() != lines.size()*lenbytes)
return 0;
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
aTexture = new TColStd_HArray1OfByte (1, lines.size()*lenbytes);
-#else
- aTexture = new TDataStd_HArray1OfByte (1, lines.size()*lenbytes);
-#endif
std::list<unsigned char>::iterator bdit;
int i;
for (i = 1, bdit = bytedata.begin(); bdit != bytedata.end(); ++bdit, ++i)
aTexture->SetValue(i, (Standard_Byte)(*bdit));
- int aTextureId = GetEngine()->addTexture(GetDocID(), lenbytes*8, lines.size(), aTexture, theTextureFile);
+ int aTextureId = GetEngine()->addTexture(lenbytes*8, lines.size(), aTexture, theTextureFile);
if (aTextureId > 0) SetErrorCode(OK);
return aTextureId;
}
int GEOMImpl_IInsertOperations::AddTexture(int theWidth, int theHeight,
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
const Handle(TColStd_HArray1OfByte)& theTexture)
-#else
- const Handle(TDataStd_HArray1OfByte)& theTexture)
-#endif
{
SetErrorCode(KO);
- int aTextureId = GetEngine()->addTexture(GetDocID(), theWidth, theHeight, theTexture);
+ int aTextureId = GetEngine()->addTexture(theWidth, theHeight, theTexture);
if (aTextureId > 0) SetErrorCode(OK);
return aTextureId;
}
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
Handle(TColStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
-#else
-Handle(TDataStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
-#endif
- int& theWidth, int& theHeight)
+ int& theWidth, int& theHeight)
{
SetErrorCode(KO);
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
Handle(TColStd_HArray1OfByte) aTexture;
-#else
- Handle(TDataStd_HArray1OfByte) aTexture;
-#endif
theWidth = theHeight = 0;
TCollection_AsciiString aFileName;
if (theTextureId <= 0)
return aTexture;
- aTexture = GetEngine()->getTexture(GetDocID(), theTextureId, theWidth, theHeight, aFileName);
+ aTexture = GetEngine()->getTexture(theTextureId, theWidth, theHeight, aFileName);
if (theWidth > 0 && theHeight > 0 && aTexture->Length() > 0) SetErrorCode(OK);
std::list<int> GEOMImpl_IInsertOperations::GetAllTextures()
{
SetErrorCode(KO);
- std::list<int> id_list = GetEngine()->getAllTextures(GetDocID());
+ std::list<int> id_list = GetEngine()->getAllTextures();
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.
+ * TransferData
*/
//=============================================================================
-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)
+bool GEOMImpl_IInsertOperations::TransferData
+ (const Handle(GEOM_Object) &theObjectFrom,
+ const Handle(GEOM_Object) &theObjectTo,
+ const int theFindMethod,
+ std::list<TransferDatum> &theResult)
{
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++);
- }
+ if (theObjectFrom.IsNull() || theObjectTo.IsNull()) {
+ return false;
}
- // 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;
-}
+ //Add a new Transfer Data object object
+ Handle(GEOM_Object) aTDObj =
+ GetEngine()->AddObject(GEOM_TRANSFER_DATA);
-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);
- }
-}
+ //Add a Transfer Data function for created object
+ Handle(GEOM_Function) aFunction =
+ aTDObj->AddFunction(GEOMImpl_CopyDriver::GetID(), TRANSFER_DATA);
-//=============================================================================
-/*!
- * 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.");
+ //Check if the function is set correctly
+ if(aFunction->GetDriverGUID() != GEOMImpl_CopyDriver::GetID()) {
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.");
+
+ Handle(GEOM_Function) aFunctionFrom = theObjectFrom->GetLastFunction();
+ Handle(GEOM_Function) aFunctionTo = theObjectTo->GetLastFunction();
+
+ if (aFunctionFrom.IsNull() || aFunctionTo.IsNull()) {
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;
- }
- }
+ GEOMImpl_ITransferData aTD(aFunction);
- 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) ? ", " : "");
+ aTD.SetRef1(aFunctionFrom);
+ aTD.SetRef2(aFunctionTo);
+ aTD.SetFindMethod(theFindMethod);
+
+ // Transfer data
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Transfer data failed");
+ return false;
}
}
-
- 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) ? ", " : "");
- }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return false;
}
- 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());
+ // Fill result list of data.
+ theResult.clear();
- if (anAttr.IsNull() == Standard_False) {
- TDF_Label aLabel = anAttr->Label();
- Handle(TDataStd_Comment) aComment;
+ Handle(TColStd_HArray1OfExtendedString) aDatumName = aTD.GetDatumName();
+ Handle(TColStd_HArray1OfInteger) aDatumMaxVal = aTD.GetDatumMaxVal();
+ Handle(TColStd_HArray1OfInteger) aDatumVal = aTD.GetDatumVal();
- if (aLabel.FindAttribute(TDataStd_Comment::GetID(), aComment)) {
- TCollection_ExtendedString aMatName = aComment->Get();
- TopoDS_Shape aShape = anAttr->Get();
+ if (!aDatumName.IsNull() && !aDatumMaxVal.IsNull() && !aDatumVal.IsNull()) {
+ Standard_Integer i;
+ Standard_Integer aNbDatum = aDatumName->Length();
- if (aMapMaterialShapes.IsBound(aMatName) == Standard_False) {
- NCollection_List<TopoDS_Shape> anEmptyList;
+ for (i = 1; i <= aNbDatum; ++i) {
+ if (aDatumMaxVal->Value(i) > 0) {
+ TransferDatum aDatum;
- 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);
- }
- }
- }
+ aDatum.myName = TCollection_AsciiString(aDatumName->Value(i));
+ aDatum.myNumber = aDatumVal->Value(i);
+ aDatum.myMaxNumber = aDatumMaxVal->Value(i);
+ theResult.push_back(aDatum);
}
}
}
-}
-
-//=============================================================================
-/*!
- * 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);
- }
+ //Make a Python command
+ GEOM::TPythonDump pd (aFunction);
+ pd << "geompy.TransferData(" << theObjectFrom << ", " << theObjectTo;
+ pd << ", GEOM.";
+
+ switch (theFindMethod) {
+ case TD_GET_IN_PLACE:
+ pd << "FSM_GetInPlace";
+ break;
+ case TD_GET_IN_PLACE_OLD:
+ pd << "FSM_GetInPlace_Old";
+ break;
+ case TD_GET_IN_PLACE_BY_HISTORY:
+ default:
+ pd << "FSM_GetInPlaceByHistory";
+ break;
}
+ pd << ")";
- 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());
- }
- }
+ SetErrorCode(OK);
- return aGroup;
+ return true;
}
