| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| #include <QApplication>
|
| #include <QMessageBox>
|
| #include <limits>
|
| #include <sstream>
|
|
|
| #include <BRepBuilderAPI_MakePolygon.hxx>
|
| #include <BRep_Builder.hxx>
|
| #include <TopoDS_Compound.hxx>
|
|
|
| #include <App/Application.h>
|
| #include <App/Document.h>
|
| #include <App/DocumentObjectGroup.h>
|
| #include <Base/CoordinateSystem.h>
|
| #include <Base/Tools.h>
|
| #include <Gui/Application.h>
|
| #include <Gui/Command.h>
|
| #include <Gui/Control.h>
|
| #include <Gui/MainWindow.h>
|
| #include <Gui/Selection/Selection.h>
|
| #include <Mod/Mesh/App/Core/Algorithm.h>
|
| #include <Mod/Mesh/App/Core/Approximation.h>
|
| #include <Mod/Mesh/App/MeshFeature.h>
|
| #include <Mod/Part/App/FaceMakerCheese.h>
|
| #include <Mod/Part/App/Geometry.h>
|
| #include <Mod/Part/App/PartFeature.h>
|
| #include <Mod/Part/App/Tools.h>
|
| #include <Mod/Points/App/Structured.h>
|
| #include <Mod/ReverseEngineering/App/ApproxSurface.h>
|
|
|
| #include "FitBSplineCurve.h"
|
| #include "FitBSplineSurface.h"
|
| #include "Poisson.h"
|
| #include "Segmentation.h"
|
| #include "SegmentationManual.h"
|
|
|
|
|
| using namespace std;
|
|
|
| DEF_STD_CMD_A(CmdApproxCurve)
|
|
|
| CmdApproxCurve::CmdApproxCurve()
|
| : Command("Reen_ApproxCurve")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Approximate B-Spline Curve…");
|
| sToolTipText = QT_TR_NOOP("Approximates a B-spline curve");
|
| sWhatsThis = "Reen_ApproxCurve";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdApproxCurve::activated(int)
|
| {
|
| App::DocumentObjectT objT;
|
| auto obj = Gui::Selection().getObjectsOfType(App::GeoFeature::getClassTypeId());
|
| if (obj.size() != 1 || !(obj.at(0)->isDerivedFrom<Points::Feature>())) {
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Reen_ApproxSurface", "Wrong selection"),
|
| qApp->translate("Reen_ApproxSurface", "Select a point cloud.")
|
| );
|
| return;
|
| }
|
|
|
| objT = obj.front();
|
| Gui::Control().showDialog(new ReenGui::TaskFitBSplineCurve(objT));
|
| }
|
|
|
| bool CmdApproxCurve::isActive()
|
| {
|
| return (hasActiveDocument() && !Gui::Control().activeDialog());
|
| }
|
|
|
| DEF_STD_CMD_A(CmdApproxSurface)
|
|
|
| CmdApproxSurface::CmdApproxSurface()
|
| : Command("Reen_ApproxSurface")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Approximate B-Spline Surface…");
|
| sToolTipText = QT_TR_NOOP("Approximates a B-spline surface");
|
| sWhatsThis = "Reen_ApproxSurface";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "actions/FitSurface";
|
| }
|
|
|
| void CmdApproxSurface::activated(int)
|
| {
|
| App::DocumentObjectT objT;
|
| std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType(
|
| App::GeoFeature::getClassTypeId()
|
| );
|
| if (obj.size() != 1
|
| || !(obj.at(0)->isDerivedFrom<Points::Feature>() || obj.at(0)->isDerivedFrom<Mesh::Feature>())) {
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Reen_ApproxSurface", "Wrong selection"),
|
| qApp->translate("Reen_ApproxSurface", "Select a point cloud or mesh.")
|
| );
|
| return;
|
| }
|
|
|
| objT = obj.front();
|
| Gui::Control().showDialog(new ReenGui::TaskFitBSplineSurface(objT));
|
| }
|
|
|
| bool CmdApproxSurface::isActive()
|
| {
|
| return (hasActiveDocument() && !Gui::Control().activeDialog());
|
| }
|
|
|
| DEF_STD_CMD_A(CmdApproxPlane)
|
|
|
| CmdApproxPlane::CmdApproxPlane()
|
| : Command("Reen_ApproxPlane")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Plane");
|
| sToolTipText = QT_TR_NOOP("Approximates a plane");
|
| sWhatsThis = "Reen_ApproxPlane";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdApproxPlane::activated(int)
|
| {
|
| std::vector<App::GeoFeature*> obj = Gui::Selection().getObjectsOfType<App::GeoFeature>();
|
| for (const auto& it : obj) {
|
| std::vector<Base::Vector3d> aPoints;
|
| std::vector<Base::Vector3d> aNormals;
|
|
|
| std::vector<App::Property*> List;
|
| it->getPropertyList(List);
|
| for (const auto& jt : List) {
|
| if (jt->isDerivedFrom<App::PropertyComplexGeoData>()) {
|
| const Data::ComplexGeoData* data
|
| = static_cast<App::PropertyComplexGeoData*>(jt)->getComplexData();
|
| if (data) {
|
| data->getPoints(aPoints, aNormals, 0.01f);
|
| if (!aPoints.empty()) {
|
| break;
|
| }
|
| }
|
| }
|
| }
|
|
|
| if (!aPoints.empty()) {
|
|
|
| Base::Vector3f refNormal(0, 0, 0);
|
| if (!aNormals.empty()) {
|
| refNormal = Base::convertTo<Base::Vector3f>(aNormals.front());
|
| }
|
|
|
| std::vector<Base::Vector3f> aData;
|
| aData.reserve(aPoints.size());
|
| for (const auto& jt : aPoints) {
|
| aData.push_back(Base::toVector<float>(jt));
|
| }
|
| MeshCore::PlaneFit fit;
|
| fit.AddPoints(aData);
|
| float sigma = fit.Fit();
|
| Base::Vector3f base = fit.GetBase();
|
| Base::Vector3f dirU = fit.GetDirU();
|
| Base::Vector3f dirV = fit.GetDirV();
|
| Base::Vector3f norm = fit.GetNormal();
|
|
|
|
|
|
|
| if (refNormal * norm < 0) {
|
| norm = -norm;
|
| dirU = -dirU;
|
| }
|
|
|
| float length, width;
|
| fit.Dimension(length, width);
|
|
|
|
|
| base = base - (0.5f * length * dirU + 0.5f * width * dirV);
|
|
|
| Base::CoordinateSystem cs;
|
| cs.setPosition(Base::convertTo<Base::Vector3d>(base));
|
| cs.setAxes(Base::convertTo<Base::Vector3d>(norm), Base::convertTo<Base::Vector3d>(dirU));
|
| Base::Placement pm = Base::CoordinateSystem().displacement(cs);
|
| double q0, q1, q2, q3;
|
| pm.getRotation().getValue(q0, q1, q2, q3);
|
|
|
| Base::Console().log("RMS value for plane fit with %lu points: %.4f\n", aData.size(), sigma);
|
| Base::Console().log(" Plane base(%.4f, %.4f, %.4f)\n", base.x, base.y, base.z);
|
| Base::Console().log(" Plane normal(%.4f, %.4f, %.4f)\n", norm.x, norm.y, norm.z);
|
|
|
| std::stringstream str;
|
| str << "from FreeCAD import Base" << std::endl;
|
| str << "App.ActiveDocument.addObject('Part::Plane','Plane_fit')" << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Length = " << length << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Width = " << width << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Placement = Base.Placement("
|
| << "Base.Vector(" << base.x << "," << base.y << "," << base.z << "),"
|
| << "Base.Rotation(" << q0 << "," << q1 << "," << q2 << "," << q3 << "))"
|
| << std::endl;
|
|
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Fit plane"));
|
| runCommand(Gui::Command::Doc, str.str().c_str());
|
| commitCommand();
|
| updateActive();
|
| }
|
| }
|
| }
|
|
|
| bool CmdApproxPlane::isActive()
|
| {
|
| if (getSelection().countObjectsOfType<App::GeoFeature>() > 0) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdApproxCylinder)
|
|
|
| CmdApproxCylinder::CmdApproxCylinder()
|
| : Command("Reen_ApproxCylinder")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Cylinder");
|
| sToolTipText = QT_TR_NOOP("Approximates a cylinder");
|
| sWhatsThis = "Reen_ApproxCylinder";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdApproxCylinder::activated(int)
|
| {
|
| std::vector<Mesh::Feature*> sel = getSelection().getObjectsOfType<Mesh::Feature>();
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Fit cylinder"));
|
| for (auto it : sel) {
|
| const Mesh::MeshObject& mesh = it->Mesh.getValue();
|
| const MeshCore::MeshKernel& kernel = mesh.getKernel();
|
| MeshCore::CylinderFit fit;
|
| fit.AddPoints(kernel.GetPoints());
|
|
|
|
|
| {
|
| std::vector<MeshCore::FacetIndex> facets(kernel.CountFacets());
|
| std::generate(facets.begin(), facets.end(), Base::iotaGen<MeshCore::FacetIndex>(0));
|
| std::vector<Base::Vector3f> normals = kernel.GetFacetNormals(facets);
|
| Base::Vector3f base = fit.GetGravity();
|
| Base::Vector3f axis = fit.GetInitialAxisFromNormals(normals);
|
| fit.SetInitialValues(base, axis);
|
| }
|
|
|
| if (fit.Fit() < std::numeric_limits<float>::max()) {
|
| Base::Vector3f base, top;
|
| fit.GetBounding(base, top);
|
| float height = Base::Distance(base, top);
|
|
|
| Base::Rotation rot;
|
| rot.setValue(Base::Vector3d(0, 0, 1), Base::convertTo<Base::Vector3d>(fit.GetAxis()));
|
| double q0, q1, q2, q3;
|
| rot.getValue(q0, q1, q2, q3);
|
|
|
| std::stringstream str;
|
| str << "from FreeCAD import Base" << std::endl;
|
| str << "App.ActiveDocument.addObject('Part::Cylinder','Cylinder_fit')" << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Radius = " << fit.GetRadius() << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Height = " << height << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Placement = Base.Placement("
|
| << "Base.Vector(" << base.x << "," << base.y << "," << base.z << "),"
|
| << "Base.Rotation(" << q0 << "," << q1 << "," << q2 << "," << q3 << "))"
|
| << std::endl;
|
|
|
| runCommand(Gui::Command::Doc, str.str().c_str());
|
| }
|
| }
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdApproxCylinder::isActive()
|
| {
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() > 0) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdApproxSphere)
|
|
|
| CmdApproxSphere::CmdApproxSphere()
|
| : Command("Reen_ApproxSphere")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Sphere");
|
| sToolTipText = QT_TR_NOOP("Approximates a sphere");
|
| sWhatsThis = "Reen_ApproxSphere";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdApproxSphere::activated(int)
|
| {
|
| std::vector<Mesh::Feature*> sel = getSelection().getObjectsOfType<Mesh::Feature>();
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Fit sphere"));
|
| for (auto it : sel) {
|
| const Mesh::MeshObject& mesh = it->Mesh.getValue();
|
| const MeshCore::MeshKernel& kernel = mesh.getKernel();
|
| MeshCore::SphereFit fit;
|
| fit.AddPoints(kernel.GetPoints());
|
| if (fit.Fit() < std::numeric_limits<float>::max()) {
|
| Base::Vector3f base = fit.GetCenter();
|
|
|
| std::stringstream str;
|
| str << "from FreeCAD import Base" << std::endl;
|
| str << "App.ActiveDocument.addObject('Part::Sphere','Sphere_fit')" << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Radius = " << fit.GetRadius() << std::endl;
|
| str << "App.ActiveDocument.ActiveObject.Placement = Base.Placement("
|
| << "Base.Vector(" << base.x << "," << base.y << "," << base.z << "),"
|
| << "Base.Rotation(" << 1 << "," << 0 << "," << 0 << "," << 0 << "))" << std::endl;
|
|
|
| runCommand(Gui::Command::Doc, str.str().c_str());
|
| }
|
| }
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdApproxSphere::isActive()
|
| {
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() > 0) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdApproxPolynomial)
|
|
|
| CmdApproxPolynomial::CmdApproxPolynomial()
|
| : Command("Reen_ApproxPolynomial")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Polynomial Surface");
|
| sToolTipText = QT_TR_NOOP("Approximates a polynomial surface");
|
| sWhatsThis = "Reen_ApproxPolynomial";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdApproxPolynomial::activated(int)
|
| {
|
| std::vector<Mesh::Feature*> sel = getSelection().getObjectsOfType<Mesh::Feature>();
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Fit polynomial surface"));
|
| for (auto it : sel) {
|
| const Mesh::MeshObject& mesh = it->Mesh.getValue();
|
| const MeshCore::MeshKernel& kernel = mesh.getKernel();
|
| MeshCore::SurfaceFit fit;
|
| fit.AddPoints(kernel.GetPoints());
|
| if (fit.Fit() < std::numeric_limits<float>::max()) {
|
| Base::BoundBox3f bbox = fit.GetBoundings();
|
| std::vector<Base::Vector3d> poles
|
| = fit.toBezier(bbox.MinX, bbox.MaxX, bbox.MinY, bbox.MaxY);
|
| fit.Transform(poles);
|
|
|
| TColgp_Array2OfPnt grid(1, 3, 1, 3);
|
| grid.SetValue(1, 1, Base::convertTo<gp_Pnt>(poles.at(0)));
|
| grid.SetValue(2, 1, Base::convertTo<gp_Pnt>(poles.at(1)));
|
| grid.SetValue(3, 1, Base::convertTo<gp_Pnt>(poles.at(2)));
|
| grid.SetValue(1, 2, Base::convertTo<gp_Pnt>(poles.at(3)));
|
| grid.SetValue(2, 2, Base::convertTo<gp_Pnt>(poles.at(4)));
|
| grid.SetValue(3, 2, Base::convertTo<gp_Pnt>(poles.at(5)));
|
| grid.SetValue(1, 3, Base::convertTo<gp_Pnt>(poles.at(6)));
|
| grid.SetValue(2, 3, Base::convertTo<gp_Pnt>(poles.at(7)));
|
| grid.SetValue(3, 3, Base::convertTo<gp_Pnt>(poles.at(8)));
|
|
|
| Handle(Geom_BezierSurface) bezier(new Geom_BezierSurface(grid));
|
| Part::Feature* part = static_cast<Part::Feature*>(doc->addObject("Part::Spline", "Bezier"));
|
| part->Shape.setValue(Part::GeomBezierSurface(bezier).toShape());
|
| }
|
| }
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdApproxPolynomial::isActive()
|
| {
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() > 0) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdSegmentation)
|
|
|
| CmdSegmentation::CmdSegmentation()
|
| : Command("Reen_Segmentation")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Mesh Segmentation…");
|
| sToolTipText = QT_TR_NOOP("Creates separate mesh segments based on surface types");
|
| sWhatsThis = "Reen_Segmentation";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdSegmentation::activated(int)
|
| {
|
| std::vector<Mesh::Feature*> objs = Gui::Selection().getObjectsOfType<Mesh::Feature>();
|
| Mesh::Feature* mesh = static_cast<Mesh::Feature*>(objs.front());
|
| Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
|
| if (!dlg) {
|
| dlg = new ReverseEngineeringGui::TaskSegmentation(mesh);
|
| }
|
| Gui::Control().showDialog(dlg);
|
| }
|
|
|
| bool CmdSegmentation::isActive()
|
| {
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
| return Gui::Selection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdSegmentationManual)
|
|
|
| CmdSegmentationManual::CmdSegmentationManual()
|
| : Command("Reen_SegmentationManual")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Manual Segmentation…");
|
| sToolTipText = QT_TR_NOOP("Creates mesh segments manually");
|
| sWhatsThis = "Reen_SegmentationManual";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdSegmentationManual::activated(int)
|
| {
|
| Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
|
| if (!dlg) {
|
| dlg = new ReverseEngineeringGui::TaskSegmentationManual();
|
| }
|
| Gui::Control().showDialog(dlg);
|
| }
|
|
|
| bool CmdSegmentationManual::isActive()
|
| {
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
| return hasActiveDocument();
|
| }
|
|
|
| DEF_STD_CMD_A(CmdSegmentationFromComponents)
|
|
|
| CmdSegmentationFromComponents::CmdSegmentationFromComponents()
|
| : Command("Reen_SegmentationFromComponents")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("From Components");
|
| sToolTipText = QT_TR_NOOP("Creates mesh segments from components");
|
| sWhatsThis = "Reen_SegmentationFromComponents";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdSegmentationFromComponents::activated(int)
|
| {
|
| std::vector<Mesh::Feature*> sel = getSelection().getObjectsOfType<Mesh::Feature>();
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| doc->openTransaction("Segmentation");
|
|
|
| for (auto it : sel) {
|
| std::string internalname = "Segments_";
|
| internalname += it->getNameInDocument();
|
| auto* group = doc->addObject<App::DocumentObjectGroup>(internalname.c_str());
|
| std::string labelname = "Segments ";
|
| labelname += it->Label.getValue();
|
| group->Label.setValue(labelname);
|
|
|
| const Mesh::MeshObject& mesh = it->Mesh.getValue();
|
| std::vector<std::vector<MeshCore::FacetIndex>> comps = mesh.getComponents();
|
| for (const auto& jt : comps) {
|
| std::unique_ptr<Mesh::MeshObject> segment(mesh.meshFromSegment(jt));
|
| auto* feaSegm = group->addObject<Mesh::Feature>("Segment");
|
| Mesh::MeshObject* feaMesh = feaSegm->Mesh.startEditing();
|
| feaMesh->swap(*segment);
|
| feaSegm->Mesh.finishEditing();
|
| }
|
| }
|
|
|
| doc->commitTransaction();
|
| doc->recompute();
|
| }
|
|
|
| bool CmdSegmentationFromComponents::isActive()
|
| {
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() > 0) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdMeshBoundary)
|
|
|
| CmdMeshBoundary::CmdMeshBoundary()
|
| : Command("Reen_MeshBoundary")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Wire From Mesh Boundary…");
|
| sToolTipText = QT_TR_NOOP("Creates a wire from mesh boundaries");
|
| sWhatsThis = "Reen_Segmentation";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdMeshBoundary::activated(int)
|
| {
|
| std::vector<Mesh::Feature*> objs = Gui::Selection().getObjectsOfType<Mesh::Feature>();
|
| App::Document* document = App::GetApplication().getActiveDocument();
|
| document->openTransaction("Wire from mesh");
|
| for (auto it : objs) {
|
| const Mesh::MeshObject& mesh = it->Mesh.getValue();
|
| std::list<std::vector<Base::Vector3f>> bounds;
|
| MeshCore::MeshAlgorithm algo(mesh.getKernel());
|
| algo.GetMeshBorders(bounds);
|
|
|
| BRep_Builder builder;
|
| TopoDS_Compound compound;
|
| builder.MakeCompound(compound);
|
|
|
| TopoDS_Shape shape;
|
| std::vector<TopoDS_Wire> wires;
|
|
|
| for (const auto& bt : bounds) {
|
| BRepBuilderAPI_MakePolygon mkPoly;
|
| for (auto it = bt.rbegin(); it != bt.rend(); ++it) {
|
| mkPoly.Add(gp_Pnt(it->x, it->y, it->z));
|
| }
|
| if (mkPoly.IsDone()) {
|
| builder.Add(compound, mkPoly.Wire());
|
| wires.push_back(mkPoly.Wire());
|
| }
|
| }
|
|
|
| try {
|
| shape = Part::FaceMakerCheese::makeFace(wires);
|
| }
|
| catch (...) {
|
| }
|
|
|
| if (!shape.IsNull()) {
|
| Part::Feature* shapeFea = document->addObject<Part::Feature>("Face from mesh");
|
| shapeFea->Shape.setValue(shape);
|
| }
|
| else {
|
| Part::Feature* shapeFea = document->addObject<Part::Feature>("Wire from mesh");
|
| shapeFea->Shape.setValue(compound);
|
| }
|
| }
|
| document->commitTransaction();
|
| }
|
|
|
| bool CmdMeshBoundary::isActive()
|
| {
|
| return Gui::Selection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdPoissonReconstruction)
|
|
|
| CmdPoissonReconstruction::CmdPoissonReconstruction()
|
| : Command("Reen_PoissonReconstruction")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Poisson…");
|
| sToolTipText = QT_TR_NOOP("Performs Poisson surface reconstruction");
|
| sWhatsThis = "Reen_PoissonReconstruction";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdPoissonReconstruction::activated(int)
|
| {
|
| App::DocumentObjectT objT;
|
| std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType(
|
| Points::Feature::getClassTypeId()
|
| );
|
| if (obj.size() != 1) {
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Reen_ApproxSurface", "Wrong selection"),
|
| qApp->translate("Reen_ApproxSurface", "Select a single point cloud.")
|
| );
|
| return;
|
| }
|
|
|
| objT = obj.front();
|
| Gui::Control().showDialog(new ReenGui::TaskPoisson(objT));
|
| }
|
|
|
| bool CmdPoissonReconstruction::isActive()
|
| {
|
| return (hasActiveDocument() && !Gui::Control().activeDialog());
|
| }
|
|
|
| DEF_STD_CMD_A(CmdViewTriangulation)
|
|
|
| CmdViewTriangulation::CmdViewTriangulation()
|
| : Command("Reen_ViewTriangulation")
|
| {
|
| sAppModule = "Reen";
|
| sGroup = QT_TR_NOOP("Reverse Engineering");
|
| sMenuText = QT_TR_NOOP("Structured Point Clouds");
|
| sToolTipText = QT_TR_NOOP("Triangulates structured point clouds");
|
| sStatusTip = QT_TR_NOOP("Triangulation of structured point clouds");
|
| sWhatsThis = "Reen_ViewTriangulation";
|
| }
|
|
|
| void CmdViewTriangulation::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType(
|
| Points::Structured::getClassTypeId()
|
| );
|
| addModule(App, "ReverseEngineering");
|
| openCommand(QT_TRANSLATE_NOOP("Command", "View triangulation"));
|
| try {
|
| for (const auto& it : obj) {
|
| App::DocumentObjectT objT(it);
|
| QString document = QString::fromStdString(objT.getDocumentPython());
|
| QString object = QString::fromStdString(objT.getObjectPython());
|
|
|
| QString command = QStringLiteral(
|
| "%1.addObject('Mesh::Feature', 'View mesh').Mesh "
|
| "= ReverseEngineering.viewTriangulation("
|
| "Points=%2.Points,"
|
| "Width=%2.Width,"
|
| "Height=%2.Height)"
|
| )
|
| .arg(document, object);
|
| runCommand(Doc, command.toLatin1());
|
| }
|
|
|
| commitCommand();
|
| updateActive();
|
| }
|
| catch (const Base::Exception& e) {
|
| abortCommand();
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Reen_ViewTriangulation", "View triangulation failed"),
|
| QString::fromLatin1(e.what())
|
| );
|
| }
|
| }
|
|
|
| bool CmdViewTriangulation::isActive()
|
| {
|
| return (Gui::Selection().countObjectsOfType<Points::Structured>() > 0);
|
| }
|
|
|
| void CreateReverseEngineeringCommands()
|
| {
|
| Gui::CommandManager& rcCmdMgr = Gui::Application::Instance->commandManager();
|
| rcCmdMgr.addCommand(new CmdApproxCurve());
|
| rcCmdMgr.addCommand(new CmdApproxSurface());
|
| rcCmdMgr.addCommand(new CmdApproxPlane());
|
| rcCmdMgr.addCommand(new CmdApproxCylinder());
|
| rcCmdMgr.addCommand(new CmdApproxSphere());
|
| rcCmdMgr.addCommand(new CmdApproxPolynomial());
|
| rcCmdMgr.addCommand(new CmdSegmentation());
|
| rcCmdMgr.addCommand(new CmdSegmentationManual());
|
| rcCmdMgr.addCommand(new CmdSegmentationFromComponents());
|
| rcCmdMgr.addCommand(new CmdMeshBoundary());
|
| rcCmdMgr.addCommand(new CmdPoissonReconstruction());
|
| rcCmdMgr.addCommand(new CmdViewTriangulation());
|
| }
|
|
|
