ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2025-02-05 16:44:17 +05:00
Code Issues Packages Projects Releases Wiki Activity

import/export XAO for topology and groups + rework

Browse Source
This commit is contained in:
fps 2013-04-09 12:00:09 +00:00
parent e508f5a4cc
commit 37b0d2eb73
28 changed files with 2273 additions and 726 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
configure.ac
View File

@ -359,6 +359,14 @@ echo
CHECK_KERNEL CHECK_KERNEL
echo
echo ---------------------------------------------
echo Testing cppunit
echo ---------------------------------------------
echo
CHECK_CPPUNIT
echo echo
echo --------------------------------------------- echo ---------------------------------------------
echo Summary echo Summary
@ -373,7 +381,7 @@ fi
echo echo
obligatory_vars="cc_ok lex_yacc_ok python_ok swig_ok threads_ok vtk_ok hdf5_ok omniORB_ok boost_ok libxml_ok occ_ok doxygen_ok graphviz_ok sphinx_ok Kernel_ok" obligatory_vars="cc_ok lex_yacc_ok python_ok swig_ok threads_ok vtk_ok hdf5_ok omniORB_ok boost_ok libxml_ok occ_ok doxygen_ok graphviz_ok sphinx_ok Kernel_ok"
optional_vars="opencv_ok" optional_vars="opencv_ok cppunit_ok"
gui_vars="OpenGL_ok qt_ok gui_ok" gui_vars="OpenGL_ok qt_ok gui_ok"
### ###
@ -496,6 +504,7 @@ AC_OUTPUT([ \
src/Makefile \ src/Makefile \
src/AdvancedGUI/Makefile \ src/AdvancedGUI/Makefile \
src/XAO/Makefile \ src/XAO/Makefile \
src/XAO/tests/Makefile \
src/ImportExportGUI/Makefile \ src/ImportExportGUI/Makefile \
src/ARCHIMEDE/Makefile \ src/ARCHIMEDE/Makefile \
src/BREPExport/Makefile \ src/BREPExport/Makefile \

12
src/GEOMGUI/GEOM_msg_en.ts
View File

@ -5762,21 +5762,25 @@ Do you want to create new material?</translation>
</context> </context>
<context> <context>
<name>@default</name> <name>@default</name>
<message>
<source>MEN_IMPORTEXPORT</source>
<translation>Import / Export</translation>
</message>
<message> <message>
<source>TOP_EXPORTXAO</source> <source>TOP_EXPORTXAO</source>
<translation>ExportXAO</translation> <translation>Export to XAO</translation>
</message> </message>
<message> <message>
<source>MEN_EXPORTXAO</source> <source>MEN_EXPORTXAO</source>
<translation>ExportXAO</translation> <translation>Export XAO</translation>
</message> </message>
<message> <message>
<source>STB_EXPORTXAO</source> <source>STB_EXPORTXAO</source>
<translation>ExportXAO</translation> <translation>Export shape to XAO format</translation>
</message> </message>
<message> <message>
<source>GEOM_IMPORTEXPORT_204</source> <source>GEOM_IMPORTEXPORT_204</source>
<translation>ExportXAO</translation> <translation>Export XAO</translation>
</message> </message>
</context> </context>
</TS> </TS>

368
src/GEOMImpl/GEOMImpl_IImportExportOperations.cxx
View File

@ -19,6 +19,10 @@
// File : GEOMImpl_IImportExportOperations.cxx // File : GEOMImpl_IImportExportOperations.cxx
// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com) // Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
#include <cmath>
#include <iostream>
#include <sstream>
#include <Standard_Stream.hxx> #include <Standard_Stream.hxx>
#include "GEOMImpl_Types.hxx" #include "GEOMImpl_Types.hxx"
@ -46,6 +50,7 @@
#include "Xao.hxx" #include "Xao.hxx"
#include "Geometry.hxx" #include "Geometry.hxx"
#include "Group.hxx" #include "Group.hxx"
#include "XaoUtils.hxx"
#include <GEOMImpl_ExportXAODriver.hxx> #include <GEOMImpl_ExportXAODriver.hxx>
#include <GEOMImpl_IExportXAO.hxx> #include <GEOMImpl_IExportXAO.hxx>
@ -68,7 +73,9 @@
#include <gp_Ax3.hxx> #include <gp_Ax3.hxx>
#include <BRepBuilderAPI_Transform.hxx> #include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <cmath> #include <BRep_Builder.hxx>
#include <BRepTools.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>
@ -76,26 +83,25 @@
#include <TDF_Tool.hxx> #include <TDF_Tool.hxx>
#include <Standard_Failure.hxx> #include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
//============================================================================= //=============================================================================
/*! /*!
* Constructor * Constructor
*/ */
//============================================================================= //=============================================================================
GEOMImpl_IImportExportOperations::GEOMImpl_IImportExportOperations(GEOM_Engine* theEngine, int theDocID) : GEOMImpl_IImportExportOperations::GEOMImpl_IImportExportOperations(GEOM_Engine* engine, int docID) :
GEOM_IOperations(theEngine, theDocID) GEOM_IOperations(engine, docID)
{ {
MESSAGE("GEOMImpl_IImportExportOperations::GEOMImpl_IImportExportOperations"); MESSAGE("GEOMImpl_IImportExportOperations::GEOMImpl_IImportExportOperations");
/*myBasicOperations = new GEOMImpl_IBasicOperations(GetEngine(), GetDocID()); /*myBasicOperations = new GEOMImpl_IBasicOperations(GetEngine(), GetDocID());
myBooleanOperations = new GEOMImpl_IBooleanOperations(GetEngine(), GetDocID()); myBooleanOperations = new GEOMImpl_IBooleanOperations(GetEngine(), GetDocID());
myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID()); myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID());
myTransformOperations = new GEOMImpl_ITransformOperations(GetEngine(), GetDocID()); myTransformOperations = new GEOMImpl_ITransformOperations(GetEngine(), GetDocID());
myBlocksOperations = new GEOMImpl_IBlocksOperations(GetEngine(), GetDocID()); myBlocksOperations = new GEOMImpl_IBlocksOperations(GetEngine(), GetDocID());
my3DPrimOperations = new GEOMImpl_I3DPrimOperations(GetEngine(), GetDocID()); my3DPrimOperations = new GEOMImpl_I3DPrimOperations(GetEngine(), GetDocID());
myLocalOperations = new GEOMImpl_ILocalOperations(GetEngine(), GetDocID()); myLocalOperations = new GEOMImpl_ILocalOperations(GetEngine(), GetDocID());
myHealingOperations = new GEOMImpl_IHealingOperations(GetEngine(), GetDocID());*/ myHealingOperations = new GEOMImpl_IHealingOperations(GetEngine(), GetDocID());*/
myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID()); m_shapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID());
myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID()); m_groupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
} }
//============================================================================= //=============================================================================
@ -105,160 +111,224 @@ GEOMImpl_IImportExportOperations::GEOMImpl_IImportExportOperations(GEOM_Engine*
//============================================================================= //=============================================================================
GEOMImpl_IImportExportOperations::~GEOMImpl_IImportExportOperations() GEOMImpl_IImportExportOperations::~GEOMImpl_IImportExportOperations()
{ {
MESSAGE("GEOMImpl_IImportExportOperations::~GEOMImpl_IImportExportOperations"); MESSAGE("GEOMImpl_IImportExportOperations::~GEOMImpl_IImportExportOperations");
/*delete myBasicOperations; /*delete myBasicOperations;
delete myBooleanOperations; delete myBooleanOperations;
delete myShapesOperations; delete myShapesOperations;
delete myTransformOperations; delete myTransformOperations;
delete myBlocksOperations; delete myBlocksOperations;
delete my3DPrimOperations; delete my3DPrimOperations;
delete myLocalOperations; delete myLocalOperations;
delete myHealingOperations;*/ delete myHealingOperations;*/
delete myShapesOperations; delete m_shapesOperations;
delete myGroupOperations; delete m_groupOperations;
} }
//============================================================================= //=============================================================================
/*! /*!
* Export a shape to XAO Format * Export a shape to XAO Format
* \param theExportingShape Shape to export * \param shape The shape to export
* \param theFileName The name of the exported file * \param fileName The name of the exported file
* \param thelGroups List of groups to export * \param groupList The list of groups to export
* \param thelFields List of fields to export * \param fieldList The list of fields to export
* \return New GEOM_Object, containing the created shape. * \return New GEOM_Object, containing the created shape.
*/ */
//============================================================================= //=============================================================================
bool GEOMImpl_IImportExportOperations::ExportXAO (Handle(GEOM_Object) theExportingShape, const std::string theFileName, std::list<Handle(GEOM_Object)> thelGroups, std::list<Handle(GEOM_Object)> thelFields) bool GEOMImpl_IImportExportOperations::ExportXAO(Handle(GEOM_Object) shape,
const std::string fileName,
std::list<Handle(GEOM_Object)> groupList,
std::list<Handle(GEOM_Object)> fieldList)
{ {
SetErrorCode(KO); std::cout << ">> ExportXAO" << std::endl;
bool isGood = false; SetErrorCode(KO);
bool isGood = false;
//
//Add a new shape function with parameters //
Handle(GEOM_Function) aRefFunction = theExportingShape->GetLastFunction();
if (aRefFunction.IsNull()) return false;
//Add a new result object // add a new shape function with parameters
Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT); Handle(GEOM_Function) lastFunction = shape->GetLastFunction();
if (lastFunction.IsNull())
//Add an Export function return false;
Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_ExportXAODriver::GetID(), EXPORTXAO_EXPORTINGSHAPE_FILENAME_LGROUPS_LFIELDS);
if (aFunction.IsNull()) return false;
//Check if the function is set correctly
if (aFunction->GetDriverGUID() != GEOMImpl_ExportXAODriver::GetID()) return false;
/*GEOMImpl_IExportXAO aData (aRefFunction); // add a new result object
Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
TCollection_AsciiString FileName = theFileName.c_str(); // add an Export function
aData.SetExportingShape(aRefFunction); Handle(GEOM_Function) exportFunction = result->AddFunction(GEOMImpl_ExportXAODriver::GetID(),
aData.SetFileName(FileName); EXPORTXAO_EXPORTINGSHAPE_FILENAME_LGROUPS_LFIELDS);
aData.SetlGroups(thelGroups); if (exportFunction.IsNull())
aData.SetlFields(thelFields); return false;
//Compute the resulting value // check if the function is set correctly
try { if (exportFunction->GetDriverGUID() != GEOMImpl_ExportXAODriver::GetID())
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100 return false;
OCC_CATCH_SIGNALS;
#endif /*GEOMImpl_IExportXAO aData (aRefFunction);
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("ExportXAO driver failed : Not enough space on disk, or you haven't permissions to write this directory"); TCollection_AsciiString FileName = theFileName.c_str();
return false; aData.SetExportingShape(aRefFunction);
} aData.SetFileName(FileName);
} aData.SetlGroups(thelGroups);
catch (Standard_Failure) { aData.SetlFields(thelFields);
Handle(Standard_Failure) aFail = Standard_Failure::Caught();
SetErrorCode(aFail->GetMessageString()); //Compute the resulting value
return false; try {
}*/ #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
TCollection_AsciiString FileName = theFileName.c_str(); OCC_CATCH_SIGNALS;
XAO::Xao *myXao = new XAO::Xao(); #endif
XAO::Geometry *myGeometry = new XAO::Geometry(); if (!GetSolver()->ComputeFunction(aFunction)) {
myGeometry->setShape(theExportingShape->GetValue()); SetErrorCode("ExportXAO driver failed : Not enough space on disk, or you haven't permissions to write this directory");
myGeometry->setName(theExportingShape->GetName()); return false;
Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects(theExportingShape, false); }
int nbSubObjects = subObjects->Length(); }
for (int i = 1 ; i <= nbSubObjects ; i++) { catch (Standard_Failure) {
Handle(Standard_Transient) anTransientSubObject = subObjects->Value(i); Handle(Standard_Failure) aFail = Standard_Failure::Caught();
if (anTransientSubObject.IsNull()) SetErrorCode(aFail->GetMessageString());
continue; return false;
Handle(GEOM_Object) asubObject = Handle(GEOM_Object)::DownCast(anTransientSubObject); }*/
if (asubObject->GetType() != GEOM_GROUP) XAO::Xao* xaoObject = new XAO::Xao();
XAO::Geometry* geometry = new XAO::Geometry();
TopoDS_Shape topoShape = shape->GetValue();
std::ostringstream dumpStream;
BRepTools::Dump(topoShape, dumpStream);
geometry->setShape(dumpStream.str().c_str());
geometry->setName(shape->GetName());
Handle(TColStd_HSequenceOfTransient) subObjects = m_shapesOperations->GetExistingSubObjects(shape, false);
int nbSubObjects = subObjects->Length();
std::cout << "nb sub obj = " << nbSubObjects << std::endl;
int nbVertices = 0, nbEdges = 0, nbFaces = 0, nbSolids = 0, nbGroups = 0;
for (int i = 1; i <= nbSubObjects; i++)
{ {
int index = myShapesOperations->GetSubShapeIndex(theExportingShape,asubObject); Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
switch (asubObject->GetValue().ShapeType() ) if (transientSubObject.IsNull())
{ continue;
case TopAbs_SOLID:
break; Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast(transientSubObject);
case TopAbs_FACE: if (subObject->GetType() == GEOM_GROUP)
break; {
case TopAbs_EDGE: nbGroups++;
break; }
case TopAbs_VERTEX: else
myGeometry->setVertexName(index,asubObject->GetName()); {
break; switch (subObject->GetValue().ShapeType())
} {
} case TopAbs_VERTEX: nbVertices++; break;
} case TopAbs_EDGE: nbEdges++; break;
myXao->setGeometry(myGeometry); case TopAbs_FACE: nbFaces++; break;
case TopAbs_SOLID: nbSolids++; break;
// Adding groups }
std::list<Handle(GEOM_Object)>::iterator itG1 = thelGroups.begin(); }
while (itG1 != thelGroups.end()) {
Handle(GEOM_Object) itGroup = (*itG1++);
XAO::Group *Group = new XAO::Group();
Group->setName(itGroup->GetName());
Handle(TColStd_HArray1OfInteger) groupIds = myGroupOperations->GetObjects(itGroup);
TopAbs_ShapeEnum shapeGroup = myGroupOperations->GetType(itGroup);
if (shapeGroup == TopAbs_VERTEX)
{
Group->setType(0);
for (int i = 1; i <= groupIds->Length(); i++)
{
int index = myGeometry->findVertex(groupIds->Value(i));
Group->addValue(index);
}
} }
myXao->addGroup(Group);
/*{
case TopAbs_SOLID:
Group->setType(3);
break;
case TopAbs_FACE:
Group->setType(2);
break;
case TopAbs_EDGE:
Group->setType(1);
break;
case TopAbs_VERTEX:
Group->setType(0);
break;
} */
} std::cout << "Nb = " << nbVertices << ", " << nbEdges << ", " << nbFaces << ", " << nbSolids << ", " << nbGroups << std::endl;
if (nbVertices > 0) geometry->setCountVertices(nbVertices);
if (nbEdges > 0) geometry->setCountEdges(nbEdges);
if (nbFaces > 0) geometry->setCountFaces(nbFaces);
if (nbSolids > 0) geometry->setCountSolids(nbSolids);
//Make a Python command int vInd = 0, eInd = 0, fInd = 0, sInd = 0;
GEOM::TPythonDump pd (aFunction); for (int i = 1; i <= nbSubObjects; i++)
std::list<Handle(GEOM_Object)>::iterator itG = thelGroups.begin(); {
std::list<Handle(GEOM_Object)>::iterator itF = thelFields.begin(); Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
pd << /*isGood <<*/ " = geompy.ExportXAO(" << theExportingShape << ", " << FileName.ToCString() << ", ["; if (transientSubObject.IsNull())
continue;
pd << (*itG++); Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast(transientSubObject);
while (itG != thelGroups.end()) { std::cout << " sub[" << i << "] N=" << subObject->GetName()
pd << ", " << (*itG++); //<< " E=" << subObject->GetEntry()
} //<< " D=" << subObject->GetDocID()
pd << "], ["; << " T=" << subObject->GetType() << std::endl;
pd << (*itF++); if (subObject->GetType() != GEOM_GROUP)
while (itF != thelFields.end()) { {
pd << ", " << (*itF++); int index = m_shapesOperations->GetSubShapeIndex(shape, subObject);
} const char* strIndex = XAO::XaoUtils::intToString(index);
pd << "])"; std::cout << " index= " << index << std::endl;
switch (subObject->GetValue().ShapeType())
{
case TopAbs_VERTEX:
geometry->setVertex(vInd++, subObject->GetName(), strIndex);
break;
case TopAbs_EDGE:
geometry->setEdge(eInd++, subObject->GetName(), strIndex);
break;
case TopAbs_FACE:
geometry->setFace(fInd++, subObject->GetName(), strIndex);
break;
case TopAbs_SOLID:
geometry->setSolid(sInd++, subObject->GetName(), strIndex);
break;
}
}
}
xaoObject->setGeometry(geometry);
SetErrorCode(OK); xaoObject->exportToFile(fileName.c_str());
return isGood; /*
// adding groups
std::list<Handle(GEOM_Object)>::iterator itG1 = groupList.begin();
int gInd = 0;
while (itG1 != groupList.end())
{
std::cout << "Group = " << gInd++ << std::endl;
Handle(GEOM_Object) itGroup = (*itG1++);
XAO::Group* group = new XAO::Group();
group->setName(itGroup->GetName());
Handle(TColStd_HArray1OfInteger) groupIds = m_groupOperations->GetObjects(itGroup);
TopAbs_ShapeEnum shapeGroup = m_groupOperations->GetType(itGroup);
std::cout << "GroupShape = " << shapeGroup << std::endl;
if (shapeGroup == TopAbs_VERTEX)
{
group->setDimension(0);
for (int i = 1; i <= groupIds->Length(); i++)
{
const char* index = geometry->getVertexReference(groupIds->Value(i));
group->addElement(index);
}
}
xaoObject->addGroup(group);
/*{
case TopAbs_SOLID:
Group->setType(3);
break;
case TopAbs_FACE:
Group->setType(2);
break;
case TopAbs_EDGE:
Group->setType(1);
break;
case TopAbs_VERTEX:
Group->setType(0);
break;
} *
}*/
/*
// make a Python command
TCollection_AsciiString fileNameStr = fileName.c_str();
GEOM::TPythonDump pd(exportFunction);
std::list<Handle(GEOM_Object)>::iterator itG = groupList.begin();
std::list<Handle(GEOM_Object)>::iterator itF = fieldList.begin();
//pd << /*isGood <<**" = geompy.ExportXAO(" << shape << ", " << fileNameStr.ToCString() << ", [";
pd << (*itG++);
while (itG != groupList.end())
{
pd << ", " << (*itG++);
}
pd << "], [";
pd << (*itF++);
while (itF != fieldList.end())
{
pd << ", " << (*itF++);
}
pd << "])";*/
SetErrorCode(OK);
return isGood;
} }
/*@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@*/ /*@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@*/

52
src/GEOMImpl/GEOMImpl_IImportExportOperations.hxx
View File

@ -30,35 +30,39 @@
#include <list> #include <list>
/*class GEOMImpl_IBasicOperations; /*class GEOMImpl_IBasicOperations;
class GEOMImpl_IBooleanOperations; class GEOMImpl_IBooleanOperations;
class GEOMImpl_IShapesOperations; class GEOMImpl_IShapesOperations;
class GEOMImpl_ITransformOperations; class GEOMImpl_ITransformOperations;
class GEOMImpl_IBlocksOperations; class GEOMImpl_IBlocksOperations;
class GEOMImpl_I3DPrimOperations; class GEOMImpl_I3DPrimOperations;
class GEOMImpl_ILocalOperations; class GEOMImpl_ILocalOperations;
class GEOMImpl_IHealingOperations;*/ class GEOMImpl_IHealingOperations;*/
class GEOMImpl_IShapesOperations; class GEOMImpl_IShapesOperations;
class GEOMImpl_IGroupOperations; class GEOMImpl_IGroupOperations;
class GEOMImpl_IImportExportOperations: public GEOM_IOperations { class GEOMImpl_IImportExportOperations: public GEOM_IOperations
{
private: private:
/*GEOMImpl_IBasicOperations* myBasicOperations; /*GEOMImpl_IBasicOperations* myBasicOperations;
GEOMImpl_IBooleanOperations* myBooleanOperations; GEOMImpl_IBooleanOperations* myBooleanOperations;
GEOMImpl_IShapesOperations* myShapesOperations; GEOMImpl_IShapesOperations* myShapesOperations;
GEOMImpl_ITransformOperations* myTransformOperations; GEOMImpl_ITransformOperations* myTransformOperations;
GEOMImpl_IBlocksOperations* myBlocksOperations; GEOMImpl_IBlocksOperations* myBlocksOperations;
GEOMImpl_I3DPrimOperations* my3DPrimOperations; GEOMImpl_I3DPrimOperations* my3DPrimOperations;
GEOMImpl_ILocalOperations* myLocalOperations; GEOMImpl_ILocalOperations* myLocalOperations;
GEOMImpl_IHealingOperations* myHealingOperations;*/ GEOMImpl_IHealingOperations* myHealingOperations;*/
GEOMImpl_IShapesOperations* myShapesOperations; GEOMImpl_IShapesOperations* m_shapesOperations;
GEOMImpl_IGroupOperations* myGroupOperations; GEOMImpl_IGroupOperations* m_groupOperations;
public: public:
Standard_EXPORT GEOMImpl_IImportExportOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IImportExportOperations(GEOM_Engine* engine, int docID);
Standard_EXPORT ~GEOMImpl_IImportExportOperations(); Standard_EXPORT ~GEOMImpl_IImportExportOperations();
Standard_EXPORT bool ExportXAO (Handle(GEOM_Object) theExportingShape, const std::string theFileName, std::list<Handle(GEOM_Object)> thelGroups, std::list<Handle(GEOM_Object)> thelFields); Standard_EXPORT bool ExportXAO (Handle(GEOM_Object) shape,
/*@@ insert new functions before this line @@ do not remove this line @@*/ const std::string fileName,
std::list<Handle(GEOM_Object)> groupList,
std::list<Handle(GEOM_Object)> fieldList);
/*@@ insert new functions before this line @@ do not remove this line @@*/
}; };
#endif #endif

5
src/GEOMImpl/Makefile.am
View File

@ -237,11 +237,12 @@ dist_libGEOMimpl_la_SOURCES += $(IMPORTEXPORT_SOURCES)
libGEOMimpl_la_CPPFLAGS = \ libGEOMimpl_la_CPPFLAGS = \
$(CORBA_CXXFLAGS) \ $(CORBA_CXXFLAGS) \
$(CORBA_INCLUDES) \ $(CORBA_INCLUDES) \
$(CAS_CPPFLAGS) \ $(CAS_CPPFLAGS) \
$(KERNEL_CXXFLAGS) \ $(KERNEL_CXXFLAGS) \
$(BOOST_CPPFLAGS) \ $(BOOST_CPPFLAGS) \
$(PYTHON_INCLUDES) \ $(PYTHON_INCLUDES) \
$(LIBXML_INCLUDES) \
-I$(srcdir)/../ShHealOper \ -I$(srcdir)/../ShHealOper \
-I$(srcdir)/../NMTDS \ -I$(srcdir)/../NMTDS \
-I$(srcdir)/../NMTTools \ -I$(srcdir)/../NMTTools \

49
src/ImportExportGUI/ImportExportGUI.cxx
View File

@ -41,7 +41,8 @@
// function : ImportExportGUI() // function : ImportExportGUI()
// purpose : Constructor // purpose : Constructor
//======================================================================= //=======================================================================
ImportExportGUI::ImportExportGUI( GeometryGUI* parent ) : GEOMGUI( parent ) ImportExportGUI::ImportExportGUI(GeometryGUI* parent) :
GEOMGUI(parent)
{ {
} }
@ -57,30 +58,30 @@ ImportExportGUI::~ImportExportGUI()
// function : OnGUIEvent() // function : OnGUIEvent()
// purpose : // purpose :
//======================================================================= //=======================================================================
bool ImportExportGUI::OnGUIEvent( int theCommandID, SUIT_Desktop* parent ) bool ImportExportGUI::OnGUIEvent(int commandId, SUIT_Desktop* parent)
{ {
SalomeApp_Application* app = getGeometryGUI()->getApp(); SalomeApp_Application* app = getGeometryGUI()->getApp();
if ( !app ) return false; if (!app) return false;
getGeometryGUI()->EmitSignalDeactivateDialog(); getGeometryGUI()->EmitSignalDeactivateDialog();
QDialog* aDlg = NULL;
switch ( theCommandID ) { QDialog* dialog = NULL;
case GEOMOp::OpExportXAO: switch (commandId)
cout << "test" << endl; {
aDlg = new ImportExportGUI_ExportXAODlg( getGeometryGUI(), parent ); case GEOMOp::OpExportXAO:
break; dialog = new ImportExportGUI_ExportXAODlg(getGeometryGUI(), parent);
//@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@// break;
default: //@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@//
app->putInfo( tr( "GEOM_PRP_COMMAND" ).arg( theCommandID ) ); default:
break; app->putInfo(tr("GEOM_PRP_COMMAND").arg(commandId));
} break;
}
if ( aDlg != NULL ) if (dialog != NULL)
aDlg->show(); dialog->show();
return true; return true;
} }
//===================================================================================== //=====================================================================================
@ -89,10 +90,10 @@ bool ImportExportGUI::OnGUIEvent( int theCommandID, SUIT_Desktop* parent )
extern "C" extern "C"
{ {
#ifdef WIN32 #ifdef WIN32
__declspec( dllexport ) __declspec( dllexport )
#endif #endif
GEOMGUI* GetLibGUI( GeometryGUI* parent ) GEOMGUI* GetLibGUI(GeometryGUI* parent)
{ {
return new ImportExportGUI( parent ); return new ImportExportGUI(parent);
} }
} }

12
src/ImportExportGUI/ImportExportGUI.h
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -24,18 +24,18 @@
#define IMPORTEXPORTGUI_H #define IMPORTEXPORTGUI_H
#include "GEOMGUI.h" #include "GEOMGUI.h"
//================================================================================= //=================================================================================
// class : ImportExportGUI // class : ImportExportGUI
// purpose : // purpose :
//================================================================================= //=================================================================================
class ImportExportGUI : public GEOMGUI class ImportExportGUI: public GEOMGUI
{ {
public: public:
ImportExportGUI( GeometryGUI* ); ImportExportGUI(GeometryGUI* parent);
~ImportExportGUI(); ~ImportExportGUI();
bool OnGUIEvent( int, SUIT_Desktop* ); bool OnGUIEvent(int commandId, SUIT_Desktop* parent);
}; };
#endif // IMPORTEXPORTGUI_H #endif // IMPORTEXPORTGUI_H

280
src/ImportExportGUI/ImportExportGUI_ExportXAODlg.cxx
View File

@ -1,7 +1,4 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2013 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 // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -19,9 +16,6 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#include "ImportExportGUI_ExportXAODlg.h"
//#include "ImportExportGUI_Widgets.h"
#include <DlgRef.h> #include <DlgRef.h>
#include <GeometryGUI.h> #include <GeometryGUI.h>
#include <GEOMBase.h> #include <GEOMBase.h>
@ -47,84 +41,86 @@
#include <TopTools_IndexedMapOfShape.hxx> #include <TopTools_IndexedMapOfShape.hxx>
#include <GEOMImpl_Types.hxx> #include <GEOMImpl_Types.hxx>
#include "ImportExportGUI_ExportXAODlg.h"
//#include "ImportExportGUI_Widgets.h"
//================================================================================= //=================================================================================
// Constructor // Constructor
//================================================================================= //=================================================================================
ImportExportGUI_ExportXAODlg::ImportExportGUI_ExportXAODlg (GeometryGUI* theGeometryGUI, QWidget* parent) ImportExportGUI_ExportXAODlg::ImportExportGUI_ExportXAODlg(GeometryGUI* geometryGUI, QWidget* parent)
: GEOMBase_Skeleton(theGeometryGUI, parent, false) :
GEOMBase_Skeleton(geometryGUI, parent, false)
{ {
myMainObj = GEOM::GEOM_Object::_nil(); m_mainObj = GEOM::GEOM_Object::_nil();
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
QPixmap imageOp (resMgr->loadPixmap("GEOM", tr("ICON_DLG_EXPORTXAO_EXPORTINGSHAPE_FILENAME_LGROUPS_LFIELDS")));
QPixmap iconSelect (resMgr->loadPixmap("GEOM", tr("ICON_SELECT")));
setWindowTitle(tr("GEOM_EXPORTXAO_TITLE")); SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
QPixmap imageOp(resMgr->loadPixmap("GEOM", tr("ICON_DLG_EXPORTXAO_EXPORTINGSHAPE_FILENAME_LGROUPS_LFIELDS")));
QPixmap iconSelect(resMgr->loadPixmap("GEOM", tr("ICON_SELECT")));
/***************************************************************/ setWindowTitle(tr("GEOM_EXPORTXAO_TITLE"));
mainFrame()->GroupConstructors->setTitle( tr( "GEOM_EXPORTXAO_TITLE" ) );
mainFrame()->RadioButton1->setIcon( imageOp ); /***************************************************************/
mainFrame()->RadioButton2->setAttribute( Qt::WA_DeleteOnClose ); mainFrame()->GroupConstructors->setTitle(tr("GEOM_EXPORTXAO_TITLE"));
mainFrame()->RadioButton2->close(); mainFrame()->RadioButton1->setIcon(imageOp);
mainFrame()->RadioButton3->setAttribute( Qt::WA_DeleteOnClose ); mainFrame()->RadioButton2->setAttribute(Qt::WA_DeleteOnClose);
mainFrame()->RadioButton3->close(); mainFrame()->RadioButton2->close();
mainFrame()->RadioButton3->setAttribute(Qt::WA_DeleteOnClose);
mainFrame()->RadioButton3->close();
QGroupBox *GroupBoxExport = new QGroupBox(parent);
QGroupBox* gbxExport = new QGroupBox(parent);
QGridLayout *gridLayoutExport = new QGridLayout(GroupBoxExport);
QGridLayout *gridLayoutExport = new QGridLayout(gbxExport);
#ifndef Q_OS_MAC #ifndef Q_OS_MAC
gridLayoutExport->setSpacing(6); gridLayoutExport->setSpacing(6);
#endif #endif
#ifndef Q_OS_MAC #ifndef Q_OS_MAC
gridLayoutExport->setContentsMargins(9, 9, 9, 9); gridLayoutExport->setContentsMargins(9, 9, 9, 9);
#endif #endif
gridLayoutExport->setObjectName(QString::fromUtf8("gridLayoutExport")); gridLayoutExport->setObjectName(QString::fromUtf8("gridLayoutExport"));
//**************************** //****************************
QLabel *TextLabel1 = new QLabel(tr( "GEOM_EXPORTXAO_EXPORTINGSHAPE" ),GroupBoxExport); QLabel* txtLabel1 = new QLabel(tr("GEOM_EXPORTXAO_EXPORTINGSHAPE"), gbxExport);
gridLayoutExport->addWidget(TextLabel1, 0, 0, 1, 1); gridLayoutExport->addWidget(txtLabel1, 0, 0, 1, 1);
mySelBtn = new QPushButton(GroupBoxExport); btnSelect = new QPushButton(gbxExport);
mySelBtn->setIcon(iconSelect); btnSelect->setIcon(iconSelect);
gridLayoutExport->addWidget(mySelBtn, 0, 1, 1, 1); gridLayoutExport->addWidget(btnSelect, 0, 1, 1, 1);
myMainShape = new QLineEdit(GroupBoxExport); ledShape = new QLineEdit(gbxExport);
myMainShape->setMinimumSize(QSize(100, 0)); ledShape->setMinimumSize(QSize(100, 0));
gridLayoutExport->addWidget(myMainShape, 0, 2, 1, 1); gridLayoutExport->addWidget(ledShape, 0, 2, 1, 1);
//**************************** //****************************
QLabel *TextLabel2 = new QLabel(tr( "GEOM_EXPORTXAO_FILENAME" ),GroupBoxExport); QLabel* txtLabel2 = new QLabel(tr("GEOM_EXPORTXAO_FILENAME"), gbxExport);
gridLayoutExport->addWidget(TextLabel2, 1, 0, 1, 1); gridLayoutExport->addWidget(txtLabel2, 1, 0, 1, 1);
myMainFile = new QLineEdit(GroupBoxExport); ledFileName = new QLineEdit(gbxExport);
gridLayoutExport->addWidget(myMainFile, 1, 1, 1, 2); gridLayoutExport->addWidget(ledFileName, 1, 1, 1, 2);
//**************************** //****************************
QLabel *TextLabel3 = new QLabel(tr( "GEOM_EXPORTXAO_LGROUPS" ),GroupBoxExport); QLabel* txtLabel3 = new QLabel(tr("GEOM_EXPORTXAO_LGROUPS"), gbxExport);
gridLayoutExport->addWidget(TextLabel3, 2, 0, 1, 2); gridLayoutExport->addWidget(txtLabel3, 2, 0, 1, 2);
myListGroups = new QListWidget(GroupBoxExport);
gridLayoutExport->addWidget(myListGroups, 3, 0, 1, 2);
QLabel *TextLabel4 = new QLabel(tr( "GEOM_EXPORTXAO_LFIELDS" ),GroupBoxExport); lstGroups = new QListWidget(gbxExport);
gridLayoutExport->addWidget(TextLabel4, 2, 2, 1, 1); gridLayoutExport->addWidget(lstGroups, 3, 0, 1, 2);
myListFields = new QListWidget(GroupBoxExport); QLabel* txtLabel4 = new QLabel(tr("GEOM_EXPORTXAO_LFIELDS"), gbxExport);
gridLayoutExport->addWidget(myListFields, 3, 2, 1, 1); gridLayoutExport->addWidget(txtLabel4, 2, 2, 1, 1);
lstFields = new QListWidget(gbxExport);
gridLayoutExport->addWidget(lstFields, 3, 2, 1, 1);
QVBoxLayout* layout = new QVBoxLayout(centralWidget()); QVBoxLayout* layout = new QVBoxLayout(centralWidget());
layout->setMargin(0); layout->setSpacing(6); layout->setMargin(0);
layout->addWidget(GroupBoxExport); layout->setSpacing(6);
layout->addWidget(gbxExport);
//QWidget::setTabOrder(PushButton1, LineEdit1); //QWidget::setTabOrder(PushButton1, LineEdit1);
//QWidget::setTabOrder(LineEdit1, LineEdit2); //QWidget::setTabOrder(LineEdit1, LineEdit2);
setHelpFileName("create_exportxao_page.html");
Init(); setHelpFileName("create_exportxao_page.html");
Init();
} }
//================================================================================= //=================================================================================
@ -132,7 +128,7 @@ ImportExportGUI_ExportXAODlg::ImportExportGUI_ExportXAODlg (GeometryGUI* theGeom
//================================================================================= //=================================================================================
ImportExportGUI_ExportXAODlg::~ImportExportGUI_ExportXAODlg() ImportExportGUI_ExportXAODlg::~ImportExportGUI_ExportXAODlg()
{ {
// no need to delete child widgets, Qt does it all for us // no need to delete child widgets, Qt does it all for us
} }
//================================================================================= //=================================================================================
@ -141,20 +137,20 @@ ImportExportGUI_ExportXAODlg::~ImportExportGUI_ExportXAODlg()
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::Init() void ImportExportGUI_ExportXAODlg::Init()
{ {
// Get setting of step value from file configuration // Get setting of step value from file configuration
myGroups.clear(); m_groups.clear();
myFields.clear(); m_fields.clear();
// Signal/slot connections // Signal/slot connections
connect(buttonOk(), SIGNAL(clicked()), this, SLOT(ClickOnOk())); connect(buttonOk(), SIGNAL(clicked()), this, SLOT(ClickOnOk()));
connect(buttonApply(), SIGNAL(clicked()), this, SLOT(ClickOnApply())); connect(buttonApply(), SIGNAL(clicked()), this, SLOT(ClickOnApply()));
connect( mySelBtn, SIGNAL( clicked() ), this, SLOT( SetEditCurrentArgument() ) ); connect(btnSelect, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
connect( ( (SalomeApp_Application*)( SUIT_Session::session()->activeApplication() ) )->selectionMgr(), connect(((SalomeApp_Application*) (SUIT_Session::session()->activeApplication()))->selectionMgr(),
SIGNAL( currentSelectionChanged() ), this, SLOT( SelectionIntoArgument() ) ); SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
initName(tr("GEOM_EXPORTXAO")); initName(tr("GEOM_EXPORTXAO"));
SelectionIntoArgument(); SelectionIntoArgument();
} }
//================================================================================= //=================================================================================
@ -163,20 +159,22 @@ void ImportExportGUI_ExportXAODlg::Init()
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::processObject() void ImportExportGUI_ExportXAODlg::processObject()
{ {
if ( myMainObj->_is_nil() ) { if (m_mainObj->_is_nil())
myMainShape->setText( "" );
myMainFile->setText( "" );
}
else {
myMainShape->setText( GEOMBase::GetName( myMainObj ) );
GEOM::GEOM_IShapesOperations_var aShOp = getGeomEngine()->GetIShapesOperations(getStudyId());
GEOM::ListOfGO_var Groups = aShOp->GetExistingSubObjects(myMainObj, true);
// Affichage des noms des groupes
for ( int i = 0, n = Groups->length(); i < n; i++ )
{ {
myListGroups->addItem( GEOMBase::GetName( Groups[i] ) ); ledShape->setText("");
ledFileName->setText("");
}
else
{
ledShape->setText(GEOMBase::GetName(m_mainObj));
GEOM::GEOM_IShapesOperations_var aShOp = getGeomEngine()->GetIShapesOperations(getStudyId());
GEOM::ListOfGO_var Groups = aShOp->GetExistingSubObjects(m_mainObj, true);
// Affichage des noms des groupes
for (int i = 0, n = Groups->length(); i < n; i++)
{
lstGroups->addItem(GEOMBase::GetName(Groups[i]));
}
} }
}
} }
//================================================================================= //=================================================================================
@ -185,8 +183,8 @@ void ImportExportGUI_ExportXAODlg::processObject()
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::ClickOnOk() void ImportExportGUI_ExportXAODlg::ClickOnOk()
{ {
if (ClickOnApply()) if (ClickOnApply())
ClickOnCancel(); ClickOnCancel();
} }
//================================================================================= //=================================================================================
@ -195,12 +193,12 @@ void ImportExportGUI_ExportXAODlg::ClickOnOk()
//================================================================================= //=================================================================================
bool ImportExportGUI_ExportXAODlg::ClickOnApply() bool ImportExportGUI_ExportXAODlg::ClickOnApply()
{ {
if (!onAccept()) if (!onAccept())
return false; return false;
initName(); initName();
return true; return true;
} }
//================================================================================= //=================================================================================
@ -209,27 +207,27 @@ bool ImportExportGUI_ExportXAODlg::ClickOnApply()
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::SelectionIntoArgument() void ImportExportGUI_ExportXAODlg::SelectionIntoArgument()
{ {
myMainObj = GEOM::GEOM_Object::_nil(); m_mainObj = GEOM::GEOM_Object::_nil();
LightApp_SelectionMgr* aSelMgr = myGeomGUI->getApp()->selectionMgr(); LightApp_SelectionMgr* selMgr = myGeomGUI->getApp()->selectionMgr();
SALOME_ListIO aSelList; SALOME_ListIO selList;
aSelMgr->selectedObjects(aSelList); selMgr->selectedObjects(selList);
if (aSelList.Extent() != 1) { if (selList.Extent() != 1)
{
processObject();
return;
}
/*GEOM::GEOM_Object_var aSelectedObject*/m_mainObj = GEOMBase::ConvertIOinGEOMObject(selList.First());
/*if ( aSelectedObject->_is_nil() ) {
processObject();
return;
}*/
//myMainObj = aSelectedObject;
processObject(); processObject();
return;
}
/*GEOM::GEOM_Object_var aSelectedObject*/myMainObj = GEOMBase::ConvertIOinGEOMObject( aSelList.First() );
/*if ( aSelectedObject->_is_nil() ) {
processObject();
return;
}*/
//myMainObj = aSelectedObject;
processObject();
} }
//================================================================================= //=================================================================================
@ -238,9 +236,9 @@ void ImportExportGUI_ExportXAODlg::SelectionIntoArgument()
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::SetEditCurrentArgument() void ImportExportGUI_ExportXAODlg::SetEditCurrentArgument()
{ {
myMainShape->setFocus(); ledShape->setFocus();
myEditCurrentArgument = myMainShape; myEditCurrentArgument = ledShape;
SelectionIntoArgument(); SelectionIntoArgument();
} }
//================================================================================= //=================================================================================
// function : ActivateThisDialog() // function : ActivateThisDialog()
@ -248,17 +246,17 @@ void ImportExportGUI_ExportXAODlg::SetEditCurrentArgument()
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::ActivateThisDialog() void ImportExportGUI_ExportXAODlg::ActivateThisDialog()
{ {
GEOMBase_Skeleton::ActivateThisDialog(); GEOMBase_Skeleton::ActivateThisDialog();
} }
//================================================================================= //=================================================================================
// function : enterEvent [REDEFINED] // function : enterEvent [REDEFINED]
// purpose : // purpose :
//================================================================================= //=================================================================================
void ImportExportGUI_ExportXAODlg::enterEvent (QEvent*) void ImportExportGUI_ExportXAODlg::enterEvent(QEvent*)
{ {
if (!mainFrame()->GroupConstructors->isEnabled()) if (!mainFrame()->GroupConstructors->isEnabled())
ActivateThisDialog(); ActivateThisDialog();
} }
//================================================================================= //=================================================================================
@ -267,47 +265,51 @@ void ImportExportGUI_ExportXAODlg::enterEvent (QEvent*)
//================================================================================= //=================================================================================
GEOM::GEOM_IOperations_ptr ImportExportGUI_ExportXAODlg::createOperation() GEOM::GEOM_IOperations_ptr ImportExportGUI_ExportXAODlg::createOperation()
{ {
return getGeomEngine()->GetIImportExportOperations(getStudyId()); return getGeomEngine()->GetIImportExportOperations(getStudyId());
} }
//================================================================================= //=================================================================================
// function : isValid // function : isValid
// purpose : // purpose :
//================================================================================= //=================================================================================
bool ImportExportGUI_ExportXAODlg::isValid (QString& msg) bool ImportExportGUI_ExportXAODlg::isValid(QString& msg)
{ {
bool ok = true; bool ok = true;
//@@ add custom validation actions here @@// //@@ add custom validation actions here @@//
return ok; return ok;
} }
//================================================================================= //=================================================================================
// function : execute // function : execute
// purpose : // purpose :
//================================================================================= //=================================================================================
bool ImportExportGUI_ExportXAODlg::execute (ObjectList& objects) bool ImportExportGUI_ExportXAODlg::execute(ObjectList& objects)
{ {
bool res = false; bool res = false;
GEOM::GEOM_Object_var anObj; GEOM::GEOM_Object_var obj;
GEOM::GEOM_IImportExportOperations_var anOper = GEOM::GEOM_IImportExportOperations::_narrow(getOperation()); GEOM::GEOM_IImportExportOperations_var ieOp = GEOM::GEOM_IImportExportOperations::_narrow(getOperation());
GEOM::GEOM_IShapesOperations_var anShapesOper = getGeomEngine()->GetIShapesOperations(getStudyId()); GEOM::GEOM_IShapesOperations_var shapesOp = getGeomEngine()->GetIShapesOperations(getStudyId());
GEOM::ListOfGO_var mylGroups = anShapesOper->GetExistingSubObjects(myMainObj, true); GEOM::ListOfGO_var groups = shapesOp->GetExistingSubObjects(m_mainObj, true);
GEOM::ListOfGO_var mylFields = new GEOM::ListOfGO(); GEOM::ListOfGO_var fields = new GEOM::ListOfGO();
mylGroups->length( myGroups.count() ); std::cout << " == Groups" << std::endl;
for ( int i = 0; i < myGroups.count(); i++ ) groups->length(m_groups.count());
mylGroups[i] = myGroups[i].copy(); for (int i = 0; i < m_groups.count(); i++)
groups[i] = m_groups[i].copy();
mylFields->length( myFields.count() );
for ( int i = 0; i < myFields.count(); i++ )
mylFields[i] = myFields[i].copy();
// call engine function std::cout << " == Fields" << std::endl;
res = anOper->ExportXAO(myMainObj, myMainFile->text().toStdString().c_str(), mylGroups, mylFields); fields->length(m_fields.count());
for (int i = 0; i < m_fields.count(); i++)
fields[i] = m_fields[i].copy();
return res; // call engine function
std::cout << " >> ExportXAO" << std::endl;
res = ieOp->ExportXAO(m_mainObj, ledFileName->text().toStdString().c_str(), groups, fields);
std::cout << " << ExportXAO" << std::endl;
return res;
} }

63
src/ImportExportGUI/ImportExportGUI_ExportXAODlg.h
View File

@ -1,7 +1,4 @@
// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2013 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 // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -23,7 +20,7 @@
#define IMPORTEXPORTGUI_EXPORTXAODLG_H #define IMPORTEXPORTGUI_EXPORTXAODLG_H
#include <GEOMBase_Skeleton.h> #include <GEOMBase_Skeleton.h>
#include "GEOM_GenericObjPtr.h" #include <GEOM_GenericObjPtr.h>
class QLineEdit; class QLineEdit;
class QButtonGroup; class QButtonGroup;
@ -35,45 +32,45 @@ class QListWidget;
// class : ImportExportGUI_ExportXAODlg // class : ImportExportGUI_ExportXAODlg
// purpose : // purpose :
//================================================================================= //=================================================================================
class ImportExportGUI_ExportXAODlg : public GEOMBase_Skeleton class ImportExportGUI_ExportXAODlg: public GEOMBase_Skeleton
{ {
Q_OBJECT Q_OBJECT
public: public:
ImportExportGUI_ExportXAODlg( GeometryGUI*, QWidget* = 0 ); ImportExportGUI_ExportXAODlg(GeometryGUI*, QWidget* = 0);
~ImportExportGUI_ExportXAODlg(); ~ImportExportGUI_ExportXAODlg();
protected: protected:
// redefined from GEOMBase_Helper // redefined from GEOMBase_Helper
virtual GEOM::GEOM_IOperations_ptr createOperation(); virtual GEOM::GEOM_IOperations_ptr createOperation();
virtual bool isValid( QString& ); virtual bool isValid(QString&);
virtual bool execute( ObjectList& ); virtual bool execute(ObjectList&);
private: private:
void Init(); void Init();
void enterEvent( QEvent* ); void enterEvent(QEvent*);
void processObject(); void processObject();
private: private:
GEOM::GEOM_Object_var myMainObj; GEOM::GEOM_Object_var m_mainObj;
QList<GEOM::GeomObjPtr> myGroups; QList<GEOM::GeomObjPtr> m_groups;
QList<GEOM::GeomObjPtr> myFields; QList<GEOM::GeomObjPtr> m_fields;
//ImportExportGUI_1Sel1LineEdit2ListWidget* myGrp; //ImportExportGUI_1Sel1LineEdit2ListWidget* myGrp;
QLineEdit *myMainShape; QLineEdit* ledShape;
QLineEdit *myMainFile; QLineEdit* ledFileName;
QListWidget *myListGroups; QListWidget* lstGroups;
QListWidget *myListFields; QListWidget* lstFields;
QPushButton *mySelBtn; QPushButton* btnSelect;
private slots: private slots:
void ClickOnOk(); void ClickOnOk();
bool ClickOnApply(); bool ClickOnApply();
void ActivateThisDialog(); void ActivateThisDialog();
void LineEditReturnPressed(); void LineEditReturnPressed();
void SelectionIntoArgument(); void SelectionIntoArgument();
void SetEditCurrentArgument(); void SetEditCurrentArgument();
//void ValueChangedInSpinBox(); //void ValueChangedInSpinBox();
//void SetDoubleSpinBoxStep( double ); //void SetDoubleSpinBoxStep( double );
}; };
#endif // IMPORTEXPORTGUI_EXPORTXAODLG_H #endif // IMPORTEXPORTGUI_EXPORTXAODLG_H

2
src/XAO/Field.cxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public

6
src/XAO/Field.hxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -32,7 +32,7 @@ namespace XAO
FACE = 2, FACE = 2,
SOLID = 3 SOLID = 3
} FieldDimension; } FieldDimension;
typedef enum typedef enum
{ {
BOOLEAN = 0, BOOLEAN = 0,
@ -40,7 +40,7 @@ namespace XAO
DOUBLE = 2, DOUBLE = 2,
STRING = 3 STRING = 3
} FieldType; } FieldType;
class Field class Field
{ {
public: public:

105
src/XAO/GeometricElement.cxx Normal file
View File

@ -0,0 +1,105 @@
// Copyright (C) 2013 CEA/DEN, EDF R&D
//
// 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.
//
// 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
//
// Author : Frederic Pons (OpenCascade)
#include <Utils_SALOME_Exception.hxx>
#include "GeometricElement.hxx"
using namespace XAO;
GeometricElement::GeometricElement()
{
m_name = "";
m_reference = "";
}
GeometricElement::GeometricElement(const char* name, const char* reference)
{
m_name = name;
m_reference = reference;
}
GeometricElement::~GeometricElement()
{
}
GeometricElementList::GeometricElementList()
{
setSize(0);
}
GeometricElementList::GeometricElementList(const int count)
{
setSize(m_count);
}
void GeometricElementList::setSize(const int nb)
{
m_count = nb;
m_elements.clear();
for (int i = 0; i < nb; ++i)
{
m_elements[i] = GeometricElement();
}
}
void GeometricElementList::setElement(const int index, const char* name, const char* reference)
{
if (m_count == 0 || index > m_count)
throw SALOME_Exception("Problem with number of elements");
m_elements[index].setName(name);
m_elements[index].setReference(reference);
}
const char* GeometricElementList::getName(const int index)
{
if (m_count == 0 || index > m_count)
throw SALOME_Exception("Problem with number of elements");
return m_elements[index].getName();
}
void GeometricElementList::setName(const int index, const char* name)
{
if (m_count == 0 || index > m_count)
throw SALOME_Exception("Problem with number of elements");
m_elements[index].setName(name);
}
const char* GeometricElementList::getReference(const int index)
{
if (m_count == 0 || index > m_count)
throw SALOME_Exception("Problem with number of elements");
return m_elements[index].getReference();
}
void GeometricElementList::setReference(const int index, const char* name)
{
if (m_count == 0 || index > m_count)
throw SALOME_Exception("Problem with number of elements");
m_elements[index].setReference(name);
}

85
src/XAO/GeometricElement.hxx Normal file
View File

@ -0,0 +1,85 @@
// Copyright (C) 2013 CEA/DEN, EDF R&D
//
// 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.
//
// 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
//
// Author : Frederic Pons (OpenCascade)
#ifndef __XAO_GEOMETRICELEMENT_HXX__
#define __XAO_GEOMETRICELEMENT_HXX__
#include <string>
#include <map>
namespace XAO
{
class GeometricElement
{
public:
GeometricElement();
GeometricElement(const char* name, const char* reference);
~GeometricElement();
const char* getName()
{
return m_name.c_str();
}
void setName(const char* name)
{
m_name = name;
}
const char* getReference()
{
return m_reference.c_str();
}
void setReference(const char* reference)
{
m_reference = reference;
}
private:
std::string m_name;
std::string m_reference;
};
class GeometricElementList
{
public:
GeometricElementList();
GeometricElementList(const int nb);
~GeometricElementList() {}
int getSize() { return m_count; }
void setSize(const int nb);
void setElement(const int index, const char* name, const char* reference);
const char* getName(const int index);
void setName(const int index, const char* name);
const char* getReference(const int index);
void setReference(const int index, const char* reference);
private:
int m_count;
std::map<int, GeometricElement> m_elements;
};
}
#endif /* __XAO_GEOMETRICELEMENT_HXX__ */

284
src/XAO/Geometry.cxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -18,6 +18,7 @@
// //
// Author : Nathalie Gore (OpenCascade) // Author : Nathalie Gore (OpenCascade)
#include "XaoUtils.hxx"
#include "Geometry.hxx" #include "Geometry.hxx"
#include <Standard_TypeMismatch.hxx> #include <Standard_TypeMismatch.hxx>
@ -29,7 +30,7 @@
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
#include <iostream> #include <iostream>
#include <ostream> #include <iosfwd>
#include <list> #include <list>
#include <TopTools_MapOfShape.hxx> #include <TopTools_MapOfShape.hxx>
@ -41,210 +42,157 @@
#include <TColStd_ListIteratorOfListOfInteger.hxx> #include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <TColStd_HArray1OfInteger.hxx> #include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HSequenceOfInteger.hxx> #include <TColStd_HSequenceOfInteger.hxx>
using namespace std;
using namespace XAO; using namespace XAO;
Geometry::Geometry() Geometry::Geometry()
{ {
_myFormat = "BREP"; m_format = "BREP";
_myNbVertices = 0;
_myNamesVertices = NULL;
_myIdsVertices = NULL;
_myNbEdges = 0;
_myNamesEdges = NULL;
_myIdsEdges = NULL;
_myNbFaces = 0;
_myNamesFaces = NULL;
_myIdsFaces = NULL;
_myNbSolids = 0;
_myNamesSolids = NULL;
_myIdsSolids = NULL;
} }
Geometry::~Geometry() Geometry::~Geometry()
{ {
if (_myNamesVertices != NULL)
delete _myNamesVertices;
if (_myIdsVertices != NULL)
delete _myIdsVertices;
if (_myNamesEdges != NULL)
delete _myNamesEdges;
if (_myIdsEdges != NULL)
delete _myIdsEdges;
if (_myNamesFaces != NULL)
delete _myNamesFaces;
if (_myIdsFaces != NULL)
delete _myIdsFaces;
if (_myNamesSolids != NULL)
delete _myNamesSolids;
if (_myIdsSolids != NULL)
delete _myIdsSolids;
} }
void Geometry::setShape(TopoDS_Shape Shape) void Geometry::setShape(TopoDS_Shape shape)
{ {
_myShape = Shape; m_shape = shape;
// intialization of Ids // intialization of Ids
initListIds(TopAbs_VERTEX); initListIds(TopAbs_VERTEX);
initListIds(TopAbs_EDGE); initListIds(TopAbs_EDGE);
initListIds(TopAbs_FACE); initListIds(TopAbs_FACE);
initListIds(TopAbs_SOLID); initListIds(TopAbs_SOLID);
} }
void Geometry::setShape(const char * brep ) void Geometry::setShape(const char* brep)
{ {
istringstream streamBrep(brep); std::istringstream streamBrep(brep);
BRep_Builder aBuilder; BRep_Builder builder;
BRepTools::Read(_myShape, streamBrep, aBuilder); BRepTools::Read(m_shape, streamBrep, builder);
// intialization of Ids // intialization of Ids
initListIds(TopAbs_VERTEX); initListIds(TopAbs_VERTEX);
initListIds(TopAbs_EDGE); initListIds(TopAbs_EDGE);
initListIds(TopAbs_FACE); initListIds(TopAbs_FACE);
initListIds(TopAbs_SOLID); initListIds(TopAbs_SOLID);
} }
const char * Geometry::getBREP() const char* Geometry::getBREP()
{ {
ostringstream streamShape; std::ostringstream streamShape;
BRepTools::Write(_myShape, streamShape); BRepTools::Write(m_shape, streamShape);
return streamShape.str().c_str(); return streamShape.str().c_str();
} }
void Geometry::setVertexName(int index, const char *myName) /*
void Geometry::changeVertexName(int id, const char* name)
{ {
if (_myNbVertices == 0 || index > _myNbVertices) if (m_nbVertices == 0)
Standard_TypeMismatch::Raise("Problem with number of vertices"); Standard_TypeMismatch::Raise("Problem with number of vertices");
if (_myNamesVertices == NULL) if (m_verticesNames == NULL)
_myNamesVertices = new std::string[_myNbVertices]; m_verticesNames = new std::string[m_nbVertices];
_myNamesVertices[index] = myName; int index = findVertex(id);
if (index == -1)
Standard_TypeMismatch::Raise("Problem with the id of the vertex");
m_verticesNames[index] = name;
} }
void Geometry::changeVertexName(int id, const char *myName) const char* Geometry::findVertexName(int id)
{ {
if (_myNbVertices == 0) if (m_nbVertices == 0)
Standard_TypeMismatch::Raise("Problem with number of vertices"); {
Standard_TypeMismatch::Raise("Problem with number of vertices");
return "";
}
if (_myNamesVertices == NULL) int index = findVertex(id);
_myNamesVertices = new std::string[_myNbVertices];
int index = findVertex(id);
if (index == -1)
Standard_TypeMismatch::Raise("Problem with the id of the vertex");
_myNamesVertices[index] = myName;
}
const char * Geometry::findVertexName(int id) if (index == -1)
{ {
if (_myNbVertices == 0) { Standard_TypeMismatch::Raise("Problem with the id of the vertex");
Standard_TypeMismatch::Raise("Problem with number of vertices"); return "";
return ""; }
}
int index = findVertex(id);
if (index == -1) {
Standard_TypeMismatch::Raise("Problem with the id of the vertex");
return "";
}
return _myNamesVertices[index].c_str();
}
return m_verticesNames[index].c_str();
}*/
/*
int Geometry::findVertex(int id) int Geometry::findVertex(int id)
{ {
int index = -1; int index = -1;
for (int i = 0, n = _myNbVertices; i < n; i++) for (int i = 0, n = m_nbVertices; i < n; i++)
{ {
if (_myIdsVertices[i] == id) if (m_verticesIds[i] == id)
return i; return i;
} }
return index; return index;
} }*/
void Geometry::initListIds(const Standard_Integer theShapeType) void Geometry::initListIds(const Standard_Integer shapeType)
{ {
std::list<int> aList; TopTools_MapOfShape mapShape;
TopTools_ListOfShape listShape;
TopTools_MapOfShape mapShape;
TopTools_ListOfShape listShape;
TopExp_Explorer exp (_myShape, TopAbs_ShapeEnum(theShapeType));
for (; exp.More(); exp.Next())
if (mapShape.Add(exp.Current()))
listShape.Append(exp.Current());
if (listShape.IsEmpty()) { TopExp_Explorer exp(m_shape, TopAbs_ShapeEnum(shapeType));
return ; for (; exp.More(); exp.Next())
} {
if (mapShape.Add(exp.Current()))
listShape.Append(exp.Current());
}
TopTools_IndexedMapOfShape anIndices; if (listShape.IsEmpty())
TopExp::MapShapes(_myShape, anIndices); {
Handle(TColStd_HArray1OfInteger) anArray; return;
}
TopTools_ListIteratorOfListOfShape itSub (listShape); TopTools_IndexedMapOfShape anIndices;
for (int index = 1; itSub.More(); itSub.Next(), ++index) { TopExp::MapShapes(m_shape, anIndices);
TopoDS_Shape aValue = itSub.Value(); //Handle (TColStd_HArray1OfInteger) anArray;
aList.push_back(anIndices.FindIndex(aValue));
} std::list<int> aList;
TopTools_ListIteratorOfListOfShape itSub(listShape);
std::list<int>::iterator it = aList.begin(); for (int index = 1; itSub.More(); itSub.Next(), ++index)
switch ( theShapeType ) {
case TopAbs_VERTEX: /* Fill vertices ids */
{ {
_myNbVertices = aList.size(); TopoDS_Shape value = itSub.Value();
if (_myIdsVertices != NULL) aList.push_back(anIndices.FindIndex(value));
delete _myIdsVertices;
_myIdsVertices = new int[_myNbVertices];
for (int i = 0; it != aList.end(); it++, i++)
_myIdsVertices[i] = (*it);
break;
} }
case TopAbs_EDGE: /* Fill edges ids */
std::list<int>::iterator it = aList.begin();
switch (shapeType)
{ {
_myNbEdges = aList.size(); case TopAbs_VERTEX: /* Fill vertices ids */
if (_myIdsEdges != NULL) {
delete _myIdsEdges; m_vertices.setSize(aList.size());
_myIdsEdges = new int[_myNbEdges]; for (int i = 0; it != aList.end(); it++, i++)
for (int i = 0; it != aList.end(); it++, i++) m_vertices.setReference(i, XaoUtils::intToString((*it)));
_myIdsEdges[i] = (*it); break;
break; }
case TopAbs_EDGE: /* Fill edges ids */
{
m_edges.setSize(aList.size());
for (int i = 0; it != aList.end(); it++, i++)
m_edges.setReference(i, XaoUtils::intToString((*it)));
break;
}
case TopAbs_FACE: /* Fill faces ids */
{
m_faces.setSize(aList.size());
for (int i = 0; it != aList.end(); it++, i++)
m_faces.setReference(i, XaoUtils::intToString((*it)));
break;
}
case TopAbs_SOLID: /* Fill solids ids */
{
m_solids.setSize(aList.size());
for (int i = 0; it != aList.end(); it++, i++)
m_solids.setReference(i, XaoUtils::intToString((*it)));
break;
}
} }
case TopAbs_FACE: /* Fill faces ids */
{
_myNbFaces = aList.size();
if (_myIdsFaces != NULL)
delete _myIdsFaces;
_myIdsFaces = new int[_myNbFaces];
for (int i = 0; it != aList.end(); it++, i++)
_myIdsFaces[i] = (*it);
break;
}
case TopAbs_SOLID: /* Fill solids ids */
{
_myNbSolids = aList.size();
if (_myIdsSolids != NULL)
delete _myIdsSolids;
_myIdsSolids = new int[_myNbSolids];
for (int i = 0; it != aList.end(); it++, i++)
_myIdsSolids[i] = (*it);
break;
}
}
} }

130
src/XAO/Geometry.hxx
View File

@ -26,58 +26,96 @@
#include <SALOMEconfig.h> #include <SALOMEconfig.h>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
# include "GeometricElement.hxx"
namespace XAO namespace XAO
{ {
class Geometry class Geometry
{ {
public: public:
Geometry(); Geometry();
~Geometry(); ~Geometry();
void setName(const char *name) { _myName=name; } const char* getName()
const char *getName() const { return _myName.c_str(); } {
return m_name.c_str();
}
void setName(const char* name)
{
m_name = name;
}
void setFormat(const char *format) { _myFormat=format; } const char* getFormat()
const char *getFormat() const { return _myFormat.c_str(); } {
return m_format.c_str();
void setShape(TopoDS_Shape Shape); }
TopoDS_Shape getShape() { return _myShape; } void setFormat(const char* format)
{
void setShape(const char * brep ); m_format = format;
const char * getBREP(); }
int countVertices() { return _myNbVertices; }
int findVertex(int id);
void setVertexName(int index, const char *myName);
const char * getVertexName(int index) { return _myNamesVertices[index].c_str(); }
void changeVertexName(int id, const char *myName);
const char * findVertexName(int id);
int countEdges() { return _myNbEdges; } TopoDS_Shape getShape()
int countFaces() { return _myNbFaces; } {
int countSolids() { return _myNbSolids; } return m_shape;
}
void setShape(TopoDS_Shape shape);
private: const char* getBREP();
void initListIds(const Standard_Integer theShapeType); void setShape(const char* brep);
private: int countVertices() { return m_vertices.getSize(); }
TopoDS_Shape _myShape; int countEdges() { return m_edges.getSize(); }
std::string _myName; int countFaces() { return m_faces.getSize(); }
std::string _myFormat; int countSolids() { return m_solids.getSize(); }
int _myNbVertices;
std::string *_myNamesVertices; void setCountVertices(const int nb) { m_vertices.setSize(nb); }
int *_myIdsVertices; void setCountEdges(const int nb) { m_edges.setSize(nb); }
int _myNbEdges; void setCountFaces(const int nb) { m_faces.setSize(nb); }
std::string *_myNamesEdges; void setCountSolids(const int nb) { m_solids.setSize(nb); }
int *_myIdsEdges;
int _myNbFaces; void setVertex(const int index, const char* name, const char* reference) { m_vertices.setElement(index, name,reference); }
std::string *_myNamesFaces; void setEdge(const int index, const char* name, const char* reference) { m_edges.setElement(index, name,reference); }
int *_myIdsFaces; void setFace(const int index, const char* name, const char* reference) { m_faces.setElement(index, name,reference); }
int _myNbSolids; void setSolid(const int index, const char* name, const char* reference) { m_solids.setElement(index, name,reference); }
std::string *_myNamesSolids;
int *_myIdsSolids; const char* getVertexName(const int index) { return m_vertices.getName(index); }
}; const char* getEdgeName(const int index) { return m_edges.getName(index); }
const char* getFaceName(const int index) { return m_faces.getName(index); }
const char* getSolidName(const int index) { return m_solids.getName(index); }
void setVertexName(const int index, const char* name) { m_vertices.setName(index, name); }
void setEdgeName(const int index, const char* name) { m_edges.setName(index, name); }
void setFaceName(const int index, const char* name) { m_faces.setName(index, name); }
void setSolidName(const int index, const char* name) { m_solids.setName(index, name); }
const char* getVertexReference(const int index) { return m_vertices.getReference(index); }
const char* getEdgeReference(const int index) { return m_edges.getReference(index); }
const char* getFaceReference(const int index) { return m_faces.getReference(index); }
const char* getSolidReference(const int index) { return m_solids.getReference(index); }
void setVertexReference(const int index, const char* reference) { m_vertices.setReference(index, reference); }
void setEdgeReference(const int index, const char* reference) { m_edges.setReference(index, reference); }
void setFaceReference(const int index, const char* reference) { m_faces.setReference(index, reference); }
void setSolidReference(const int index, const char* reference) { m_solids.setReference(index, reference); }
// int findVertex(int id);
// void changeVertexName(const int id, const char* name);
// const char* findVertexName(int id);
private:
void initListIds(const Standard_Integer shapeType);
private:
TopoDS_Shape m_shape;
std::string m_name;
std::string m_format;
GeometricElementList m_vertices;
GeometricElementList m_edges;
GeometricElementList m_faces;
GeometricElementList m_solids;
};
} }
#endif #endif

9
src/XAO/Group.cxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -16,7 +16,7 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// Author : Nathalie Gore (OpenCascade) // Author : Nathalie Gore (OpenCascade), Frederic Pons (OpenCascade)
#include "Group.hxx" #include "Group.hxx"
@ -24,12 +24,11 @@ using namespace XAO;
Group::Group() Group::Group()
{ {
_myType = 0; m_dimension = 0;
_myCount = 0; m_count = 0;
} }
Group::~Group() Group::~Group()
{ {
} }

67
src/XAO/Group.hxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -16,42 +16,61 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// Author : Nathalie Gore (OpenCascade) // Author : Nathalie Gore (OpenCascade), Frederic Pons (OpenCascade)
#ifndef __XAO_GROUP_HXX__ #ifndef __XAO_GROUP_HXX__
#define __XAO_GROUP_HXX__ #define __XAO_GROUP_HXX__
#include <string> #include <string>
#include <list> #include <vector>
namespace XAO namespace XAO
{ {
class Group class Group
{ {
public: public:
Group(); Group();
~Group(); ~Group();
void setName(const char *name) { _myName=name; } void setName(const char* name)
const char *getName() const { return _myName.c_str(); } {
m_name = name;
}
const char *getName() const
{
return m_name.c_str();
}
void setType(int type) { _myType=type; } void setDimension(int dimension)
int getType() { return _myType; } {
m_dimension = dimension;
}
int getDimension()
{
return m_dimension;
}
int getCount() { return _myValues.size(); } int getCount()
{
void addValue(int value) {_myValues.push_back(value);} return m_elements.size();
//int getValue(int index) { return _myValues[index]; } }
private: void addElement(const char* value)
void sort() {_myValues.sort();} {
m_elements.push_back(value);
}
private: const char* getElement(const int index)
std::string _myName; {
int _myType; return m_elements[index].c_str();
int _myCount; }
std::list<int> _myValues;
}; private:
std::string m_name;
int m_dimension;
int m_count;
std::vector<std::string> m_elements;
};
} }
#endif #endif

41
src/XAO/Makefile.am
View File

@ -21,7 +21,9 @@
# #
include $(top_srcdir)/adm_local/unix/make_common_starter.am include $(top_srcdir)/adm_local/unix/make_common_starter.am
if CPPUNIT_IS_OK
SUBDIRS = . tests
endif
# =============================================================== # ===============================================================
# Files to be installed # Files to be installed
@ -29,29 +31,32 @@ include $(top_srcdir)/adm_local/unix/make_common_starter.am
# #
# header files # header files
salomeinclude_HEADERS = \ salomeinclude_HEADERS = \
Xao.hxx \ XaoUtils.hxx \
Geometry.hxx \ GeometricElement.hxx \
Group.hxx \ Xao.hxx \
Field.hxx Geometry.hxx \
Group.hxx \
Field.hxx
lib_LTLIBRARIES = libXAO.la lib_LTLIBRARIES = libXAO.la
dist_libXAO_la_SOURCES = \ dist_libXAO_la_SOURCES = \
Xao.cxx \ XaoUtils.cxx \
Geometry.cxx \ GeometricElement.cxx \
Group.cxx \ Xao.cxx \
Field.cxx Geometry.cxx \
Group.cxx \
Field.cxx
libXAO_la_CPPFLAGS = \ libXAO_la_CPPFLAGS = \
$(GEOM_CXXFLAGS) \ $(GEOM_CXXFLAGS) \
$(CAS_CPPFLAGS) \ $(CAS_CPPFLAGS) \
$(LIBXML_INCLUDES) \ $(LIBXML_INCLUDES) \
-I$(top_builddir) \ -I$(top_builddir) \
-I$(top_builddir)/idl -I$(top_builddir)/idl
libXAO_la_LDFLAGS = \ libXAO_la_LDFLAGS = \
$(CAS_LDPATH) \ $(CAS_LDPATH) \
$(LIBXML_LIBS) \ $(LIBXML_LIBS) \
$(GEOM_LDFLAGS) $(GEOM_LDFLAGS)

528
src/XAO/Xao.cxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -16,78 +16,500 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// Author : Nathalie Gore (OpenCascade) // Author : Nathalie Gore (OpenCascade), Frederic Pons (OpenCascade)
#include <libxml/parser.h>
#include "XaoUtils.hxx"
#include "Xao.hxx" #include "Xao.hxx"
#include "Geometry.hxx" #include "Geometry.hxx"
#include "Group.hxx" #include "Group.hxx"
#include "Field.hxx" #include "Field.hxx"
#include <Utils_SALOME_Exception.hxx>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <fstream>
#include <sstream>
#include <iostream>
#include <ostream>
using namespace XAO; using namespace XAO;
const xmlChar* C_XAO_VERSION = (xmlChar*)"1.0";
const xmlChar* C_TAG_XAO = (xmlChar*)"XAO";
const xmlChar* C_ATTR_XAO_AUTHOR = (xmlChar*)"author";
const xmlChar* C_ATTR_XAO_VERSION = (xmlChar*)"version";
const xmlChar* C_TAG_GEOMETRY = (xmlChar*)"geometry";
const xmlChar* C_ATTR_GEOMETRY_NAME = (xmlChar*)"name";
const xmlChar* C_TAG_SHAPE = (xmlChar*)"shape";
const xmlChar* C_ATTR_SHAPE_FORMAT = (xmlChar*)"format";
const xmlChar* C_TAG_TOPOLOGY = (xmlChar*)"topology";
const xmlChar* C_TAG_VERTICES = (xmlChar*)"vertices";
const xmlChar* C_TAG_VERTEX = (xmlChar*)"vertex";
const xmlChar* C_TAG_EDGES = (xmlChar*)"edges";
const xmlChar* C_TAG_EDGE = (xmlChar*)"edge";
const xmlChar* C_TAG_FACES = (xmlChar*)"faces";
const xmlChar* C_TAG_FACE = (xmlChar*)"face";
const xmlChar* C_TAG_SOLIDS = (xmlChar*)"solids";
const xmlChar* C_TAG_SOLID = (xmlChar*)"solid";
const xmlChar* C_ATTR_COUNT = (xmlChar*)"count";
const xmlChar* C_ATTR_ELT_INDEX = (xmlChar*)"index";
const xmlChar* C_ATTR_ELT_NAME = (xmlChar*)"name";
const xmlChar* C_ATTR_ELT_REFERENCE = (xmlChar*)"reference";
const xmlChar* C_TAG_GROUPS = (xmlChar*)"groups";
const xmlChar* C_TAG_GROUP = (xmlChar*)"group";
const xmlChar* C_ATTR_GROUP_NAME = (xmlChar*)"name";
const xmlChar* C_ATTR_GROUP_DIM = (xmlChar*)"dimension";
const xmlChar* C_TAG_ELEMENT = (xmlChar*)"element";
const xmlChar* C_ATTR_ELEMENT_INDEX = (xmlChar*)"index";
const xmlChar* C_TAG_FIELDS = (xmlChar*)"fields";
const xmlChar* C_TAG_FIELD = (xmlChar*)"field";
const xmlChar* C_TAG_COMPONENTS = (xmlChar*)"components";
const xmlChar* C_TAG_COMPONENT = (xmlChar*)"component";
const xmlChar* C_TAG_STEPS = (xmlChar*)"steps";
const xmlChar* C_TAG_STEP = (xmlChar*)"step";
Xao::Xao() Xao::Xao()
{ {
_myAuthor = "Nathalie Gore"; m_author = "";
_myVersion = "1.0"; m_version = (char*)C_XAO_VERSION;
_myGeometry = NULL; m_geometry = NULL;
_myNbGroups = 0; m_nbGroups = 0;
} }
Xao::Xao(const char *author, const char *version) Xao::Xao(const char* author, const char* version)
{ {
_myAuthor = author; m_author = author;
_myVersion = version; m_version = version;
_myGeometry = NULL; m_geometry = NULL;
_myNbGroups = 0; m_nbGroups = 0;
} }
Xao::~Xao() Xao::~Xao()
{ {
if (_myGeometry != NULL) if (m_geometry != NULL)
{ {
delete _myGeometry; delete m_geometry;
_myGeometry = NULL; m_geometry = NULL;
} }
// for (std::list<Group*>::iterator it = m_groups.begin(); it != m_groups.end(); ++it)
// {
// delete (*it);
// }
} }
bool Xao::Export(const char* fileName) Group* Xao::getGroup(const int index)
{ {
if (_myGeometry == NULL) int i = 0;
return false; for (std::list<Group*>::iterator it = m_groups.begin(); it != m_groups.end(); ++it, ++i)
{
xmlDocPtr master_doc = 0; if (i == index)
xmlNodePtr xao_node = 0; return (*it);
}
//Creating the Xml document }
master_doc = xmlNewDoc(BAD_CAST "1.0");
xao_node = xmlNewNode(0, BAD_CAST "XAO");
xmlDocSetRootElement(master_doc,xao_node); bool Xao::exportToFile(const char* fileName)
{
xmlNodePtr version_node = xmlNewChild(xao_node,0, BAD_CAST "version", BAD_CAST _myVersion.c_str()); xmlDocPtr doc = exportXMLDoc();
xmlNodePtr author_node = xmlNewChild(xao_node,0, BAD_CAST "author", BAD_CAST _myAuthor.c_str()); xmlSaveFormatFileEnc(fileName, doc, "UTF-8", 2);
xmlFreeDoc(doc);
// Geometric part
xmlNodePtr geom_node = xmlNewChild(xao_node,0, BAD_CAST "geometry",0); return true;
xmlNodePtr name_geom_node = xmlNewChild(geom_node,0, BAD_CAST "name",BAD_CAST _myGeometry->getName()); }
xmlNodePtr format_geom_node = xmlNewChild(geom_node,0, BAD_CAST "name",BAD_CAST _myGeometry->getFormat());
xmlNodePtr shape_geom_node = xmlNewChild(geom_node,0, BAD_CAST "shape",BAD_CAST _myGeometry->getBREP()); const char* Xao::getXML()
{
/*xmlNodePtr topo_geom_node = xmlNewChild(geom_node,0, BAD_CAST "topology",0); xmlDocPtr doc = exportXMLDoc();
ostringstream stream;
stream << _myGeometry->countVertices(); xmlChar *xmlbuff;
xmlNodePtr count_topo_geom_node = xmlNewChild(count_topo_geom_node,0, BAD_CAST "topology", BAD_CAST stream.str().c_str());*/ int buffersize;
xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
xmlFreeDoc(doc);
xmlCleanupGlobals();
return (char*)xmlbuff;
}
xmlDocPtr Xao::exportXMLDoc()
{
// Creating the Xml document
xmlDocPtr masterDocument = xmlNewDoc(BAD_CAST "1.0");
xmlNodePtr xao = xmlNewNode(0, C_TAG_XAO);
xmlDocSetRootElement(masterDocument, xao);
xmlNewProp(xao, C_ATTR_XAO_VERSION, BAD_CAST getVersion());
xmlNewProp(xao, C_ATTR_XAO_AUTHOR, BAD_CAST getAuthor());
if (m_geometry != NULL)
{
exportGeometry(masterDocument, xao);
}
exportGroups(xao);
return masterDocument;
}
void Xao::exportGeometry(xmlDocPtr doc, xmlNodePtr xao)
{
// Geometric part
xmlNodePtr geometry = xmlNewChild(xao, 0, C_TAG_GEOMETRY, 0);
xmlNewProp(geometry, C_ATTR_GEOMETRY_NAME, BAD_CAST m_geometry->getName());
xmlNodePtr shape = xmlNewChild(geometry, 0, C_TAG_SHAPE, 0);
xmlNewProp(shape, C_ATTR_SHAPE_FORMAT, BAD_CAST m_geometry->getFormat());
const char* brep = m_geometry->getBREP();
xmlNodePtr cdata = xmlNewCDataBlock(doc, BAD_CAST brep, strlen(brep));
xmlAddChild(shape, cdata);
xmlNodePtr topology = xmlNewChild(geometry, 0, C_TAG_TOPOLOGY, 0);
// vertices
xmlNodePtr vertices = xmlNewChild(topology, 0, C_TAG_VERTICES, 0);
xmlNewProp(vertices, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(m_geometry->countVertices()));
for (int i = 0; i < m_geometry->countVertices(); ++i)
{
xmlNodePtr vertex = xmlNewChild(vertices, 0, C_TAG_VERTEX, 0);
xmlNewProp(vertex, C_ATTR_ELT_INDEX, BAD_CAST XaoUtils::intToString(i));
xmlNewProp(vertex, C_ATTR_ELT_NAME, BAD_CAST m_geometry->getVertexName(i));
xmlNewProp(vertex, C_ATTR_ELT_REFERENCE, BAD_CAST m_geometry->getVertexReference(i));
}
// edges
xmlNodePtr edges = xmlNewChild(topology, 0, C_TAG_EDGES, 0);
xmlNewProp(edges, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(m_geometry->countEdges()));
for (int i = 0; i < m_geometry->countEdges(); ++i)
{
xmlNodePtr edge = xmlNewChild(edges, 0, C_TAG_EDGE, 0);
xmlNewProp(edge, C_ATTR_ELT_INDEX, BAD_CAST XaoUtils::intToString(i));
xmlNewProp(edge, C_ATTR_ELT_NAME, BAD_CAST m_geometry->getEdgeName(i));
xmlNewProp(edge, C_ATTR_ELT_REFERENCE, BAD_CAST m_geometry->getEdgeReference(i));
}
// faces
xmlNodePtr faces = xmlNewChild(topology, 0, C_TAG_FACES, 0);
xmlNewProp(faces, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(m_geometry->countFaces()));
for (int i = 0; i < m_geometry->countFaces(); ++i)
{
xmlNodePtr face = xmlNewChild(faces, 0, C_TAG_FACE, 0);
xmlNewProp(face, C_ATTR_ELT_INDEX, BAD_CAST XaoUtils::intToString(i));
xmlNewProp(face, C_ATTR_ELT_NAME, BAD_CAST m_geometry->getFaceName(i));
xmlNewProp(face, C_ATTR_ELT_REFERENCE, BAD_CAST m_geometry->getFaceReference(i));
}
// soldids
xmlNodePtr solids = xmlNewChild(topology, 0, C_TAG_SOLIDS, 0);
xmlNewProp(solids, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(m_geometry->countSolids()));
for (int i = 0; i < m_geometry->countSolids(); ++i)
{
xmlNodePtr solid = xmlNewChild(solids, 0, C_TAG_SOLID, 0);
xmlNewProp(solid, C_ATTR_ELT_INDEX, BAD_CAST XaoUtils::intToString(i));
xmlNewProp(solid, C_ATTR_ELT_NAME, BAD_CAST m_geometry->getSolidName(i));
xmlNewProp(solid, C_ATTR_ELT_REFERENCE, BAD_CAST m_geometry->getSolidReference(i));
}
}
void Xao::exportGroups(xmlNodePtr xao)
{
xmlNodePtr groups = xmlNewChild(xao, 0, C_TAG_GROUPS, 0);
xmlNewProp(groups, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(countGroups()));
for (std::list<Group*>::iterator it = m_groups.begin(); it != m_groups.end(); ++it)
{
Group* grp = (*it);
xmlNodePtr group = xmlNewChild(groups, 0, C_TAG_GROUP, 0);
xmlNewProp(group, C_ATTR_GROUP_NAME, BAD_CAST grp->getName());
xmlNewProp(group, C_ATTR_GROUP_DIM, BAD_CAST XaoUtils::dimensionToString(grp->getDimension()));
xmlNewProp(group, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(grp->getCount()));
for (int i = 0; i < grp->getCount(); ++i)
{
xmlNodePtr elt = xmlNewChild(group, 0, C_TAG_ELEMENT, 0);
xmlNewProp(elt, C_ATTR_ELEMENT_INDEX, BAD_CAST grp->getElement(i));
}
}
}
bool Xao::importFromFile(const char* fileName)
{
// parse the file and get the DOM
int options = 16384; // merge cdata as text node
xmlDocPtr doc = xmlReadFile(fileName, NULL, options);
if (doc == NULL)
{
throw SALOME_Exception("Cannot read XAO file");
}
parseXMLDoc(doc);
return true;
}
void Xao::parseXMLDoc(xmlDocPtr doc)
{
// Get the root element node
xmlNodePtr root = xmlDocGetRootElement(doc);
if (xmlStrcmp(root->name , C_TAG_XAO) != 0)
throw SALOME_Exception("Cannot read XAO file: invalid format XAO node not found");
parseXaoNode(doc, root);
xmlFreeDoc(doc); // free document
xmlCleanupParser(); // Free globals
}
void Xao::parseXaoNode(xmlDocPtr doc, xmlNodePtr xaoNode)
{
xmlChar* version = xmlGetProp(xaoNode, C_ATTR_XAO_VERSION);
if (version != NULL)
{
setVersion((char*)version);
xmlFree(version);
}
xmlChar* author = xmlGetProp(xaoNode, C_ATTR_XAO_AUTHOR);
if (author != NULL)
{
setAuthor((char*)author);
xmlFree(author);
}
for (xmlNodePtr node = xaoNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_GEOMETRY) == 0)
parseGeometryNode(doc, node);
else if (xmlStrcmp(node->name, C_TAG_GROUPS) == 0)
parseGroupsNode(node);
}
}
void Xao::parseGeometryNode(xmlDocPtr doc, xmlNodePtr geometryNode)
{
//std::cout << ">> Geometry" << std::endl;
if (m_geometry == NULL)
m_geometry = new Geometry();
xmlChar* name = xmlGetProp(geometryNode, C_ATTR_GEOMETRY_NAME);
if (name != NULL)
{
m_geometry->setName((char*)name);
xmlFree(name);
}
for (xmlNodePtr node = geometryNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_SHAPE) == 0)
parseShapeNode(doc, node);
else if (xmlStrcmp(node->name, C_TAG_TOPOLOGY) == 0)
parseTopologyNode(node);
// else
// std::cout << "skip:" << node->name << std::endl;
}
} }
void Xao::parseShapeNode(xmlDocPtr doc, xmlNodePtr shapeNode)
{
xmlChar* shapeType = xmlGetProp(shapeNode, C_ATTR_SHAPE_FORMAT);
if (xmlStrcmp(shapeType, (xmlChar*)"BREP") == 0)
{
xmlChar* data = xmlNodeGetContent(shapeNode->children);
if (data == NULL)
throw SALOME_Exception("Missing BREP");
m_geometry->setShape((char*)data);
xmlFree(data);
}
else
{
throw SALOME_Exception("Shape format not supported");
}
}
void Xao::parseTopologyNode(xmlNodePtr topologyNode)
{
// std::cout << ">> Topology" << std::endl;
for (xmlNodePtr node = topologyNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_VERTICES) == 0)
parseVerticesNode(node);
else if (xmlStrcmp(node->name, C_TAG_EDGES) == 0)
parseEdgesNode(node);
else if (xmlStrcmp(node->name, C_TAG_FACES) == 0)
parseFacesNode(node);
else if (xmlStrcmp(node->name, C_TAG_SOLIDS) == 0)
parseSolidsNode(node);
}
}
void Xao::parseVerticesNode(xmlNodePtr verticesNode)
{
xmlChar* count = xmlGetProp(verticesNode, C_ATTR_COUNT);
if (count == NULL)
throw SALOME_Exception("No count attribute for vertices");
m_geometry->setCountVertices(atoi((char*)count));
xmlFree(count);
for (xmlNodePtr node = verticesNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_VERTEX) == 0)
{
xmlChar* index = xmlGetProp(node, C_ATTR_ELT_INDEX);
if (index == NULL)
throw SALOME_Exception("Bad index for vertex");
xmlChar* name = xmlGetProp(node, C_ATTR_ELT_NAME);
if (name == NULL)
name = (xmlChar*)"";
xmlChar* reference = xmlGetProp(node, C_ATTR_ELT_REFERENCE);
if (reference == NULL)
throw SALOME_Exception("Bad reference for vertex");
m_geometry->setVertex(atoi((char*)index), (char*)name, (char*)reference);
}
}
}
void Xao::parseEdgesNode(xmlNodePtr edgesNode)
{
xmlChar* count = xmlGetProp(edgesNode, C_ATTR_COUNT);
if (count == NULL)
throw SALOME_Exception("No count attribute for edges");
m_geometry->setCountEdges(atoi((char*)count));
xmlFree(count);
for (xmlNodePtr node = edgesNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_EDGE) == 0)
{
xmlChar* index = xmlGetProp(node, C_ATTR_ELT_INDEX);
if (index == NULL)
throw SALOME_Exception("Bad index for edge");
xmlChar* name = xmlGetProp(node, C_ATTR_ELT_NAME);
if (name == NULL)
name = (xmlChar*)"";
xmlChar* reference = xmlGetProp(node, C_ATTR_ELT_REFERENCE);
if (reference == NULL)
throw SALOME_Exception("Bad reference for edge");
m_geometry->setEdge(atoi((char*)index), (char*)name, (char*)reference);
}
}
}
void Xao::parseFacesNode(xmlNodePtr facesNode)
{
xmlChar* count = xmlGetProp(facesNode, C_ATTR_COUNT);
if (count == NULL)
throw SALOME_Exception("No count attribute for faces");
m_geometry->setCountFaces(atoi((char*)count));
xmlFree(count);
for (xmlNodePtr node = facesNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_FACE) == 0)
{
xmlChar* index = xmlGetProp(node, C_ATTR_ELT_INDEX);
if (index == NULL)
throw SALOME_Exception("Bad index for face");
xmlChar* name = xmlGetProp(node, C_ATTR_ELT_NAME);
if (name == NULL)
name = (xmlChar*)"";
xmlChar* reference = xmlGetProp(node, C_ATTR_ELT_REFERENCE);
if (reference == NULL)
throw SALOME_Exception("Bad reference for face");
m_geometry->setFace(atoi((char*)index), (char*)name, (char*)reference);
}
}
}
void Xao::parseSolidsNode(xmlNodePtr solidsNode)
{
xmlChar* count = xmlGetProp(solidsNode, C_ATTR_COUNT);
if (count == NULL)
throw SALOME_Exception("No count attribute for solids");
m_geometry->setCountSolids(atoi((char*)count));
xmlFree(count);
for (xmlNodePtr node = solidsNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_SOLID) == 0)
{
xmlChar* index = xmlGetProp(node, C_ATTR_ELT_INDEX);
if (index == NULL)
throw SALOME_Exception("Bad index for solid");
xmlChar* name = xmlGetProp(node, C_ATTR_ELT_NAME);
if (name == NULL)
name = (xmlChar*)"";
xmlChar* reference = xmlGetProp(node, C_ATTR_ELT_REFERENCE);
if (reference == NULL)
throw SALOME_Exception("Bad reference for solid");
m_geometry->setSolid(atoi((char*)index), (char*)name, (char*)reference);
}
}
}
void Xao::parseGroupsNode(xmlNodePtr groupsNode)
{
// xmlChar* count = xmlGetProp(groupsNode, C_ATTR_COUNT);
// if (count == NULL)
// throw SALOME_Exception("No count attribute for groups");
for (xmlNodePtr node = groupsNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_GROUP) == 0)
{
parseGroupNode(node);
}
}
}
void Xao::parseGroupNode(xmlNodePtr groupNode)
{
// xmlChar* count = xmlGetProp(groupNode, C_ATTR_COUNT);
// if (count == NULL)
// throw SALOME_Exception("Bad count for group");
xmlChar* dimension = xmlGetProp(groupNode, C_ATTR_GROUP_DIM);
if (dimension == NULL)
throw SALOME_Exception("Bad dimension for group");
Group* group = new Group();
xmlChar* name = xmlGetProp(groupNode, C_ATTR_GROUP_NAME);
if (name == NULL) name = (xmlChar*)"";
group->setName((char*)name);
xmlFree(name);
group->setDimension(XaoUtils::stringToDimension((char*)dimension));
xmlFree(dimension);
addGroup(group);
for (xmlNodePtr node = groupNode->children; node; node = node->next)
{
if (xmlStrcmp(node->name, C_TAG_ELEMENT) == 0)
{
xmlChar* index = xmlGetProp(node, C_ATTR_ELEMENT_INDEX);
if (index == NULL)
throw SALOME_Exception("Bad index for group element");
group->addElement((char*)index);
xmlFree(index);
}
}
}

75
src/XAO/Xao.hxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D // Copyright (C) 2013 CEA/DEN, EDF R&D
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -16,61 +16,84 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// Author : Nathalie Gore (OpenCascade) // Author : Nathalie Gore (OpenCascade), Frederic Pons (OpenCascade)
#ifndef __XAO_XAO_HXX__ #ifndef __XAO_XAO_HXX__
#define __XAO_XAO_HXX__ #define __XAO_XAO_HXX__
#include <string> #include <string>
#include <list> #include <list>
#include <libxml/parser.h>
namespace XAO namespace XAO
{ {
enum Kind{ enum Kind
{
VERTEX, VERTEX,
EDGE, EDGE,
FACE, FACE,
SOLID SOLID
}; };
class Geometry; class Geometry;
class Group; class Group;
class Field; class Field;
class Xao class Xao
{ {
public: public:
Xao(); Xao();
Xao(const char *author, const char *version); Xao(const char* author, const char* version);
~Xao(); ~Xao();
void setAuthor(const char *author) { _myAuthor=author; } void setAuthor(const char* author) { m_author = author; }
const char *getAuthor() const { return _myAuthor.c_str(); } const char* getAuthor() { return m_author.c_str(); }
void setVersion(const char *version) { _myVersion=version; }
const char *getVersion() const { return _myVersion.c_str(); }
void setGeometry(Geometry *myGeometry) { _myGeometry=myGeometry; } void setVersion(const char* version) { m_version = version; }
const Geometry *getGeometry() const { return _myGeometry; } const char* getVersion() { return m_version.c_str(); }
int getNbGroups() { return _myGroups.size(); } void setGeometry(Geometry* geometry) { m_geometry = geometry; }
void addGroup(Group *myGroup) { _myGroups.push_back(myGroup); } Geometry* getGeometry() { return m_geometry; }
void removeGroup(Group *myGroup) { _myGroups.remove(myGroup); }
int getNbFields() { return _myNbFields; } int countGroups() { return m_groups.size(); }
Group* getGroup(const int index);
bool Export(const char* fileName); void addGroup(Group* group) { m_groups.push_back(group); }
void removeGroup(Group* group) { m_groups.remove(group); }
bool exportToFile(const char* fileName);
const char* getXML();
bool importFromFile(const char* fileName);
bool setXML(const char* xml);
private: private:
std::string _myAuthor; std::string m_author;
std::string _myVersion; std::string m_version;
Geometry *_myGeometry; Geometry* m_geometry;
int _myNbGroups; int m_nbGroups;
std::list<Group *> _myGroups; std::list<Group*> m_groups;
int _myNbFields; //int m_nbFields;
//std::list<Field *> _myFields; //std::list<Field*> m_fields;
xmlDocPtr exportXMLDoc();
void exportGeometry(xmlDocPtr doc, xmlNodePtr xao);
void exportGroups(xmlNodePtr xao);
void parseXMLDoc(xmlDocPtr doc);
void parseXaoNode(xmlDocPtr doc, xmlNodePtr xaoNode);
void parseGeometryNode(xmlDocPtr doc, xmlNodePtr geometryNode);
void parseShapeNode(xmlDocPtr doc, xmlNodePtr shapeNode);
void parseTopologyNode(xmlNodePtr topologyNode);
void parseVerticesNode(xmlNodePtr verticesNode);
void parseEdgesNode(xmlNodePtr edgesNode);
void parseFacesNode(xmlNodePtr facesNode);
void parseSolidsNode(xmlNodePtr solidsNode);
void parseGroupsNode(xmlNodePtr groupsNode);
void parseGroupNode(xmlNodePtr groupNode);
}; };
} }
#endif #endif

61
src/XAO/XaoUtils.cxx Normal file
View File

@ -0,0 +1,61 @@
// Copyright (C) 2013 CEA/DEN, EDF R&D
//
// 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.
//
// 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
//
// Author : Frederic Pons (OpenCascade)
#include <cstring>
#include <sstream>
#include <iosfwd>
#include <Utils_SALOME_Exception.hxx>
#include "XaoUtils.hxx"
using namespace XAO;
const char* XaoUtils::intToString(const int value)
{
std::stringstream str;
str << value;
return str.str().c_str();
}
const char* XaoUtils::dimensionToString(const int dimension)
{
if (dimension == 0)
return "vertex";
if (dimension == 1)
return "edge";
if (dimension == 2)
return "face";
if (dimension == 3)
return "solid";
throw SALOME_Exception("Bad dimension");
}
const int XaoUtils::stringToDimension(const char* dimension)
{
if (strcmp(dimension, "vertex") == 0)
return 0;
if (strcmp(dimension, "edge") == 0)
return 1;
if (strcmp(dimension, "face") == 0)
return 2;
if (strcmp(dimension, "solid") == 0)
return 3;
throw SALOME_Exception("Bad dimension");
}

37
src/XAO/XaoUtils.hxx Normal file
View File

@ -0,0 +1,37 @@
// Copyright (C) 2013 CEA/DEN, EDF R&D
//
// 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.
//
// 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
//
// Author : Frederic Pons (OpenCascade)
#ifndef __XAO_UTILS_HXX__
#define __XAO_UTILS_HXX__
namespace XAO
{
class XaoUtils
{
public:
static const char* intToString(const int value);
static const char* dimensionToString(const int dimension);
static const int stringToDimension(const char* dimension);
};
}
#endif /* __XAO_UTILS_HXX__ */

167
src/XAO/tests/ImportExportTest.cxx Normal file
View File

@ -0,0 +1,167 @@
// Copyright (C) 2013 CEA/DEN, EDF R&D
//
// 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.
//
// 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
//
// Author : Frederic Pons (OpenCascade)
#include <stdio.h>
#include <Utils_SALOME_Exception.hxx>
#include "ImportExportTest.hxx"
#include "../Geometry.hxx"
#include "../Group.hxx"
using namespace XAO;
std::string getTestFile(std::string fileName)
{
std::string dataDir = getenv("GEOM_SRC_DIR");
dataDir += "/src/XAO/tests/data/" + fileName;
return dataDir;
}
void ImportExportTest::setUp()
{
}
void ImportExportTest::tearDown()
{
}
void ImportExportTest::cleanUp()
{
}
void ImportExportTest::testExportNoGeometry()
{
Xao xao("me", "1.0");
bool res = xao.exportToFile("empty.xao");
CPPUNIT_ASSERT(res);
}
void ImportExportTest::testExportGeometry()
{
Xao xao("me", "1.0");
Geometry* geom = new Geometry();
geom->setName("mygeom");
xao.setGeometry(geom);
geom->setCountVertices(4);
geom->setVertex(0, "v1", "1");
geom->setVertex(1, "", "2");
geom->setVertex(2, "v3", "3");
geom->setVertex(3, "", "4");
geom->setCountEdges(3);
geom->setEdge(0, "e1", "5");
geom->setEdge(1, "", "6");
geom->setEdge(2, "e3", "7");
geom->setCountFaces(2);
geom->setFace(0, "f1", "8");
geom->setFace(1, "", "9");
geom->setCountSolids(1);
geom->setSolid(0, "s1", "10");
Group* group = new Group();
xao.addGroup(group);
group->setName("boite1");
group->setDimension(3);
group->addElement("1");
group = new Group();
xao.addGroup(group);
group->setName("faces");
group->setDimension(2);
group->addElement("5");
group->addElement("8");
group->addElement("9");
bool res = xao.exportToFile("mygeom.xao");
CPPUNIT_ASSERT(res);
const char* xml = xao.getXML();
//CPPUNIT_ASSERT(strlen(xml) == 1007);
}
void ImportExportTest::testGeometryError()
{
Xao xao("me", "1.0");
Geometry* geom = new Geometry();
geom->setName("mygeom");
xao.setGeometry(geom);
geom->setCountVertices(2);
CPPUNIT_ASSERT_THROW(geom->setVertex(3, "v4", "4"), SALOME_Exception);
}
void ImportExportTest::testImportXao()
{
std::cout << std::endl;
Xao xao;
xao.importFromFile(getTestFile("test.xao").c_str());
CPPUNIT_ASSERT(strcmp(xao.getAuthor(), "me") == 0);
CPPUNIT_ASSERT(strcmp(xao.getVersion(), "1.0") == 0);
Geometry* geom = xao.getGeometry();
CPPUNIT_ASSERT(geom != NULL);
CPPUNIT_ASSERT(strcmp(geom->getName(), "mygeom") == 0);
CPPUNIT_ASSERT(geom->countVertices() == 4);
CPPUNIT_ASSERT(strcmp(geom->getVertexName(0), "v1") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexReference(0), "1") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexName(1), "") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexReference(1), "2") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexName(2), "v3") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexReference(2), "3") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexName(3), "") == 0);
CPPUNIT_ASSERT(strcmp(geom->getVertexReference(3), "4") == 0);
CPPUNIT_ASSERT(geom->countEdges() == 3);
CPPUNIT_ASSERT(strcmp(geom->getEdgeName(0), "e1") == 0);
CPPUNIT_ASSERT(strcmp(geom->getEdgeReference(0), "5") == 0);
CPPUNIT_ASSERT(strcmp(geom->getEdgeName(1), "") == 0);
CPPUNIT_ASSERT(strcmp(geom->getEdgeReference(1), "6") == 0);
CPPUNIT_ASSERT(strcmp(geom->getEdgeName(2), "e3") == 0);
CPPUNIT_ASSERT(strcmp(geom->getEdgeReference(2), "7") == 0);
CPPUNIT_ASSERT(geom->countFaces() == 2);
CPPUNIT_ASSERT(strcmp(geom->getFaceName(0), "f1") == 0);
CPPUNIT_ASSERT(strcmp(geom->getFaceReference(0), "8") == 0);
CPPUNIT_ASSERT(strcmp(geom->getFaceName(1), "") == 0);
CPPUNIT_ASSERT(strcmp(geom->getFaceReference(1), "9") == 0);
CPPUNIT_ASSERT(geom->countSolids() == 1);
CPPUNIT_ASSERT(strcmp(geom->getSolidName(0), "s1") == 0);
CPPUNIT_ASSERT(strcmp(geom->getSolidReference(0), "10") == 0);
CPPUNIT_ASSERT(xao.countGroups() == 2);
Group* group = xao.getGroup(0);
CPPUNIT_ASSERT(group->getCount() == 1);
CPPUNIT_ASSERT(strcmp(group->getName(), "boite_1") == 0);
CPPUNIT_ASSERT(group->getDimension() == 3);
CPPUNIT_ASSERT(strcmp(group->getElement(0), "1") == 0);
group = xao.getGroup(1);
CPPUNIT_ASSERT(group->getCount() == 3);
CPPUNIT_ASSERT(strcmp(group->getName(), "") == 0);
CPPUNIT_ASSERT(group->getDimension() == 2);
CPPUNIT_ASSERT(strcmp(group->getElement(0), "5") == 0);
CPPUNIT_ASSERT(strcmp(group->getElement(1), "8") == 0);
CPPUNIT_ASSERT(strcmp(group->getElement(2), "9") == 0);
}

31
src/XAO/tests/ImportExportTest.hxx Normal file
View File

@ -0,0 +1,31 @@
#ifndef __BUILDING_IMPORT_TEST_HXX__
#define __BUILDING_IMPORT_TEST_HXX__
#include <cppunit/extensions/HelperMacros.h>
#include "../Xao.hxx"
namespace XAO
{
class ImportExportTest: public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(ImportExportTest);
CPPUNIT_TEST(testExportNoGeometry);
CPPUNIT_TEST(testExportGeometry);
CPPUNIT_TEST(testGeometryError);
CPPUNIT_TEST(testImportXao);
CPPUNIT_TEST_SUITE_END();
public:
void setUp();
void tearDown();
void cleanUp();
void testExportNoGeometry();
void testExportGeometry();
void testGeometryError();
void testImportXao();
};
}
#endif

161
src/XAO/tests/MainTest.hxx Normal file
View File

@ -0,0 +1,161 @@
// Copyright (C) 2013 CEA/DEN, EDF R&D
//
// 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.
//
// 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
//
// Author : Frederic Pons (OpenCascade)
#ifndef __XAOMAINTEST_HXX__
#define __XAOMAINTEST_HXX__
#include <cppunit/CompilerOutputter.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TextTestProgressListener.h>
#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/TestRunner.h>
#include <stdexcept>
#include <cstring>
#include <iostream>
#include <fstream>
struct Arguments
{
public:
bool List;
bool Err;
std::string Test;
};
Arguments parseArguments(int argc, char* argv[])
{
Arguments res;
res.List = false;
res.Err = false;
res.Test = "";
if (argc > 1)
{
int i = 0;
while (++i < argc) // skip 0
{
if (strcmp(argv[i], "-l") == 0 || strcmp(argv[i], "--list") == 0)
{
res.List = true;
}
else if (strcmp(argv[i], "-e") == 0 || strcmp(argv[i], "--err") == 0)
{
res.Err = true;
}
if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--test") == 0)
{
if (i+1 < argc)
res.Test = argv[++i];
}
}
}
return res;
}
void listTests(CPPUNIT_NS::Test* test)
{
if (!test) return;
std::cout << test->getName() << std::endl;
for (int i = 0; i < test->getChildTestCount(); ++i)
{
listTests(test->getChildTestAt(i));
}
}
// ============================================================================
/*!
* Main program source for Unit Tests with cppunit package does not depend
* on actual tests, so we use the same for all partial unit tests.
*/
// ============================================================================
int main(int argc, char* argv[])
{
Arguments args = parseArguments(argc, argv);
// --- Create the event manager and test controller
CPPUNIT_NS::TestResult controller;
// --- Add a listener that colllects test result
CPPUNIT_NS::TestResultCollector result;
controller.addListener(&result);
// --- Add a listener that print dots as test run.
#ifdef WIN32
CPPUNIT_NS::TextTestProgressListener progress;
#else
CPPUNIT_NS::BriefTestProgressListener progress;
#endif
controller.addListener(&progress);
// --- Get the top level suite from the registry
CPPUNIT_NS::Test *suite =
CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest();
// --- Adds the test to the list of test to run
// list tests and exit
if (args.List)
{
listTests(suite);
return 0;
}
if (!args.Test.empty())
{
// find test by name
// an exception is raised if not found
suite = suite->findTest(args.Test);
}
CPPUNIT_NS::TestRunner runner;
runner.addTest(suite);
runner.run(controller);
// --- Print test in a compiler compatible format.
if (args.Err)
{
CPPUNIT_NS::CompilerOutputter outputter(&result, std::cerr);
outputter.write();
}
else
{
std::ofstream testFile;
testFile.open("UnitTestsResult", std::ios::out | std::ios::trunc);
CPPUNIT_NS::CompilerOutputter outputter(&result, testFile);
outputter.write();
testFile.close();
}
// --- Run the tests.
bool wasSucessful = result.wasSuccessful();
// --- Return error code 1 if the one of test failed.
return wasSucessful ? 0 : 1;
}
#endif

32
src/XAO/tests/Makefile.am Executable file
View File

@ -0,0 +1,32 @@
include $(top_srcdir)/adm_local/unix/make_common_starter.am
bin_PROGRAMS= TestXAO
TestXAO_CPPFLAGS= \
@CPPUNIT_INCLUDES@ @PTHREAD_CFLAGS@ \
$(GEOM_CXXFLAGS) \
$(CAS_CPPFLAGS) \
$(LIBXML_INCLUDES) \
-I$(srcdir)
TestXAO_LDFLAGS = \
@CPPUNIT_LIBS@ \
$(CAS_LDPATH) \
$(LIBXML_LIBS) \
$(GEOM_LDFLAGS) \
-lxml2 \
../../GEOMBase/libGEOMBase.la \
../libXAO.la
dist_TestXAO_SOURCES = \
ImportExportTest.cxx \
XAOTests.cxx
UNIT_TEST_PROG = TestXAO
check : tests
CLEANFILES = \
UnitTestsResult

5
src/XAO/tests/XAOTests.cxx Normal file
View File

@ -0,0 +1,5 @@
#include "ImportExportTest.hxx"
CPPUNIT_TEST_SUITE_REGISTRATION(XAO::ImportExportTest);
#include "MainTest.hxx"

321
src/XAO/tests/data/test.xao Normal file
View File

@ -0,0 +1,321 @@
<?xml version="1.0" encoding="UTF-8"?>
<XAO version="1.0" author="me">
<geometry name="mygeom">
<shape format="BREP">
<![CDATA[
DBRep_DrawableShape
CASCADE Topology V1, (c) Matra-Datavision
Locations 0
Curve2ds 24
1 0 0 1 0
1 0 0 1 0
1 200 0 0 -1
1 0 0 0 1
1 0 -200 1 0
1 0 0 1 0
1 0 0 0 -1
1 0 0 0 1
1 0 0 1 0
1 0 200 1 0
1 200 0 0 -1
1 200 0 0 1
1 0 -200 1 0
1 0 200 1 0
1 0 0 0 -1
1 200 0 0 1
1 0 0 0 1
1 0 0 1 0
1 200 0 0 1
1 0 0 1 0
1 0 0 0 1
1 0 200 1 0
1 200 0 0 1
1 0 200 1 0
Curves 12
1 0 0 0 0 0 1
1 0 0 200 -0 1 0
1 0 200 0 0 0 1
1 0 0 0 -0 1 0
1 200 0 0 0 0 1
1 200 0 200 0 1 0
1 200 200 0 0 0 1
1 200 0 0 -0 1 0
1 0 0 0 1 0 -0
1 0 0 200 1 0 -0
1 0 200 0 1 0 -0
1 0 200 200 1 0 -0
Polygon3D 0
PolygonOnTriangulations 0
Surfaces 6
1 0 0 0 1 0 -0 0 0 1 0 -1 0
1 0 0 0 -0 1 0 0 0 1 1 0 -0
1 0 0 200 0 0 1 1 0 -0 -0 1 0
1 0 200 0 -0 1 0 0 0 1 1 0 -0
1 0 0 0 0 0 1 1 0 -0 -0 1 0
1 200 0 0 1 0 -0 0 0 1 0 -1 0
Triangulations 0
TShapes 34
Ve
1e-07
0 0 200
0 0
0101101
*
Ve
1e-07
0 0 0
0 0
0101101
*
Ed
1e-07 1 1 0
1 1 0 0 200
2 1 1 0 0 200
2 2 2 0 0 200
0
0101000
-34 0 +33 0 *
Ve
1e-07
0 200 200
0 0
0101101
*
Ed
1e-07 1 1 0
1 2 0 0 200
2 3 1 0 0 200
2 4 3 0 0 200
0
0101000
-31 0 +34 0 *
Ve
1e-07
0 200 0
0 0
0101101
*
Ed
1e-07 1 1 0
1 3 0 0 200
2 5 1 0 0 200
2 6 4 0 0 200
0
0101000
-31 0 +29 0 *
Ed
1e-07 1 1 0
1 4 0 0 200
2 7 1 0 0 200
2 8 5 0 0 200
0
0101000
-29 0 +33 0 *
Wi
0101000
-32 0 -30 0 +28 0 +27 0 *
Fa
0 1e-07 1 0
0111000
+26 0 *
Ve
1e-07
200 0 200
0 0
0101101
*
Ve
1e-07
200 0 0
0 0
0101101
*
Ed
1e-07 1 1 0
1 5 0 0 200
2 9 6 0 0 200
2 10 2 0 0 200
0
0101000
-24 0 +23 0 *
Ve
1e-07
200 200 200
0 0
0101101
*
Ed
1e-07 1 1 0
1 6 0 0 200
2 11 6 0 0 200
2 12 3 0 0 200
0
0101000
-21 0 +24 0 *
Ve
1e-07
200 200 0
0 0
0101101
*
Ed
1e-07 1 1 0
1 7 0 0 200
2 13 6 0 0 200
2 14 4 0 0 200
0
0101000
-21 0 +19 0 *
Ed
1e-07 1 1 0
1 8 0 0 200
2 15 6 0 0 200
2 16 5 0 0 200
0
0101000
-19 0 +23 0 *
Wi
0101000
-22 0 -20 0 +18 0 +17 0 *
Fa
0 1e-07 6 0
0111000
+16 0 *
Ed
1e-07 1 1 0
1 9 0 0 200
2 17 2 0 0 200
2 18 5 0 0 200
0
0101000
-23 0 +33 0 *
Ed
1e-07 1 1 0
1 10 0 0 200
2 19 2 0 0 200
2 20 3 0 0 200
0
0101000
-24 0 +34 0 *
Wi
0101000
-14 0 -22 0 +13 0 +32 0 *
Fa
0 1e-07 2 0
0111000
+12 0 *
Ed
1e-07 1 1 0
1 11 0 0 200
2 21 4 0 0 200
2 22 5 0 0 200
0
0101000
-19 0 +29 0 *
Ed
1e-07 1 1 0
1 12 0 0 200
2 23 4 0 0 200
2 24 3 0 0 200
0
0101000
-21 0 +31 0 *
Wi
0101000
-10 0 -18 0 +9 0 +28 0 *
Fa
0 1e-07 4 0
0111000
+8 0 *
Wi
0101000
-27 0 -10 0 +17 0 +14 0 *
Fa
0 1e-07 5 0
0111000
+6 0 *
Wi
0101000
-30 0 -9 0 +20 0 +13 0 *
Fa
0 1e-07 3 0
0111000
+4 0 *
Sh
0101100
-25 0 +15 0 -11 0 +7 0 -5 0 +3 0 *
So
1100000
+2 0 *
+1 0
]]>
</shape>
<topology>
<vertices count="4">
<vertex index="0" name="v1" reference="1"/>
<vertex index="1" name="" reference="2"/>
<vertex index="2" name="v3" reference="3"/>
<vertex index="3" name="" reference="4"/>
</vertices>
<edges count="3">
<edge index="0" name="e1" reference="5"/>
<edge index="1" name="" reference="6"/>
<edge index="2" name="e3" reference="7"/>
</edges>
<faces count="2">
<face index="0" name="f1" reference="8"/>
<face index="1" name="" reference="9"/>
</faces>
<solids count="1">
<solid index="0" name="s1" reference="10"/>
</solids>
</topology>
</geometry>
<groups>
<group name="boite_1" dimension="solid" count="1">
<element index="1" />
</group>
<group name="" dimension="face" count="3">
<element index="5" />
<element index="8" />
<element index="9" />
</group>
</groups>
</XAO>