+ removed unneeded pure virtual method getFaces from PropertyComplexGeoData

+ extend interface of ComplexGeoData::getPoints to also return normals if available

src/App/ComplexGeoData.h

@@ -138,6 +138,7 @@ public:
     { return Base::Vector3d(); }
     /** Get points from object with given accuracy */
     virtual void getPoints(std::vector<Base::Vector3d> &Points,
+        std::vector<Base::Vector3d> &Normals,
         float Accuracy, uint16_t flags=0) const {}
     /** Get lines from object with given accuracy */
     virtual void getLines(std::vector<Base::Vector3d> &Points,std::vector<Line> &lines,

src/App/PropertyGeo.h

@@ -357,9 +357,6 @@ public:
     //@{
     virtual const Data::ComplexGeoData* getComplexData() const = 0;
     virtual Base::BoundBox3d getBoundingBox() const = 0;
-    virtual void getFaces(std::vector<Base::Vector3d> &Points,
-        std::vector<Data::ComplexGeoData::Facet> &Topo,
-        float Accuracy, uint16_t flags=0) const  = 0;
     //@}
 };
 

src/Mod/Fem/App/FemMeshProperty.cpp

@@ -91,13 +91,6 @@ void PropertyFemMesh::transformGeometry(const Base::Matrix4D &rclMat)
     hasSetValue();
 }
 
-void PropertyFemMesh::getFaces(std::vector<Base::Vector3d> &aPoints,
-                               std::vector<Data::ComplexGeoData::Facet> &aTopo,
-                               float accuracy, uint16_t flags) const
-{
-    _FemMesh->getFaces(aPoints, aTopo, accuracy, flags);
-}
-
 PyObject *PropertyFemMesh::getPyObject(void)
 {
     FemMeshPy* mesh = new FemMeshPy(&*_FemMesh);

src/Mod/Fem/App/FemMeshProperty.h

@@ -61,9 +61,6 @@ public:
     /** Returns the bounding box around the underlying mesh kernel */
     Base::BoundBox3d getBoundingBox() const;
     void transformGeometry(const Base::Matrix4D &rclMat);
-    void getFaces(std::vector<Base::Vector3d> &Points,
-        std::vector<Data::ComplexGeoData::Facet> &Topo,
-        float Accuracy, uint16_t flags=0) const;
     //@}
 
     /** @name Python interface */

src/Mod/Mesh/App/AppMeshPy.cpp

@@ -293,7 +293,9 @@ private:
                     if (shape && shape->getTypeId().isDerivedFrom(App::PropertyComplexGeoData::getClassTypeId())) {
                         std::vector<Base::Vector3d> aPoints;
                         std::vector<Data::ComplexGeoData::Facet> aTopo;
-                        static_cast<App::PropertyComplexGeoData*>(shape)->getFaces(aPoints, aTopo,fTolerance);
+                        const Data::ComplexGeoData* data = static_cast<App::PropertyComplexGeoData*>(shape)->getComplexData();
+                        if (data) {
+                            data->getFaces(aPoints, aTopo,fTolerance);
                             mesh->addFacets(aTopo, aPoints);
                             if (global_mesh.countFacets() == 0)
                                 global_mesh = *mesh;
@@ -301,6 +303,7 @@ private:
                                 global_mesh.addMesh(*mesh);
                         }
                     }
+                }
                 else {
                     Base::Console().Message("'%s' is not a mesh or shape, export will be ignored.\n", obj->Label.getValue());
                 }

src/Mod/Mesh/App/Mesh.cpp

@@ -253,6 +253,7 @@ MeshPoint MeshObject::getPoint(unsigned long index) const
 }
 
 void MeshObject::getPoints(std::vector<Base::Vector3d> &Points,
+                           std::vector<Base::Vector3d> &Normals,
                            float Accuracy, uint16_t flags) const
 {
     unsigned long ctpoints = _kernel.CountPoints();

src/Mod/Mesh/App/Mesh.h

@@ -129,6 +129,7 @@ public:
     double getVolume() const;
     /** Get points from object with given accuracy */
     virtual void getPoints(std::vector<Base::Vector3d> &Points,
+        std::vector<Base::Vector3d> &Normals,
         float Accuracy, uint16_t flags=0) const;
     virtual void getFaces(std::vector<Base::Vector3d> &Points,std::vector<Facet> &Topo,
         float Accuracy, uint16_t flags=0) const;

src/Mod/Mesh/App/MeshProperties.cpp

@@ -502,13 +502,6 @@ Base::BoundBox3d PropertyMeshKernel::getBoundingBox() const
     return _meshObject->getBoundBox();
 }
 
-void PropertyMeshKernel::getFaces(std::vector<Base::Vector3d> &aPoints,
-                                  std::vector<Data::ComplexGeoData::Facet> &aTopo,
-                                  float accuracy, uint16_t flags) const
-{
-    _meshObject->getFaces(aPoints, aTopo, accuracy, flags);
-}
-
 unsigned int PropertyMeshKernel::getMemSize (void) const
 {
     unsigned int size = 0;

src/Mod/Mesh/App/MeshProperties.h

@@ -207,10 +207,6 @@ public:
     const Data::ComplexGeoData* getComplexData() const;
     /** Returns the bounding box around the underlying mesh kernel */
     Base::BoundBox3d getBoundingBox() const;
-    /** Get faces from object with given accuracy */
-    virtual void getFaces(std::vector<Base::Vector3d> &Points,
-        std::vector<Data::ComplexGeoData::Facet> &Topo,
-        float Accuracy, uint16_t flags=0) const;
     //@}
 
     /** @name Modification */

src/Mod/Mesh/Gui/Command.cpp

@@ -526,10 +526,13 @@ void CmdMeshFromGeometry::activated(int iMsg)
                 if (jt->first == "Shape" && jt->second->getTypeId().isDerivedFrom(App::PropertyComplexGeoData::getClassTypeId())) {
                     std::vector<Base::Vector3d> aPoints;
                     std::vector<Data::ComplexGeoData::Facet> aTopo;
-                    static_cast<App::PropertyComplexGeoData*>(jt->second)->getFaces(aPoints, aTopo,(float)tol);
+                    const Data::ComplexGeoData* data = static_cast<App::PropertyComplexGeoData*>(jt->second)->getComplexData();
+                    if (data) {
+                        data->getFaces(aPoints, aTopo,(float)tol);
                         mesh.setFacets(aTopo, aPoints);
                     }
                 }
+            }
 
             // create a mesh feature and assign the mesh
             Mesh::Feature* mf = static_cast<Mesh::Feature*>(doc->addObject("Mesh::Feature","Mesh"));

src/Mod/Part/App/PropertyTopoShape.cpp

@@ -133,13 +133,6 @@ Base::BoundBox3d PropertyPartShape::getBoundingBox() const
     return box;
 }
 
-void PropertyPartShape::getFaces(std::vector<Base::Vector3d> &aPoints,
-                                 std::vector<Data::ComplexGeoData::Facet> &aTopo,
-                                 float accuracy, uint16_t flags) const
-{
-    _Shape.getFaces(aPoints, aTopo, accuracy, flags);
-}
-
 void PropertyPartShape::transformGeometry(const Base::Matrix4D &rclTrf)
 {
     aboutToSetValue();

src/Mod/Part/App/PropertyTopoShape.h

@@ -67,10 +67,6 @@ public:
     //@{
     /** Returns the bounding box around the underlying mesh kernel */
     Base::BoundBox3d getBoundingBox() const;
-    /** Get faces from object with given accuracy */
-    virtual void getFaces(std::vector<Base::Vector3d> &Points,
-        std::vector<Data::ComplexGeoData::Facet> &Topo,
-        float Accuracy, uint16_t flags=0) const;
     //@}
 
     /** @name Python interface */

src/Mod/Points/App/PropertyPointKernel.cpp

@@ -76,13 +76,6 @@ Base::BoundBox3d PropertyPointKernel::getBoundingBox() const
     return box;
 }
 
-void PropertyPointKernel::getFaces(std::vector<Base::Vector3d> &Points,
-                                   std::vector<Data::ComplexGeoData::Facet> &Topo,
-                                   float Accuracy, uint16_t flags) const
-{
-    _cPoints->getFaces(Points, Topo, Accuracy, flags);
-}
-
 PyObject *PropertyPointKernel::getPyObject(void)
 {
     PointsPy* points = new PointsPy(&*_cPoints);

src/Mod/Points/App/PropertyPointKernel.h

@@ -52,10 +52,6 @@ public:
     //@{
     /** Returns the bounding box around the underlying mesh kernel */
     Base::BoundBox3d getBoundingBox() const;
-    /** Get faces from object with given accuracy */
-    virtual void getFaces(std::vector<Base::Vector3d> &Points,
-        std::vector<Data::ComplexGeoData::Facet> &Topo,
-        float Accuracy, uint16_t flags=0) const;
     //@}
 
     /** @name Python interface */

src/Mod/Points/Gui/Command.cpp

@@ -195,7 +195,8 @@ void CmdPointsConvert::activated(int iMsg)
         if (prop) {
             const Data::ComplexGeoData* data = prop->getComplexData();
             std::vector<Base::Vector3d> vertexes;
-            data->getPoints(vertexes, 0.0f);
+            std::vector<Base::Vector3d> normals;
+            data->getPoints(vertexes, normals, 0.0f);
             if (!vertexes.empty()) {
                 App::Document* doc = (*it)->getDocument();
                 Points::Feature* fea = static_cast<Points::Feature*>(doc->addObject("Points::Feature", "Points"));

src/Mod/ReverseEngineering/Gui/Command.cpp

@@ -107,7 +107,11 @@ void CmdApproxPlane::activated(int iMsg)
             if (jt->second->getTypeId().isDerivedFrom(App::PropertyComplexGeoData::getClassTypeId())) {
                 std::vector<Base::Vector3d> aPoints;
                 std::vector<Data::ComplexGeoData::Facet> aTopo;
-                static_cast<App::PropertyComplexGeoData*>(jt->second)->getFaces(aPoints, aTopo,0.01f);
+                const Data::ComplexGeoData* data = static_cast<App::PropertyComplexGeoData*>(jt->second)->getComplexData();
+                if (!data)
+                    continue;
+
+                data->getFaces(aPoints, aTopo,0.01f);
 
                 // get a reference normal for the plane fit
                 Base::Vector3f refNormal(0,0,0);