// Copyright (C) 2014-2015 CEA/DEN, EDF R&D, OPEN CASCADE // // 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, 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 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // // internal includes #include "XAOPlugin_IOperations.hxx" #include "XAOPlugin_Driver.hxx" #include "XAOPlugin_IImportExport.hxx" // KERNEL includes #include #include // GEOM includes #include "GEOM_PythonDump.hxx" #include "GEOMImpl_Types.hxx" #include "GEOMImpl_IGroupOperations.hxx" #include "GEOMImpl_IShapesOperations.hxx" #include "GEOMImpl_IFieldOperations.hxx" #include "GEOM_ISubShape.hxx" #include #include #include #include #include #include #include #include #include #include #include #include // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC // OCC includes #include #include #include 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; } 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; } //============================================================================= /*! * Constructor */ //============================================================================= XAOPlugin_IOperations::XAOPlugin_IOperations( GEOM_Engine* theEngine, int theDocID ) : GEOMImpl_IBaseIEOperations( theEngine, theDocID ) { MESSAGE( "XAOPlugin_IOperations::XAOPlugin_IOperations" ); } //============================================================================= /*! * Destructor */ //============================================================================= XAOPlugin_IOperations::~XAOPlugin_IOperations() { MESSAGE( "XAOPlugin_IOperations::~XAOPlugin_IOperations" ); } void XAOPlugin_IOperations::exportGroups( std::list groupList, XAO::Xao* xaoObject, XAO::BrepGeometry* geometry ) { // add the groups std::list::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 XAOPlugin_IOperations::exportFields( std::list fieldList, XAO::Xao* xaoObject, XAO::BrepGeometry* geometry ) { std::list::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::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 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 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 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 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 XAOPlugin_IOperations::exportSubshapes( const Handle(GEOM_Object)& shape, XAO::BrepGeometry* geometry ) { Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects( shape, GEOMImpl_IShapesOperations::SubShapes ); 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 XAOPlugin_IOperations::ExportXAO( Handle(GEOM_Object) shape, std::list groupList, std::list 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(XAOPlugin_Driver::GetID(), EXPORT_SHAPE); if (exportFunction.IsNull()) return false; if (exportFunction->GetDriverGUID() != XAOPlugin_Driver::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::iterator itGroup = groupList.begin(); pd << (*itGroup++); while (itGroup != groupList.end()) { pd << ", " << (*itGroup++); } } // list of fields pd << "], ["; if (fieldList.size() > 0) { std::list::iterator itField = fieldList.begin(); pd << (*itField++); while (itField != fieldList.end()) { pd << ", " << (*itField++); } } pd << "], "; pd << "\"" << author << "\", \"" << fileName << "\")"; SetErrorCode(OK); delete xaoObject; return true; } void XAOPlugin_IOperations::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 XAOPlugin_IOperations::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(XAOPlugin_Driver::GetID(), IMPORT_SHAPE); if (function.IsNull()) return false; if (function->GetDriverGUID() != XAOPlugin_Driver::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::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 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 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 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 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; }