[EDF30834] : Templatization + python wrapping

diff --git a/src/ShapeRecogn/Areas.cxx b/src/ShapeRecogn/Areas.cxx
index 6f2f155a3afde9d1803b3d151a764deb57bfbfc0..31d5d39bba620c969d676a805e4ac5e23a7f06b9 100644 (file)
--- a/src/ShapeRecogn/Areas.cxx
+++ b/src/ShapeRecogn/Areas.cxx
@@ -64,7 +64,7 @@ void Areas::removeArea(mcIdType areaId)
 void Areas::addNode(mcIdType areaId, mcIdType nodeId)
 {
     removeNode(nodeId);
-    areaIdByNodes[nodeId] = areaId;
+    areaIdByNodes[nodeId] = FromIdType<Int32>(areaId);
     Area &area = areas[areaId];
     area.nodeIds.push_back(nodeId);
     size_t nbNodes = area.nodeIds.size();
@@ -238,7 +238,7 @@ void Areas::cleanArea(mcIdType areaId, mcIdType newAreaId = -1)
 {
     Area &area = areas[areaId];
     for (mcIdType nodeId : area.nodeIds)
-        areaIdByNodes[nodeId] = newAreaId;
+        areaIdByNodes[nodeId] = FromIdType<Int32>( newAreaId );
     area.primitive = PrimitiveType::Unknown;
     area.k1 = 0.0;
     area.k2 = 0.0;
@@ -498,7 +498,7 @@ void Areas::computeTorusProperties(mcIdType areaId)
         area.center[i] = xc * base2d[i] + yc * base2d[3 + i] + meanMajorRadiusNodes[i];
 }
 
-const std::vector<mcIdType> &Areas::getAreaIdByNodes() const
+const std::vector<Int32> &Areas::getAreaIdByNodes() const
 {
     return areaIdByNodes;
 }

diff --git a/src/ShapeRecogn/Areas.hxx b/src/ShapeRecogn/Areas.hxx
index 912b4e68088f36ec788a22dd7bfa29b98f024fff..8e3158a56b28cd76525ce529e4b90db7446a8559 100644 (file)
--- a/src/ShapeRecogn/Areas.hxx
+++ b/src/ShapeRecogn/Areas.hxx
@@ -59,7 +59,7 @@ namespace MEDCoupling
         void cleanInvalidNodeAreas();
 
         mcIdType getAreaId(mcIdType nodeId) const;
-        const std::vector<mcIdType> &getAreaIdByNodes() const;
+        const std::vector<Int32> &getAreaIdByNodes() const;
 
         bool isEmpty(mcIdType areaId) const;
         size_t getNumberOfAreas() const;
@@ -100,6 +100,6 @@ namespace MEDCoupling
 
         std::vector<Area> areas;
         const Nodes *nodes;
-        std::vector<mcIdType> areaIdByNodes;
+        std::vector<Int32> areaIdByNodes;
     };
 }

diff --git a/src/ShapeRecogn/ShapeRecognMesh.cxx b/src/ShapeRecogn/ShapeRecognMesh.cxx
index 9cd4bc7c236e3dadcee0179e27059c654596bfd6..61b664d097056ef24c00b93ea307e5817c8ad37d 100644 (file)
--- a/src/ShapeRecogn/ShapeRecognMesh.cxx
+++ b/src/ShapeRecogn/ShapeRecognMesh.cxx
@@ -68,7 +68,7 @@ const MEDCouplingFieldDouble *ShapeRecognMesh::getNodeK2() const
     return nodeK2;
 }
 
-const MEDCouplingFieldDouble *ShapeRecognMesh::getNodePrimitiveType() const
+const MEDCouplingFieldInt32 *ShapeRecognMesh::getNodePrimitiveType() const
 {
     return nodePrimitiveType;
 }
@@ -78,12 +78,12 @@ const MEDCouplingFieldDouble *ShapeRecognMesh::getNodeNormal() const
     return nodeNormal;
 }
 
-const MEDCouplingFieldDouble *ShapeRecognMesh::getAreaId() const
+const MEDCouplingFieldInt32 *ShapeRecognMesh::getAreaId() const
 {
     return areaId;
 }
 
-const MEDCouplingFieldDouble *ShapeRecognMesh::getAreaPrimitiveType() const
+const MEDCouplingFieldInt32 *ShapeRecognMesh::getAreaPrimitiveType() const
 {
     return areaPrimitiveType;
 }

diff --git a/src/ShapeRecogn/ShapeRecognMesh.hxx b/src/ShapeRecogn/ShapeRecognMesh.hxx
index 63252a0ac1f2eec539d316602c63ab6a5ec3cfef..deb44962b52aee088439f6a24b8a295d0a604bde 100644 (file)
--- a/src/ShapeRecogn/ShapeRecognMesh.hxx
+++ b/src/ShapeRecogn/ShapeRecognMesh.hxx
@@ -22,6 +22,7 @@
 #include <string>
 
 #include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingFieldInt32.hxx"
 #include "MEDCouplingFieldDouble.hxx"
 #include "MEDCouplingRefCountObject.hxx"
 
@@ -39,12 +40,12 @@ namespace MEDCoupling
         // Node properties
         const MEDCouplingFieldDouble *getNodeK1() const;
         const MEDCouplingFieldDouble *getNodeK2() const;
-        const MEDCouplingFieldDouble *getNodePrimitiveType() const;
+        const MEDCouplingFieldInt32  *getNodePrimitiveType() const;
         const MEDCouplingFieldDouble *getNodeNormal() const;
 
         // Area properties
-        const MEDCouplingFieldDouble *getAreaId() const;
-        const MEDCouplingFieldDouble *getAreaPrimitiveType() const;
+        const MEDCouplingFieldInt32  *getAreaId() const;
+        const MEDCouplingFieldInt32  *getAreaPrimitiveType() const;
         const MEDCouplingFieldDouble *getAreaNormal() const;
         const MEDCouplingFieldDouble *getMinorRadius() const;
         const MEDCouplingFieldDouble *getRadius() const;
@@ -60,10 +61,10 @@ namespace MEDCoupling
     private:
         MCAuto<MEDCouplingFieldDouble> nodeK1;
         MCAuto<MEDCouplingFieldDouble> nodeK2;
-        MCAuto<MEDCouplingFieldDouble> nodePrimitiveType;
+        MCAuto<MEDCouplingFieldInt32>  nodePrimitiveType;
         MCAuto<MEDCouplingFieldDouble> nodeNormal;
-        MCAuto<MEDCouplingFieldDouble> areaId;
-        MCAuto<MEDCouplingFieldDouble> areaPrimitiveType;
+        MCAuto<MEDCouplingFieldInt32>  areaId;
+        MCAuto<MEDCouplingFieldInt32>  areaPrimitiveType;
         MCAuto<MEDCouplingFieldDouble> areaNormal;
         MCAuto<MEDCouplingFieldDouble> minorRadius;
         MCAuto<MEDCouplingFieldDouble> radius;

diff --git a/src/ShapeRecogn/ShapeRecognMeshBuilder.cxx b/src/ShapeRecogn/ShapeRecognMeshBuilder.cxx
index fe0e7b2b06ae33db39861b44d8805c989a9dde4c..6f14340657960849905fdcd8f0e246d892c5ba95 100644 (file)
--- a/src/ShapeRecogn/ShapeRecognMeshBuilder.cxx
+++ b/src/ShapeRecogn/ShapeRecognMeshBuilder.cxx
@@ -22,7 +22,10 @@
 #include "NodesBuilder.hxx"
 #include "AreasBuilder.hxx"
 #include "ShapeRecognMesh.hxx"
+
 #include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingFieldInt64.hxx"
+#include "MEDCouplingFieldInt32.hxx"
 
 using namespace MEDCoupling;
 
@@ -82,169 +85,192 @@ const Areas *ShapeRecognMeshBuilder::getAreas() const
     return areas.get();
 }
 
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildNodeK1() const
+void ShapeRecognMeshBuilder::checkNodesBeforeBuildingField() const
 {
     if ( ! nodes.get() )
         throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
-    return buildField("K1 (Node)", 1, nodes->getK1());
 }
 
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildNodeK2() const
+void ShapeRecognMeshBuilder::checkAreasBeforeBuildingField() const
 {
-    if ( ! nodes.get() )
+    if ( ! areas.get() )
         throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
-    return buildField("K2 (Node)", 1, nodes->getK2());
 }
 
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildNodePrimitiveType() const
+template <typename T>
+typename Traits<T>::FieldType *buildField(
+    const std::string &name,
+    MCAuto<typename Traits<T>::ArrayType> data,
+    const MEDCouplingUMesh *mesh)
 {
-    if ( ! nodes.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
-    return buildField("Primitive Type (Node)", 1, nodes->getPrimitiveType());
+    using ZeField = typename Traits<T>::FieldType;
+    ZeField *field = ZeField::New(ON_NODES);
+    mcIdType nbNodes = data->getNumberOfTuples();
+    size_t nbOfCompo = data->getNumberOfComponents();
+    field->setName(name);
+    field->setMesh(mesh);
+    if (nbOfCompo == 3)
+    {
+        data->setInfoOnComponent(0, "X");
+        data->setInfoOnComponent(1, "Y");
+        data->setInfoOnComponent(2, "Z");
+    }
+    field->setArray(data);
+    return field;
+}
+
+template <typename T>
+typename Traits<T>::FieldType *buildField(
+    const std::string &name,
+    size_t nbOfCompo,
+    const std::vector<T> &values,
+    const MEDCouplingUMesh *mesh)
+{
+    using ZeArray = typename Traits<T>::ArrayType;
+    mcIdType nbNodes = mesh->getNumberOfNodes();
+    MCAuto<ZeArray> data( ZeArray::New() );
+    data->setName(name);
+    data->alloc(nbNodes, nbOfCompo);
+    std::copy(values.begin(), values.end(), data->getPointer());
+    data->declareAsNew();
+    return buildField<T>(name, data, mesh);
+}
+
+template <typename T>
+typename Traits<T>::FieldType *buildField(
+    const std::string &name,
+    size_t nbOfCompo,
+    T *values,
+    const MEDCouplingUMesh *mesh)
+{
+    using ZeArray = typename Traits<T>::ArrayType;
+    mcIdType nbNodes = mesh->getNumberOfNodes();
+    ZeArray *data = ZeArray::New();
+    data->setName(name);
+    data->useArray(
+        values,
+        true,
+        MEDCoupling::DeallocType::CPP_DEALLOC,
+        nbNodes,
+        nbOfCompo);
+    return buildField<T>(name, data, mesh);
+}
+
+template<class T>
+T *buildAreaArrayT(Areas *areas, Nodes *nodes, std::function<T(Areas *, mcIdType)> areaFunc)
+{
+    const std::vector<Int32> &areaIdByNodes = areas->getAreaIdByNodes();
+    T *values = new T[nodes->getNbNodes()];
+    for (size_t nodeId = 0; nodeId < areaIdByNodes.size(); ++nodeId)
+    {
+        Int32 areaId = areaIdByNodes[nodeId];
+        if (areaId != -1)
+            values[nodeId] = areaFunc(areas, areaId);
+    }
+    return values;
+}
+
+MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildNodeK1() const
+{
+    checkNodesBeforeBuildingField();
+    return buildField<double>("K1 (Node)", 1, nodes->getK1(), mesh);
+}
+
+MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildNodeK2() const
+{
+    checkNodesBeforeBuildingField();
+    return buildField<double>("K2 (Node)", 1, nodes->getK2(), mesh);
+}
+
+MEDCouplingFieldInt32 *ShapeRecognMeshBuilder::buildNodePrimitiveType() const
+{
+    checkNodesBeforeBuildingField();
+    return nullptr;//buildField<Int32>("Primitive Type (Node)", 1, nodes->getPrimitiveType(), mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildNodeNormal() const
 {
-    if ( ! nodes.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
-    return buildField("Normal (Node)", 3, nodes->getNormals());
+    checkNodesBeforeBuildingField();
+    return buildField<double>("Normal (Node)", 3, nodes->getNormals(), mesh);
 }
 
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildAreaId() const
+MEDCouplingFieldInt32 *ShapeRecognMeshBuilder::buildAreaId() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
-    return buildField("Area Id", 1, areas->getAreaIdByNodes());
+    checkAreasBeforeBuildingField();
+    return buildField<Int32>("Area Id", 1, areas->getAreaIdByNodes(), mesh);
 }
 
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildAreaPrimitiveType() const
+MEDCouplingFieldInt32 *ShapeRecognMeshBuilder::buildAreaPrimitiveType() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
-    double *values = buildAreaArray([](Areas *areas, mcIdType areaId) -> double
-                                    { return (double)areas->getPrimitiveType(areaId); });
-    return buildField("Primitive Type (Area)", 1, values);
+    checkAreasBeforeBuildingField();
+    std::int32_t *values = buildAreaArrayT<std::int32_t>(areas.get(),nodes.get(),[](Areas *areas, mcIdType areaId) -> std::int32_t
+                                    { return (std::int32_t)areas->getPrimitiveType(areaId); });
+    return buildField<Int32>("Primitive Type (Area)", 1, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildAreaNormal() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildArea3DArray([](Areas *areas, mcIdType areaId) -> const std::array<double, 3> &
                                       { return areas->getNormal(areaId); });
-    return buildField("Normal (Area)", 3, values);
+    return buildField<double>("Normal (Area)", 3, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildMinorRadius() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildAreaArray([](Areas *areas, mcIdType areaId) -> double
                                     { return areas->getMinorRadius(areaId); });
-    return buildField("Minor Radius (Area)", 1, values);
+    return buildField<double>("Minor Radius (Area)", 1, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildRadius() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildAreaArray([](Areas *areas, mcIdType areaId) -> double
                                     { return areas->getRadius(areaId); });
-    return buildField("Radius (Area)", 1, values);
+    return buildField<double>("Radius (Area)", 1, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildAngle() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildAreaArray([](Areas *areas, mcIdType areaId) -> double
                                     { return areas->getAngle(areaId); });
-    return buildField("Angle (Area)", 1, values);
+    return buildField<double>("Angle (Area)", 1, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildCenter() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildArea3DArray([](Areas *areas, mcIdType areaId) -> const std::array<double, 3> &
                                       { return areas->getCenter(areaId); });
-    return buildField("Center (Area)", 3, values);
+    return buildField<double>("Center (Area)", 3, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildAxis() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildArea3DArray([](Areas *areas, mcIdType areaId) -> const std::array<double, 3> &
                                       { return areas->getAxis(areaId); });
-    return buildField("Axis (Area)", 3, values);
+    return buildField<double>("Axis (Area)", 3, values, mesh);
 }
 
 MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildApex() const
 {
-    if ( ! areas.get() )
-        throw INTERP_KERNEL::Exception("recognize must be called before building any fields");
+    checkAreasBeforeBuildingField();
     double *values = buildArea3DArray([](Areas *areas, mcIdType areaId) -> const std::array<double, 3> &
                                       { return areas->getApex(areaId); });
-    return buildField("Apex (Area)", 3, values);
-}
-
-template <typename T>
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildField(
-    const std::string &name,
-    size_t nbOfCompo,
-    const std::vector<T> &values) const
-{
-    MCAuto<DataArrayDouble> data( DataArrayDouble::New() );
-    data->setName(name);
-    data->alloc(nodes->getNbNodes(), nbOfCompo);
-    std::copy(values.begin(), values.end(), data->getPointer());
-    data->declareAsNew();
-    return buildField(name, nbOfCompo, data);
-}
-
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildField(
-    const std::string &name,
-    size_t nbOfCompo,
-    double *values) const
-{
-    DataArrayDouble *data = DataArrayDouble::New();
-    data->setName(name);
-    data->useArray(
-        values,
-        true,
-        MEDCoupling::DeallocType::CPP_DEALLOC,
-        nodes->getNbNodes(),
-        nbOfCompo);
-    return buildField(name, nbOfCompo, data);
-}
-
-MEDCouplingFieldDouble *ShapeRecognMeshBuilder::buildField(
-    const std::string &name,
-    size_t nbOfCompo,
-    MCAuto<DataArrayDouble> data) const
-{
-    MEDCouplingFieldDouble *field = MEDCouplingFieldDouble::New(ON_NODES);
-    field->setName(name);
-    field->setMesh(mesh);
-    if (nbOfCompo == 3)
-    {
-        data->setInfoOnComponent(0, "X");
-        data->setInfoOnComponent(1, "Y");
-        data->setInfoOnComponent(2, "Z");
-    }
-    field->setArray(data);
-    return field;
+    return buildField<double>("Apex (Area)", 3, values, mesh);
 }
 
-double *ShapeRecognMeshBuilder::buildArea3DArray(
-    const std::array<double, 3> &(*areaFunc)(Areas *, mcIdType)) const
+double *ShapeRecognMeshBuilder::buildArea3DArray(std::function<const std::array<double, 3> &(Areas *, Int32)> areaFunc) const
 {
     double *values = new double[3 * nodes->getNbNodes()];
-    const std::vector<mcIdType> &areaIdByNodes = areas->getAreaIdByNodes();
+    const std::vector<Int32> &areaIdByNodes = areas->getAreaIdByNodes();
     for (size_t nodeId = 0; nodeId < areaIdByNodes.size(); ++nodeId)
     {
-        mcIdType areaId = areaIdByNodes[nodeId];
+        Int32 areaId = areaIdByNodes[nodeId];
         if (areaId != -1)
         {
             const std::array<double, 3> &areaValues = areaFunc(areas.get(), areaId);
@@ -256,15 +282,7 @@ double *ShapeRecognMeshBuilder::buildArea3DArray(
     return values;
 }
 
-double *ShapeRecognMeshBuilder::buildAreaArray(double (*areaFunc)(Areas *, mcIdType)) const
+double *ShapeRecognMeshBuilder::buildAreaArray(std::function<double(Areas *, Int32)> areaFunc) const
 {
-    const std::vector<mcIdType> &areaIdByNodes = areas->getAreaIdByNodes();
-    double *values = new double[nodes->getNbNodes()];
-    for (size_t nodeId = 0; nodeId < areaIdByNodes.size(); ++nodeId)
-    {
-        mcIdType areaId = areaIdByNodes[nodeId];
-        if (areaId != -1)
-            values[nodeId] = areaFunc(areas.get(), areaId);
-    }
-    return values;
+    return buildAreaArrayT<double>(areas.get(), nodes.get(), areaFunc );
 }

diff --git a/src/ShapeRecogn/ShapeRecognMeshBuilder.hxx b/src/ShapeRecogn/ShapeRecognMeshBuilder.hxx
index af7b534760eb9a3e465130a91b6faba3853d832c..051fdf65a398396254d40ec4e63eda174905fe68 100644 (file)
--- a/src/ShapeRecogn/ShapeRecognMeshBuilder.hxx
+++ b/src/ShapeRecogn/ShapeRecognMeshBuilder.hxx
@@ -22,15 +22,19 @@
 #include <string>
 
 #include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingFieldDouble.hxx"
 
 #include "Nodes.hxx"
 #include "Areas.hxx"
 
 #include <memory>
+#include <functional>
 
 namespace MEDCoupling
 {
+    class MEDCouplingFieldInt32;
+    class MEDCouplingFieldInt64;
+    class MEDCouplingFieldDouble;
+
     class ShapeRecognMesh;
 
     class ShapeRecognMeshBuilder
@@ -49,12 +53,12 @@ namespace MEDCoupling
         // Node properties
         MEDCoupling::MEDCouplingFieldDouble *buildNodeK1() const;
         MEDCoupling::MEDCouplingFieldDouble *buildNodeK2() const;
-        MEDCoupling::MEDCouplingFieldDouble *buildNodePrimitiveType() const;
+        MEDCoupling::MEDCouplingFieldInt32  *buildNodePrimitiveType() const;
         MEDCoupling::MEDCouplingFieldDouble *buildNodeNormal() const;
 
         // Area properties
-        MEDCoupling::MEDCouplingFieldDouble *buildAreaId() const;
-        MEDCoupling::MEDCouplingFieldDouble *buildAreaPrimitiveType() const;
+        MEDCoupling::MEDCouplingFieldInt32  *buildAreaId() const;
+        MEDCoupling::MEDCouplingFieldInt32  *buildAreaPrimitiveType() const;
         MEDCoupling::MEDCouplingFieldDouble *buildAreaNormal() const;
         MEDCoupling::MEDCouplingFieldDouble *buildMinorRadius() const;
         MEDCoupling::MEDCouplingFieldDouble *buildRadius() const;
@@ -63,22 +67,11 @@ namespace MEDCoupling
         MEDCoupling::MEDCouplingFieldDouble *buildAxis() const;
         MEDCoupling::MEDCouplingFieldDouble *buildApex() const;
 
-        template <typename T>
-        MEDCouplingFieldDouble *buildField(
-            const std::string &name,
-            size_t nbOfCompo,
-            const std::vector<T> &values) const;
-        MEDCouplingFieldDouble *buildField(
-            const std::string &name,
-            size_t nbOfCompo,
-            double *values) const;
-        MEDCouplingFieldDouble *buildField(
-            const std::string &name,
-            size_t nbOfCompo,
-            MCAuto<DataArrayDouble> values) const;
-        double *buildArea3DArray(const std::array<double, 3> &(*areaFunc)(Areas *, mcIdType)) const;
-        double *buildAreaArray(double (*areaFunc)(Areas *, mcIdType)) const;
+        double *buildArea3DArray(std::function<const std::array<double, 3> &(Areas *, Int32)> areaFunc) const;
+        double *buildAreaArray(std::function<double(Areas *, Int32)> areaFunc) const;
         void assign(MCAuto< MEDCouplingUMesh > mesh);
+        void checkNodesBeforeBuildingField() const;
+        void checkAreasBeforeBuildingField() const;
     private:
         MCConstAuto< MEDCouplingUMesh > mesh;
         std::unique_ptr<Nodes> nodes;

diff --git a/src/ShapeRecogn/Swig/ShapeRecognCommon.i b/src/ShapeRecogn/Swig/ShapeRecognCommon.i
index 5362e77bd8d3293a89438c6527497655c5fa332d..66e959206a7ac8c09000992a8294a86024917631 100644 (file)
--- a/src/ShapeRecogn/Swig/ShapeRecognCommon.i
+++ b/src/ShapeRecogn/Swig/ShapeRecognCommon.i
@@ -29,10 +29,6 @@ using namespace MEDCoupling;
 using namespace INTERP_KERNEL;
 %}
 
-%template(ivec) std::vector<int>;
-%template(dvec) std::vector<double>;
-%template(svec) std::vector<std::string>;
-
 #ifdef WITH_NUMPY
 %init %{ import_array(); %}
 #endif

diff --git a/src/ShapeRecogn/Swig/ShapeRecognImpl.i b/src/ShapeRecogn/Swig/ShapeRecognImpl.i
index c09a23315d955751520124a3725a3cee4a72b45b..677bdb2eb282ad3ded7e9994d059d3dc5e02851f 100644 (file)
--- a/src/ShapeRecogn/Swig/ShapeRecognImpl.i
+++ b/src/ShapeRecogn/Swig/ShapeRecognImpl.i
@@ -47,6 +47,11 @@ public:
     double getMinorRadius(mcIdType areaId) const;
     double getRadius(mcIdType areaId) const;
     double getAngle(mcIdType areaId) const;
+    //
+    bool isEmpty(mcIdType areaId) const;
+    size_t getNumberOfAreas() const;
+    size_t getNumberOfNodes(mcIdType areaId) const;
+    std::string getPrimitiveTypeName(mcIdType areaId) const;
     /*const std::array<double, 3> &getNormal(mcIdType areaId) const;
     const std::array<double, 3> &getCenter(mcIdType areaId) const;
     const std::array<double, 3> &getAxis(mcIdType areaId) const;
@@ -58,6 +63,8 @@ private:
     ~Areas();
 };
 
+using namespace MEDCoupling;
+
 class ShapeRecognMesh : public RefCountObject
 {
 public:
@@ -163,19 +170,13 @@ private:
 class ShapeRecognMeshBuilder
 {
 public:
-    ShapeRecognMeshBuilder(MEDCouplingUMesh *mesh);
+    ShapeRecognMeshBuilder(MEDCoupling::MEDCouplingUMesh *mesh);
     ~ShapeRecognMeshBuilder();
 
     //const Nodes *getNodes() const;
     const Areas *getAreas() const;
     %extend
     {
-    ShapeRecognMeshBuilder(MEDCouplingUMesh *mesh)
-    {
-        
-
-    }
-
     ShapeRecognMesh *recognize()
     {
         MCAuto<ShapeRecognMesh> ret = self->recognize();