From f00784f00ebf8e6c7f396338f4505d839c55a922 Mon Sep 17 00:00:00 2001
From: "Zheng, Lei" <realthunder.dev@gmail.com>
Date: Wed, 27 Mar 2024 11:13:50 -0400
Subject: [PATCH] Toponaming/Part: move in remaining ifdef methods and the new
 TopoShapePy methods

---
 src/Mod/Part/App/TopoShapeCompSolidPyImp.cpp |  58 ++--
 src/Mod/Part/App/TopoShapeFacePyImp.cpp      |  14 +
 src/Mod/Part/App/TopoShapePy.xml             |  93 +++++++
 src/Mod/Part/App/TopoShapePyImp.cpp          | 269 +++++++++++++++++--
 src/Mod/Part/App/TopoShapeShellPyImp.cpp     |  30 ++-
 src/Mod/Part/App/TopoShapeSolidPyImp.cpp     |  19 +-
 6 files changed, 438 insertions(+), 45 deletions(-)

diff --git a/src/Mod/Part/App/TopoShapeCompSolidPyImp.cpp b/src/Mod/Part/App/TopoShapeCompSolidPyImp.cpp
index cf2f42c20d..201c693441 100644
--- a/src/Mod/Part/App/TopoShapeCompSolidPyImp.cpp
+++ b/src/Mod/Part/App/TopoShapeCompSolidPyImp.cpp
@@ -29,11 +29,13 @@
 #endif
 
 #include "OCCError.h"
+#include "PartPyCXX.h"
 
 // inclusion of the generated files (generated out of TopoShapeCompSolidPy.xml)
 #include "TopoShapeCompSolidPy.h"
 #include "TopoShapeCompSolidPy.cpp"
 #include "TopoShapeSolidPy.h"
+#include "TopoShapeOpCode.h"
 
 
 using namespace Part;
@@ -61,10 +63,16 @@ int TopoShapeCompSolidPy::PyInit(PyObject* args, PyObject* /*kwd*/)
     }
 
     PyErr_Clear();
-    PyObject *pcObj;
-    if (!PyArg_ParseTuple(args, "O", &pcObj))
+    PyObject* pcObj;
+    if (!PyArg_ParseTuple(args, "O", &pcObj)) {
         return -1;
-
+    }
+#ifdef FC_USE_TNP_FIX
+    try {
+        getTopoShapePtr()->makeElementBoolean(Part::OpCodes::Compsolid, getPyShapes(pcObj));
+    }
+    _PY_CATCH_OCC(return (-1))
+#else
     BRep_Builder builder;
     TopoDS_CompSolid Comp;
     builder.MakeCompSolid(Comp);
@@ -73,10 +81,11 @@ int TopoShapeCompSolidPy::PyInit(PyObject* args, PyObject* /*kwd*/)
         Py::Sequence list(pcObj);
         for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
             if (PyObject_TypeCheck((*it).ptr(), &(Part::TopoShapeSolidPy::Type))) {
-                const TopoDS_Shape& sh = static_cast<TopoShapePy*>((*it).ptr())->
-                    getTopoShapePtr()->getShape();
-                if (!sh.IsNull())
+                const TopoDS_Shape& sh =
+                    static_cast<TopoShapePy*>((*it).ptr())->getTopoShapePtr()->getShape();
+                if (!sh.IsNull()) {
                     builder.Add(Comp, sh);
+                }
             }
         }
     }
@@ -87,35 +96,46 @@ int TopoShapeCompSolidPy::PyInit(PyObject* args, PyObject* /*kwd*/)
     }
 
     getTopoShapePtr()->setShape(Comp);
+#endif
     return 0;
 }
 
-PyObject*  TopoShapeCompSolidPy::add(PyObject *args)
+PyObject* TopoShapeCompSolidPy::add(PyObject* args)
 {
-    PyObject *obj;
-    if (!PyArg_ParseTuple(args, "O!", &(Part::TopoShapeSolidPy::Type), &obj))
+    PyObject* obj;
+    if (!PyArg_ParseTuple(args, "O!", &(Part::TopoShapeSolidPy::Type), &obj)) {
         return nullptr;
+    }
 
     BRep_Builder builder;
     TopoDS_Shape comp = getTopoShapePtr()->getShape();
+    auto shapes = getPyShapes(obj);
 
     try {
-        const TopoDS_Shape& sh = static_cast<TopoShapePy*>(obj)->
-            getTopoShapePtr()->getShape();
-        if (!sh.IsNull())
-            builder.Add(comp, sh);
-        else
-            Standard_Failure::Raise("Cannot empty shape to compound solid");
+        for (auto& ts : shapes) {
+            if (!ts.isNull()) {
+                builder.Add(comp, ts.getShape());
+            }
+            else {
+                Standard_Failure::Raise("Cannot empty shape to compound solid");
+            }
+        }
+#ifdef FC_USE_TNP_FIX
+        auto& self = *getTopoShapePtr();
+        shapes.push_back(self);
+        TopoShape tmp(self.Tag, self.Hasher, comp);
+        tmp.mapSubElement(shapes);
+        self = tmp;
+#else
+        getTopoShapePtr()->setShape(comp);
+#endif
+        Py_Return;
     }
     catch (Standard_Failure& e) {
 
         PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
         return nullptr;
     }
-
-    getTopoShapePtr()->setShape(comp);
-
-    Py_Return;
 }
 
 PyObject *TopoShapeCompSolidPy::getCustomAttributes(const char* /*attr*/) const
diff --git a/src/Mod/Part/App/TopoShapeFacePyImp.cpp b/src/Mod/Part/App/TopoShapeFacePyImp.cpp
index eb452b1092..17621f6105 100644
--- a/src/Mod/Part/App/TopoShapeFacePyImp.cpp
+++ b/src/Mod/Part/App/TopoShapeFacePyImp.cpp
@@ -88,6 +88,7 @@
 #include "FaceMaker.h"
 #include "Geometry2d.h"
 #include "OCCError.h"
+#include "PartPyCXX.h"
 #include "Tools.h"
 
 
@@ -324,6 +325,9 @@ int TopoShapeFacePy::PyInit(PyObject* args, PyObject* /*kwd*/)
     PyErr_Clear();
     if (PyArg_ParseTuple(args, "Os", &pcPyShapeOrList, &className)) {
         try {
+#ifdef FC_USE_TNP_FIX
+            getTopoShapePtr()->makeElementFace(getPyShapes(pcPyShapeOrList),0,className);
+#else
             std::unique_ptr<FaceMaker> fm = Part::FaceMaker::ConstructFromType(className);
 
             //dump all supplied shapes to facemaker, no matter what type (let facemaker decide).
@@ -355,6 +359,7 @@ int TopoShapeFacePy::PyInit(PyObject* args, PyObject* /*kwd*/)
             fm->Build();
 
             getTopoShapePtr()->setShape(fm->Face());
+#endif
             return 0;
         } catch (Base::Exception &e) {
             e.setPyException();
@@ -420,6 +425,10 @@ PyObject* TopoShapeFacePy::addWire(PyObject *args)
 
 PyObject* TopoShapeFacePy::makeOffset(PyObject *args)
 {
+#ifdef FC_USE_TNP_FIX
+    Py::Dict dict;
+    return TopoShapePy::makeOffset2D(args, dict.ptr());
+#else
     double dist;
     if (!PyArg_ParseTuple(args, "d",&dist))
         return nullptr;
@@ -434,6 +443,7 @@ PyObject* TopoShapeFacePy::makeOffset(PyObject *args)
     mkOffset.Perform(dist);
 
     return new TopoShapePy(new TopoShape(mkOffset.Shape()));
+#endif
 }
 
 /*
@@ -445,6 +455,9 @@ evolve = spine.makeEvolved(Profile=profile, Join=PartEnums.JoinType.Arc)
 */
 PyObject* TopoShapeFacePy::makeEvolved(PyObject *args, PyObject *kwds)
 {
+#ifdef FC_USE_TNP_FIX
+    return TopoShapePy::makeEvolved(args, kwds);
+#else
     PyObject* Profile;
     PyObject* AxeProf = Py_True;
     PyObject* Solid = Py_False;
@@ -496,6 +509,7 @@ PyObject* TopoShapeFacePy::makeEvolved(PyObject *args, PyObject *kwds)
         PyErr_SetString(PartExceptionOCCError, e.GetMessageString());
         return nullptr;
     }
+#endif
 }
 
 PyObject* TopoShapeFacePy::valueAt(PyObject *args)
diff --git a/src/Mod/Part/App/TopoShapePy.xml b/src/Mod/Part/App/TopoShapePy.xml
index 07d9b67d38..ac9485ba69 100644
--- a/src/Mod/Part/App/TopoShapePy.xml
+++ b/src/Mod/Part/App/TopoShapePy.xml
@@ -511,6 +511,11 @@ Returns: result of offsetting (wire or face or compound of those). Compounding
 structure follows that of source shape.</UserDocu>
       </Documentation>
     </Methode>
+      <Methode Name="makeEvolved" Const="true" Keyword="true">
+          <Documentation>
+              <UserDocu>Profile along the spine</UserDocu>
+          </Documentation>
+      </Methode>
     <Methode Name="makeWires" Const="true">
       <Documentation>
         <UserDocu>make wire(s) using the edges of this shape
@@ -820,6 +825,45 @@ countElement(type) -> int
         </UserDocu>
       </Documentation>
     </Methode>
+      <Methode Name="mapSubElement">
+          <Documentation>
+              <UserDocu>
+                  mapSubElement(shape|[shape...], op='') - maps the sub element of other shape
+
+                  shape:  other shape or sequence of shapes to map the sub-elements
+                  op:     optional string prefix to append before the mapped sub element names
+              </UserDocu>
+          </Documentation>
+      </Methode>
+      <Methode Name="mapShapes">
+          <Documentation>
+              <UserDocu>
+                  mapShapes(generated, modified, op='')
+
+                  generate element names with user defined mapping
+
+                  generated: a list of tuple(src, dst) that indicating src shape or shapes
+                  generates dst shape or shapes. Note that the dst shape or shapes
+                  must be sub-shapes of this shape.
+                  modified: a list of tuple(src, dst) that indicating src shape or shapes
+                  modifies into dst shape or shapes. Note that the dst shape or
+                  shapes must be sub-shapes of this shape.
+                  op: optional string prefix to append before the mapped sub element names
+              </UserDocu>
+          </Documentation>
+      </Methode>
+      <Methode Name="getElementHistory" Const="true">
+          <Documentation>
+              <UserDocu>
+                  getElementHistory(name) - returns the element mapped name history
+
+                  name: mapped element name belonging to this shape
+
+                  Returns tuple(sourceShapeTag, sourceName, [intermediateNames...]),
+                  or None if no history.
+              </UserDocu>
+          </Documentation>
+      </Methode>
     <Methode Name="getTolerance" Const="true">
       <Documentation>
         <UserDocu>Determines a tolerance from the ones stored in a shape
@@ -906,6 +950,55 @@ optimalBoundingBox([useTriangulation = True, useShapeTolerance = False]) -> boun
         </UserDocu>
       </Documentation>
     </Methode>
+      <Methode Name="clearCache" Const="true">
+          <Documentation>
+              <UserDocu>Clear internal sub-shape cache</UserDocu>
+          </Documentation>
+      </Methode>
+      <Methode Name="findSubShape" Const="true">
+          <Documentation>
+              <UserDocu>
+                  findSubShape(shape) -> (type_name, index)
+
+                  Find sub shape and return the shape type name and index. If not found,
+                  then return (None, 0)
+              </UserDocu>
+          </Documentation>
+      </Methode>
+      <Methode Name="searchSubShape" Const="true" Keyword="true">
+          <Documentation>
+              <UserDocu>
+                  searchSubShape(shape, needName=False, checkGeometry=True, tol=1e-7, atol=1e-12) -> Shape
+
+                  shape: input elementary shape, currently only support Face, Edge, or Vertex
+
+                  needName: if True, return a list of tuple(name, shape), or else return a list
+                  of shapes.
+
+                  checkGeometry: whether to compare geometry
+
+                  tol: distance tolerance
+
+                  atol: angular tolerance
+
+                  Search sub shape by checking vertex coordinates and comparing the underlying
+                  geometries, This can find shapes that are copied. It currently only works with
+                  elementary shapes, Face, Edge, Vertex.
+              </UserDocu>
+          </Documentation>
+      </Methode>
+      <Methode Name="getChildShapes" Const="true">
+          <Documentation>
+              <UserDocu>
+                  getChildShapes(shapetype, avoidtype='') -> list(Shape)
+
+                  Return a list of child sub-shapes of given type.
+
+                  shapetype: the type of requesting sub shapes
+                  avoidtype: optional shape type to skip when exploring
+              </UserDocu>
+          </Documentation>
+      </Methode>
     <!--
     <Attribute Name="Location" ReadOnly="false">
       <Documentation>
diff --git a/src/Mod/Part/App/TopoShapePyImp.cpp b/src/Mod/Part/App/TopoShapePyImp.cpp
index a22e87aa91..33055c4fdf 100644
--- a/src/Mod/Part/App/TopoShapePyImp.cpp
+++ b/src/Mod/Part/App/TopoShapePyImp.cpp
@@ -95,6 +95,7 @@
 #include "OCCError.h"
 #include "PartPyCXX.h"
 #include "ShapeMapHasher.h"
+#include "TopoShapeMapper.h"
 
 
 using namespace Part;
@@ -2414,6 +2415,32 @@ PyObject* TopoShapePy::makeShapeFromMesh(PyObject *args)
     PY_CATCH_OCC
 }
 
+PyObject* TopoShapePy::makeEvolved(PyObject *args, PyObject *kwds)
+{
+    PyObject* Profile;
+    PyObject* AxeProf = Py_True;
+    PyObject* Solid = Py_False;
+    PyObject* ProfOnSpine = Py_False;
+    auto JoinType = JoinType::arc;
+    double Tolerance = 0.0000001;
+
+    static char* kwds_evolve[] = {"Profile", "Join", "AxeProf", "Solid", "ProfOnSpine", "Tolerance", nullptr};
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|iO!O!O!d", kwds_evolve,
+                                     &TopoShapePy::Type, &Profile, &JoinType,
+                                     &PyBool_Type, &AxeProf, &PyBool_Type, &Solid,
+                                     &PyBool_Type, &ProfOnSpine, &Tolerance))
+        return nullptr;
+
+    try {
+        return Py::new_reference_to(shape2pyshape(getTopoShapePtr()->makeElementEvolve(
+            *static_cast<TopoShapePy*>(Profile)->getTopoShapePtr(), JoinType,
+            PyObject_IsTrue(AxeProf) ? CoordinateSystem::global : CoordinateSystem::relativeToSpine,
+            PyObject_IsTrue(Solid) ? MakeSolid::makeSolid : MakeSolid::noSolid,
+            PyObject_IsTrue(ProfOnSpine) ? Spine::on : Spine::notOn,
+            Tolerance)));
+    } PY_CATCH_OCC
+}
+
 PyObject* TopoShapePy::makeWires(PyObject *args) {
     const char *op = nullptr;
     if (!PyArg_ParseTuple(args, "s", &op))
@@ -2975,6 +3002,15 @@ PyObject* TopoShapePy::optimalBoundingBox(PyObject *args)
     }
 }
 
+PyObject* TopoShapePy::clearCache(PyObject* args)
+{
+    if (!PyArg_ParseTuple(args, "")) {
+        return 0;
+    }
+    getTopoShapePtr()->initCache(1);
+    return IncRef();
+}
+
 PyObject* TopoShapePy::defeaturing(PyObject *args)
 {
     PyObject *l;
@@ -3002,6 +3038,88 @@ PyObject* TopoShapePy::defeaturing(PyObject *args)
     }
 }
 
+PyObject* TopoShapePy::findSubShape(PyObject* args)
+{
+    PyObject* pyobj;
+    if (!PyArg_ParseTuple(args, "O", &pyobj)) {
+        return nullptr;
+    }
+
+    PY_TRY
+    {
+        Py::List res;
+        for (auto& s : getPyShapes(pyobj)) {
+            int index = getTopoShapePtr()->findShape(s.getShape());
+            if (index > 0) {
+                res.append(Py::TupleN(Py::String(s.shapeName()), Py::Int(index)));
+            }
+            else {
+                res.append(Py::TupleN(Py::Object(), Py::Int(0)));
+            }
+        }
+        if (PySequence_Check(pyobj)) {
+            return Py::new_reference_to(res);
+        }
+        return Py::new_reference_to(Py::Object(res[0].ptr()));
+    }
+    PY_CATCH_OCC
+}
+
+PyObject* TopoShapePy::searchSubShape(PyObject* args, PyObject* keywds)
+{
+    static char* kwlist[] = {"shape", "needName", "checkGeometry", "tol", "atol", nullptr};
+    PyObject* pyobj;
+    PyObject* needName = Py_False;
+    PyObject* checkGeometry = Py_True;
+    double tol = 1e-7;
+    double atol = 1e-12;
+    if (!PyArg_ParseTupleAndKeywords(args,
+                                     keywds,
+                                     "O!|OOdd",
+                                     kwlist,
+                                     &Type,
+                                     &pyobj,
+                                     &needName,
+                                     &checkGeometry,
+                                     &tol,
+                                     &atol)) {
+        return nullptr;
+    }
+
+    PY_TRY
+    {
+        Py::List res;
+        const TopoShape& shape = *static_cast<TopoShapePy*>(pyobj)->getTopoShapePtr();
+        if (PyObject_IsTrue(needName)) {
+            std::vector<std::string> names;
+            auto shapes = getTopoShapePtr()->findSubShapesWithSharedVertex(
+                shape,
+                &names,
+                PyObject_IsTrue(checkGeometry) ? CheckGeometry::checkGeometry
+                                               : CheckGeometry::ignoreGeometry,
+                tol,
+                atol);
+            for (std::size_t i = 0; i < shapes.size(); ++i) {
+                res.append(Py::TupleN(Py::String(names[i]), shape2pyshape(shapes[i])));
+            }
+        }
+        else {
+            for (auto& s : getTopoShapePtr()->findSubShapesWithSharedVertex(
+                     shape,
+                     nullptr,
+                     PyObject_IsTrue(checkGeometry) ? CheckGeometry::checkGeometry
+                                                    : CheckGeometry::ignoreGeometry,
+                     tol,
+                     atol)) {
+                res.append(shape2pyshape(s));
+            }
+        }
+        return Py::new_reference_to(res);
+    }
+    PY_CATCH_OCC
+}
+
+// End of Methods, Start of Attributes
 
 Py::String TopoShapePy::getShapeType() const
 {
@@ -3108,23 +3226,23 @@ getElements(const TopoShape& sh, TopAbs_ShapeEnum type, TopAbs_ShapeEnum avoid =
     return ret;
 }
 
-//  Todo:  Toponaming Project March, 2024:  This code is defined, appears to be correct, but
-//          is not clearly in use, thus commented out:
-//
-//PyObject *TopoShapePy::getChildShapes(PyObject *args)
-//{
-//    const char *type;
-//    const char *avoid = nullptr;
-//    if (!PyArg_ParseTuple(args, "s|s", &type, &avoid))
-//        return nullptr;
-//
-//    PY_TRY {
-//        return Py::new_reference_to(
-//            getElements(*getTopoShapePtr(),
-//                        TopoShape::shapeType(type),
-//                        avoid && avoid[0] ? TopoShape::shapeType(avoid) : TopAbs_SHAPE));
-//    }PY_CATCH_OCC;
-//}
+PyObject* TopoShapePy::getChildShapes(PyObject* args)
+{
+    const char* type;
+    const char* avoid = nullptr;
+    if (!PyArg_ParseTuple(args, "s|s", &type, &avoid)) {
+        return nullptr;
+    }
+
+    PY_TRY
+    {
+        return Py::new_reference_to(
+            getElements(*getTopoShapePtr(),
+                        TopoShape::shapeType(type),
+                        avoid && avoid[0] ? TopoShape::shapeType(avoid) : TopAbs_SHAPE));
+    }
+    PY_CATCH_OCC;
+}
 
 Py::List TopoShapePy::getSubShapes() const
 {
@@ -3201,14 +3319,121 @@ Py::Float TopoShapePy::getVolume() const
     return Py::Float(props.Mass());
 }
 
-PyObject *TopoShapePy::getCustomAttributes(const char* attr) const
+PyObject* TopoShapePy::getElementHistory(PyObject* args)
 {
-    if (!attr)
+    const char* pyname;
+    if (!PyArg_ParseTuple(args, "s", &pyname)) {
+        return 0;
+    }
+
+    Data::MappedName name(pyname);
+    PY_TRY
+    {
+        Data::MappedName original;
+        std::vector<Data::MappedName> history;
+        long tag = getTopoShapePtr()->getElementHistory(name, &original, &history);
+        if (!tag) {
+            Py_Return;
+        }
+        Py::Tuple ret(3);
+        ret.setItem(0, Py::Int(tag));
+        std::string tmp;
+        ret.setItem(1, Py::String(original.appendToBuffer(tmp)));
+        Py::List pyHistory;
+        for (auto& h : history) {
+            tmp.clear();
+            pyHistory.append(Py::String(h.appendToBuffer(tmp)));
+        }
+        ret.setItem(2, pyHistory);
+        return Py::new_reference_to(ret);
+    }
+    PY_CATCH_OCC
+}
+
+struct PyShapeMapper: Part::ShapeMapper
+{
+    bool populate(MappingStatus status, PyObject* pyobj)
+    {
+        if (!pyobj || pyobj == Py_None) {
+            return true;
+        }
+        try {
+            Py::Sequence seq(pyobj);
+            for (size_t i = 0, count = seq.size(); i < count; ++i) {
+                Py::Sequence item(seq[i].ptr());
+                if (item.size() != 2) {
+                    return false;
+                }
+
+                Part::ShapeMapper::populate(status,
+                                            getPyShapes(item[0].ptr()),
+                                            getPyShapes(item[1].ptr()));
+            }
+        }
+        catch (Py::Exception&) {
+            PyErr_Clear();
+            return false;
+        }
+        return true;
+    }
+
+    void init(PyObject* g, PyObject* m)
+    {
+        const char* msg =
+            "Expect input mapping to be a list of tuple(srcShape|shapeList, dstShape|shapeList)";
+        if (!populate(MappingStatus::Generated, g) || !populate(MappingStatus::Modified, m)) {
+            throw Py::TypeError(msg);
+        }
+    }
+};
+
+PyObject* TopoShapePy::mapShapes(PyObject* args)
+{
+    PyObject* generated;
+    PyObject* modified;
+    const char* op = nullptr;
+    if (!PyArg_ParseTuple(args, "OO|s", &generated, &modified, &op)) {
+        return 0;
+    }
+    PY_TRY
+    {
+        PyShapeMapper mapper;
+        mapper.init(generated, modified);
+        TopoShape& self = *getTopoShapePtr();
+        TopoShape s(self.Tag, self.Hasher);
+        s.makeShapeWithElementMap(self.getShape(), mapper, mapper.shapes, op);
+        self = s;
+        return IncRef();
+    }
+    PY_CATCH_OCC
+}
+
+PyObject* TopoShapePy::mapSubElement(PyObject* args)
+{
+    const char* op = nullptr;
+    PyObject* sh;
+    if (!PyArg_ParseTuple(args, "O|s", &sh, &op)) {
+        return 0;
+    }
+    PY_TRY
+    {
+        getTopoShapePtr()->mapSubElement(getPyShapes(sh), op);
+        return IncRef();
+    }
+    PY_CATCH_OCC
+}
+
+PyObject* TopoShapePy::getCustomAttributes(const char* attr) const
+{
+    if (!attr) {
         return nullptr;
-    PY_TRY {
-        TopoDS_Shape res = getTopoShapePtr()->getSubShape(attr,true);
-        if (!res.IsNull())
+    }
+    PY_TRY
+    {
+        TopoDS_Shape res = getTopoShapePtr()->getSubShape(attr, true);
+        if (!res.IsNull()) {
             return Py::new_reference_to(shape2pyshape(res));
+        }
     }
     PY_CATCH_OCC
     return nullptr;
diff --git a/src/Mod/Part/App/TopoShapeShellPyImp.cpp b/src/Mod/Part/App/TopoShapeShellPyImp.cpp
index 25f9892026..b15f27048e 100644
--- a/src/Mod/Part/App/TopoShapeShellPyImp.cpp
+++ b/src/Mod/Part/App/TopoShapeShellPyImp.cpp
@@ -38,6 +38,7 @@
 #include <Base/VectorPy.h>
 
 #include "OCCError.h"
+#include "PartPyCXX.h"
 #include "Tools.h"
 #include "TopoShapeCompoundPy.h"
 #include "TopoShapeCompoundPy.h"
@@ -45,7 +46,7 @@
 #include "TopoShapeShellPy.h"
 #include "TopoShapeShellPy.cpp"
 #include "TopoShapeSolidPy.h"
-
+#include "TopoShapeOpCode.h"
 
 using namespace Part;
 
@@ -85,6 +86,11 @@ int TopoShapeShellPy::PyInit(PyObject* args, PyObject* /*kwd*/)
     if (!PyArg_ParseTuple(args, "O", &obj))
         return -1;
 
+#ifdef FC_USE_TNP_FIX
+    try {
+        getTopoShapePtr()->makeElementBoolean(Part::OpCodes::Shell,getPyShapes(obj));
+    } _PY_CATCH_OCC(return(-1))
+#else
     BRep_Builder builder;
     TopoDS_Shape shape;
     TopoDS_Shell shell;
@@ -121,6 +127,7 @@ int TopoShapeShellPy::PyInit(PyObject* args, PyObject* /*kwd*/)
     }
 
     getTopoShapePtr()->setShape(shape);
+#endif
     return 0;
 }
 
@@ -134,11 +141,14 @@ PyObject*  TopoShapeShellPy::add(PyObject *args)
     TopoDS_Shape shell = getTopoShapePtr()->getShape();
 
     try {
-        const TopoDS_Shape& sh = static_cast<TopoShapeFacePy*>(obj)->
-            getTopoShapePtr()->getShape();
+        const TopoShape& shape = *static_cast<TopoShapeFacePy*>(obj)->getTopoShapePtr();
+        const auto &sh = shape.getShape();
         if (!sh.IsNull()) {
             builder.Add(shell, sh);
             BRepCheck_Analyzer check(shell);
+#ifdef FC_USE_TNP_FIX
+            getTopoShapePtr()->mapSubElement(shape);
+#endif
             if (!check.IsValid()) {
                 ShapeUpgrade_ShellSewing sewShell;
                 getTopoShapePtr()->setShape(sewShell.ApplySewing(shell));
@@ -167,7 +177,14 @@ PyObject*  TopoShapeShellPy::getFreeEdges(PyObject *args)
     as.CheckOrientedShells(getTopoShapePtr()->getShape(), Standard_True, Standard_True);
 
     TopoDS_Compound comp = as.FreeEdges();
+#ifdef FC_USE_TNP_FIX
+    TopoShape res;
+    res.setShape(comp);
+    res.mapSubElement(*getTopoShapePtr());
+    return Py::new_reference_to(shape2pyshape(res));
+#else
     return new TopoShapeCompoundPy(new TopoShape(comp));
+#endif
 }
 
 PyObject*  TopoShapeShellPy::getBadEdges(PyObject *args)
@@ -179,7 +196,14 @@ PyObject*  TopoShapeShellPy::getBadEdges(PyObject *args)
     as.CheckOrientedShells(getTopoShapePtr()->getShape(), Standard_True, Standard_True);
 
     TopoDS_Compound comp = as.BadEdges();
+#ifdef FC_USE_TNP_FIX
+    TopoShape res;
+    res.setShape(comp);
+    res.mapSubElement(*getTopoShapePtr());
+    return Py::new_reference_to(shape2pyshape(res));
+#else
     return new TopoShapeCompoundPy(new TopoShape(comp));
+#endif
 }
 
 PyObject* TopoShapeShellPy::makeHalfSpace(PyObject *args)
diff --git a/src/Mod/Part/App/TopoShapeSolidPyImp.cpp b/src/Mod/Part/App/TopoShapeSolidPyImp.cpp
index 3b069d8e06..f81efe8f2b 100644
--- a/src/Mod/Part/App/TopoShapeSolidPyImp.cpp
+++ b/src/Mod/Part/App/TopoShapeSolidPyImp.cpp
@@ -47,6 +47,7 @@
 #include <Base/VectorPy.h>
 
 #include "OCCError.h"
+#include "PartPyCXX.h"
 #include "Tools.h"
 
 // inclusion of the generated files (generated out of TopoShapeSolidPy.xml)
@@ -87,6 +88,9 @@ int TopoShapeSolidPy::PyInit(PyObject* args, PyObject* /*kwd*/)
         return -1;
 
     try {
+#ifdef FC_USE_TNP_FIX
+        getTopoShapePtr()->makeElementSolid(*static_cast<TopoShapePy*>(obj)->getTopoShapePtr());
+#else
         const TopoDS_Shape& shape = static_cast<TopoShapePy*>(obj)
             ->getTopoShapePtr()->getShape();
         //first, if we were given a compsolid, try making a solid out of it
@@ -122,7 +126,7 @@ int TopoShapeSolidPy::PyInit(PyObject* args, PyObject* /*kwd*/)
         } else /*if (count > 1)*/ {
             Standard_Failure::Raise("Only one compsolid can be accepted. Provided shape has more than one compsolid.");
         }
-
+#endif
     }
     catch (Standard_Failure& err) {
         std::stringstream errmsg;
@@ -216,7 +220,14 @@ Py::Object TopoShapeSolidPy::getOuterShell() const
     const TopoDS_Shape& shape = getTopoShapePtr()->getShape();
     if (!shape.IsNull() && shape.ShapeType() == TopAbs_SOLID)
         shell = BRepClass3d::OuterShell(TopoDS::Solid(shape));
+#ifdef FC_USE_TNP_FIX
+    TopoShape res;
+    res.setShape(shell);
+    res.mapSubElement(*getTopoShapePtr());
+    return shape2pyshape(res);
+#else
     return Py::Object(new TopoShapeShellPy(new TopoShape(shell)),true);
+#endif
 }
 
 PyObject* TopoShapeSolidPy::getMomentOfInertia(PyObject *args)
@@ -316,7 +327,13 @@ PyObject* TopoShapeSolidPy::offsetFaces(PyObject *args)
     try {
         builder.MakeOffsetShape();
         const TopoDS_Shape& offsetshape = builder.Shape();
+#ifndef FC_USE_TNP_FIX
+        TopoShape res;
+        res.setShape(offsetshape);
+        return Py::new_reference_to(shape2pyshape(res));
+#else
         return new TopoShapeSolidPy(new TopoShape(offsetshape));
+#endif
     }
     catch (Standard_Failure& e) {