|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| #include <FCConfig.h>
|
|
|
| #ifdef FC_OS_WIN32
|
| # include <windows.h>
|
| #endif
|
| #include <map>
|
| #include <limits>
|
|
|
| #include <QApplication>
|
| #include <QPointer>
|
| #include <qfileinfo.h>
|
| #include <qinputdialog.h>
|
| #include <qmessagebox.h>
|
| #include <qstringlist.h>
|
|
|
| #include <Gui/InventorAll.h>
|
|
|
| #include <App/DocumentObject.h>
|
| #include <App/DocumentObjectGroup.h>
|
| #include <Base/Console.h>
|
| #include <Base/Tools.h>
|
| #include <Gui/Application.h>
|
| #include <Gui/BitmapFactory.h>
|
| #include <Gui/Command.h>
|
| #include <Gui/Control.h>
|
| #include <Gui/Document.h>
|
| #include <Gui/FileDialog.h>
|
| #include <Gui/MainWindow.h>
|
| #include <Gui/MouseSelection.h>
|
| #include <Gui/Navigation/NavigationStyle.h>
|
| #include <Gui/Selection/Selection.h>
|
| #include <Gui/View3DInventor.h>
|
| #include <Gui/View3DInventorViewer.h>
|
| #include <Gui/WaitCursor.h>
|
|
|
| #include <Mod/Mesh/App/Core/Smoothing.h>
|
| #include <Mod/Mesh/App/FeatureMeshCurvature.h>
|
| #include <Mod/Mesh/App/MeshFeature.h>
|
|
|
| #include "DlgDecimating.h"
|
| #include "DlgEvaluateMeshImp.h"
|
| #include "DlgRegularSolidImp.h"
|
| #include "DlgSmoothing.h"
|
| #include "MeshEditor.h"
|
| #include "RemeshGmsh.h"
|
| #include "RemoveComponents.h"
|
| #include "Segmentation.h"
|
| #include "SegmentationBestFit.h"
|
| #include "ViewProviderCurvature.h"
|
| #include "ViewProviderMeshFaceSet.h"
|
|
|
|
|
| using namespace Mesh;
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshUnion)
|
|
|
| CmdMeshUnion::CmdMeshUnion()
|
| : Command("Mesh_Union")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Union");
|
| sToolTipText = QT_TR_NOOP("Unifies the selected meshes");
|
| sWhatsThis = "Mesh_Union";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Union";
|
| }
|
|
|
| void CmdMeshUnion::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| std::string name1 = obj.front()->getNameInDocument();
|
| std::string name2 = obj.back()->getNameInDocument();
|
| std::string name3 = getUniqueObjectName("Union");
|
|
|
| try {
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh union"));
|
| doCommand(
|
| Doc,
|
| "import OpenSCADUtils\n"
|
| "mesh = "
|
| "OpenSCADUtils.meshoptempfile('union',(App.ActiveDocument.%s.Mesh,App."
|
| "ActiveDocument.%s.Mesh))\n"
|
| "App.ActiveDocument.addObject(\"Mesh::Feature\",\"%s\")\n"
|
| "App.ActiveDocument.%s.Mesh = mesh\n",
|
| name1.c_str(),
|
| name2.c_str(),
|
| name3.c_str(),
|
| name3.c_str()
|
| );
|
|
|
| updateActive();
|
| commitCommand();
|
| }
|
| catch (...) {
|
| abortCommand();
|
| Base::PyGILStateLocker lock;
|
| PyObject* main = PyImport_AddModule("__main__");
|
| PyObject* dict = PyModule_GetDict(main);
|
| Py::Dict d(PyDict_Copy(dict), true);
|
|
|
| const char* cmd = "import OpenSCADUtils\nopenscadfilename = OpenSCADUtils.getopenscadexe()";
|
| PyObject* result = PyRun_String(cmd, Py_file_input, d.ptr(), d.ptr());
|
| Py_XDECREF(result);
|
|
|
| bool found = false;
|
| if (d.hasKey("openscadfilename")) {
|
| found = (bool)Py::Boolean(d.getItem("openscadfilename"));
|
| }
|
|
|
| if (found) {
|
| QMessageBox::critical(
|
| Gui::getMainWindow(),
|
| qApp->translate("Mesh_Union", "OpenSCAD"),
|
| qApp->translate("Mesh_Union", "Unknown error occurred while running OpenSCAD.")
|
| );
|
| }
|
| else {
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Mesh_Union", "OpenSCAD"),
|
| qApp->translate(
|
| "Mesh_Union",
|
| "OpenSCAD cannot be found on the system.\n"
|
| "Visit https://openscad.org/ to install it."
|
| )
|
| );
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshUnion::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 2;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshDifference)
|
|
|
| CmdMeshDifference::CmdMeshDifference()
|
| : Command("Mesh_Difference")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Difference");
|
| sToolTipText = QT_TR_NOOP("Creates a boolean difference of the selected meshes");
|
| sWhatsThis = "Mesh_Difference";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Difference";
|
| }
|
|
|
| void CmdMeshDifference::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| std::string name1 = obj.front()->getNameInDocument();
|
| std::string name2 = obj.back()->getNameInDocument();
|
| std::string name3 = getUniqueObjectName("Difference");
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh difference"));
|
|
|
| try {
|
| doCommand(
|
| Doc,
|
| "import OpenSCADUtils\n"
|
| "mesh = "
|
| "OpenSCADUtils.meshoptempfile('difference',(App.ActiveDocument.%s.Mesh,App."
|
| "ActiveDocument.%s.Mesh))\n"
|
| "App.ActiveDocument.addObject(\"Mesh::Feature\",\"%s\")\n"
|
| "App.ActiveDocument.%s.Mesh = mesh\n",
|
| name1.c_str(),
|
| name2.c_str(),
|
| name3.c_str(),
|
| name3.c_str()
|
| );
|
|
|
| updateActive();
|
| commitCommand();
|
| }
|
| catch (...) {
|
| abortCommand();
|
| Base::PyGILStateLocker lock;
|
| PyObject* main = PyImport_AddModule("__main__");
|
| PyObject* dict = PyModule_GetDict(main);
|
| Py::Dict d(PyDict_Copy(dict), true);
|
|
|
| const char* cmd = "import OpenSCADUtils\nopenscadfilename = OpenSCADUtils.getopenscadexe()";
|
| PyObject* result = PyRun_String(cmd, Py_file_input, d.ptr(), d.ptr());
|
| Py_XDECREF(result);
|
|
|
| bool found = false;
|
| if (d.hasKey("openscadfilename")) {
|
| found = (bool)Py::Boolean(d.getItem("openscadfilename"));
|
| }
|
|
|
| if (found) {
|
| QMessageBox::critical(
|
| Gui::getMainWindow(),
|
| qApp->translate("Mesh_Union", "OpenSCAD"),
|
| qApp->translate("Mesh_Union", "Unknown error occurred while running OpenSCAD.")
|
| );
|
| }
|
| else {
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Mesh_Union", "OpenSCAD"),
|
| qApp->translate(
|
| "Mesh_Union",
|
| "OpenSCAD cannot be found on the system.\n"
|
| "Visit https://openscad.org/ to install it."
|
| )
|
| );
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshDifference::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 2;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshIntersection)
|
|
|
| CmdMeshIntersection::CmdMeshIntersection()
|
| : Command("Mesh_Intersection")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Intersection");
|
| sToolTipText = QT_TR_NOOP("Creates a boolean intersection from the selected meshes");
|
| sWhatsThis = "Mesh_Intersection";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Intersection";
|
| }
|
|
|
| void CmdMeshIntersection::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| std::string name1 = obj.front()->getNameInDocument();
|
| std::string name2 = obj.back()->getNameInDocument();
|
| std::string name3 = getUniqueObjectName("Intersection");
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh intersection"));
|
|
|
| try {
|
| doCommand(
|
| Doc,
|
| "import OpenSCADUtils\n"
|
| "mesh = "
|
| "OpenSCADUtils.meshoptempfile('intersection',(App.ActiveDocument.%s.Mesh,App."
|
| "ActiveDocument.%s.Mesh))\n"
|
| "App.ActiveDocument.addObject(\"Mesh::Feature\",\"%s\")\n"
|
| "App.ActiveDocument.%s.Mesh = mesh\n",
|
| name1.c_str(),
|
| name2.c_str(),
|
| name3.c_str(),
|
| name3.c_str()
|
| );
|
|
|
| updateActive();
|
| commitCommand();
|
| }
|
| catch (...) {
|
| abortCommand();
|
| Base::PyGILStateLocker lock;
|
| PyObject* main = PyImport_AddModule("__main__");
|
| PyObject* dict = PyModule_GetDict(main);
|
| Py::Dict d(PyDict_Copy(dict), true);
|
|
|
| const char* cmd = "import OpenSCADUtils\nopenscadfilename = OpenSCADUtils.getopenscadexe()";
|
| PyObject* result = PyRun_String(cmd, Py_file_input, d.ptr(), d.ptr());
|
| Py_XDECREF(result);
|
|
|
| bool found = false;
|
| if (d.hasKey("openscadfilename")) {
|
| found = (bool)Py::Boolean(d.getItem("openscadfilename"));
|
| }
|
|
|
| if (found) {
|
| QMessageBox::critical(
|
| Gui::getMainWindow(),
|
| qApp->translate("Mesh_Union", "OpenSCAD"),
|
| qApp->translate("Mesh_Union", "Unknown error occurred while running OpenSCAD.")
|
| );
|
| }
|
| else {
|
| QMessageBox::warning(
|
| Gui::getMainWindow(),
|
| qApp->translate("Mesh_Union", "OpenSCAD"),
|
| qApp->translate(
|
| "Mesh_Union",
|
| "OpenSCAD cannot be found on the system.\n"
|
| "Visit https://openscad.org/ to install it."
|
| )
|
| );
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshIntersection::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 2;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshImport)
|
|
|
| CmdMeshImport::CmdMeshImport()
|
| : Command("Mesh_Import")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Import Mesh…");
|
| sToolTipText = QT_TR_NOOP("Imports a mesh from a file");
|
| sWhatsThis = "Mesh_Import";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Import";
|
| }
|
|
|
| void CmdMeshImport::activated(int)
|
| {
|
|
|
| QStringList filter;
|
| filter << QStringLiteral("%1 (*.stl *.ast *.bms *.obj *.off *.iv *.ply *.nas *.bdf)")
|
| .arg(QObject::tr("All Mesh Files"));
|
| filter << QStringLiteral("%1 (*.stl)").arg(QObject::tr("Binary STL"));
|
| filter << QStringLiteral("%1 (*.ast)").arg(QObject::tr("ASCII STL"));
|
| filter << QStringLiteral("%1 (*.bms)").arg(QObject::tr("Binary Mesh"));
|
| filter << QStringLiteral("%1 (*.obj)").arg(QObject::tr("Alias Mesh"));
|
| filter << QStringLiteral("%1 (*.off)").arg(QObject::tr("Object File Format"));
|
| filter << QStringLiteral("%1 (*.iv)").arg(QObject::tr("Inventor V2.1 ASCII"));
|
| filter << QStringLiteral("%1 (*.ply)").arg(QObject::tr("Stanford Polygon"));
|
| filter << QStringLiteral("%1 (*.nas *.bdf)").arg(QObject::tr("NASTRAN"));
|
| filter << QStringLiteral("%1 (*.*)").arg(QObject::tr("All Files"));
|
|
|
|
|
| QStringList fn = Gui::FileDialog::getOpenFileNames(
|
| Gui::getMainWindow(),
|
| QObject::tr("Import Mesh"),
|
| QString(),
|
| filter.join(QLatin1String(";;"))
|
| );
|
| for (const auto& it : fn) {
|
| std::string unicodepath = Base::Tools::escapedUnicodeFromUtf8(it.toUtf8().data());
|
| unicodepath = Base::Tools::escapeEncodeFilename(unicodepath);
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Import Mesh"));
|
| doCommand(Doc, "import Mesh");
|
| doCommand(Doc, "Mesh.insert(u\"%s\")", unicodepath.c_str());
|
| commitCommand();
|
| updateActive();
|
| }
|
| }
|
|
|
| bool CmdMeshImport::isActive()
|
| {
|
| return (getActiveGuiDocument() ? true : false);
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshExport)
|
|
|
| CmdMeshExport::CmdMeshExport()
|
| : Command("Mesh_Export")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Export Mesh…");
|
| sToolTipText = QT_TR_NOOP("Exports a mesh to a file");
|
| sWhatsThis = "Mesh_Export";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Export";
|
| }
|
|
|
| void CmdMeshExport::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> docObjs = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| if (docObjs.size() != 1) {
|
| return;
|
| }
|
|
|
| App::DocumentObject* docObj = docObjs.front();
|
|
|
|
|
| QString dir = QString::fromUtf8(docObj->Label.getValue());
|
| QList<QPair<QString, QByteArray> > ext;
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.stl)").arg(QObject::tr("Binary STL")), "STL");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.stl)").arg(QObject::tr("ASCII STL")), "AST");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.ast)").arg(QObject::tr("ASCII STL")), "AST");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.bms)").arg(QObject::tr("Binary Mesh")), "BMS");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.obj)").arg(QObject::tr("Alias Mesh")), "OBJ");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.smf)").arg(QObject::tr("Simple Model Format")), "SMF");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.off)").arg(QObject::tr("Object File Format")), "OFF");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.iv)").arg(QObject::tr("Inventor V2.1 ascii")), "IV");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.x3d)").arg(QObject::tr("X3D Extensible 3D")), "X3D");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.x3dz)").arg(QObject::tr("Compressed X3D")), "X3DZ");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.xhtml)").arg(QObject::tr("WebGL/X3D")), "X3DOM");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.ply)").arg(QObject::tr("Stanford Polygon")), "PLY");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.wrl *.vrml)").arg(QObject::tr("VRML V2.0")), "VRML");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.wrz)").arg(QObject::tr("Compressed VRML 2.0")), "WRZ");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.nas *.bdf)").arg(QObject::tr("Nastran")), "NAS");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.py)").arg(QObject::tr("Python module def")), "PY");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.asy)").arg(QObject::tr("Asymptote Format")), "ASY");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.3mf)").arg(QObject::tr("3D Manufacturing Format")), "3MF");
|
| ext << qMakePair<QString, QByteArray>(QStringLiteral("%1 (*.*)").arg(QObject::tr("All Files")), "");
|
|
|
| QStringList filter;
|
| for (const auto& it : ext) {
|
| filter << it.first;
|
| }
|
|
|
| QString format;
|
| QString fn = Gui::FileDialog::getSaveFileName(
|
| Gui::getMainWindow(),
|
| QObject::tr("Export Mesh"),
|
| dir,
|
| filter.join(QLatin1String(";;")),
|
| &format
|
| );
|
| if (!fn.isEmpty()) {
|
| QFileInfo fi(fn);
|
| QByteArray extension = fi.suffix().toLatin1();
|
| for (const auto& it : ext) {
|
| if (it.first == format) {
|
| extension = it.second;
|
| break;
|
| }
|
| }
|
|
|
| MeshGui::ViewProviderMesh* vp = dynamic_cast<MeshGui::ViewProviderMesh*>(
|
| Gui::Application::Instance->getViewProvider(docObj)
|
| );
|
| if (vp) {
|
| vp->exportMesh((const char*)fn.toUtf8(), (const char*)extension);
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshExport::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshFromGeometry)
|
|
|
| CmdMeshFromGeometry::CmdMeshFromGeometry()
|
| : Command("Mesh_FromGeometry")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Mesh From Geometry");
|
| sToolTipText = QT_TR_NOOP("Creates a mesh from the selected geometry");
|
| sWhatsThis = "Mesh_FromGeometry";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdMeshFromGeometry::activated(int)
|
| {
|
| bool ok {};
|
| double tol = QInputDialog::getDouble(
|
| Gui::getMainWindow(),
|
| QObject::tr("Meshing Tolerance"),
|
| QObject::tr("Enter tolerance for meshing geometry:"),
|
| 0.1,
|
| 0.01,
|
| 10.0,
|
| 2,
|
| &ok,
|
| Qt::MSWindowsFixedSizeDialogHint
|
| );
|
| if (!ok) {
|
| return;
|
| }
|
|
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| std::vector<App::DocumentObject*> geo = Gui::Selection().getObjectsOfType(
|
| App::GeoFeature::getClassTypeId()
|
| );
|
| for (auto it : geo) {
|
| if (!it->isDerivedFrom<Mesh::Feature>()) {
|
|
|
| std::map<std::string, App::Property*> Map;
|
| it->getPropertyMap(Map);
|
| Mesh::MeshObject mesh;
|
| for (const auto& jt : Map) {
|
| if (jt.first == "Shape" && jt.second->isDerivedFrom<App::PropertyComplexGeoData>()) {
|
| std::vector<Base::Vector3d> aPoints;
|
| std::vector<Data::ComplexGeoData::Facet> aTopo;
|
| const Data::ComplexGeoData* data
|
| = static_cast<App::PropertyComplexGeoData*>(jt.second)->getComplexData();
|
| if (data) {
|
| data->getFaces(aPoints, aTopo, (float)tol);
|
| mesh.setFacets(aTopo, aPoints);
|
| }
|
| }
|
| }
|
|
|
|
|
| Mesh::Feature* mf = doc->addObject<Mesh::Feature>("Mesh");
|
| mf->Mesh.setValue(mesh.getKernel());
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshFromGeometry::isActive()
|
| {
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| if (!doc) {
|
| return false;
|
| }
|
| return getSelection().countObjectsOfType<App::GeoFeature>() >= 1;
|
| }
|
|
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshFromPartShape)
|
|
|
| CmdMeshFromPartShape::CmdMeshFromPartShape()
|
| : Command("Mesh_FromPartShape")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Mesh From Shape");
|
| sToolTipText = QT_TR_NOOP("Tessellates the selected shape to a mesh");
|
| sWhatsThis = "Mesh_FromPartShape";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_FromPartShape.svg";
|
| }
|
|
|
| void CmdMeshFromPartShape::activated(int)
|
| {
|
| doCommand(Doc, "import MeshPartGui, FreeCADGui\nFreeCADGui.runCommand('MeshPart_Mesher')\n");
|
| }
|
|
|
| bool CmdMeshFromPartShape::isActive()
|
| {
|
| return (hasActiveDocument() && !Gui::Control().activeDialog());
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshVertexCurvature)
|
|
|
| CmdMeshVertexCurvature::CmdMeshVertexCurvature()
|
| : Command("Mesh_VertexCurvature")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Curvature Plot");
|
| sToolTipText = QT_TR_NOOP("Calculates the curvature of the vertices of a mesh");
|
| sWhatsThis = "Mesh_VertexCurvature";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_VertexCurvature";
|
| }
|
|
|
| void CmdMeshVertexCurvature::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto it : meshes) {
|
| std::string fName = it->getNameInDocument();
|
| fName += "_Curvature";
|
| fName = getUniqueObjectName(fName.c_str());
|
|
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh VertexCurvature"));
|
| App::DocumentObject* grp = App::DocumentObjectGroup::getGroupOfObject(it);
|
| if (grp) {
|
| doCommand(
|
| Doc,
|
| "App.activeDocument().getObject(\"%s\").newObject(\"Mesh::Curvature\",\"%s\")",
|
| grp->getNameInDocument(),
|
| fName.c_str()
|
| );
|
| }
|
| else {
|
| doCommand(Doc, "App.activeDocument().addObject(\"Mesh::Curvature\",\"%s\")", fName.c_str());
|
| }
|
| doCommand(
|
| Doc,
|
| "App.activeDocument().%s.Source = App.activeDocument().%s",
|
| fName.c_str(),
|
| it->getNameInDocument()
|
| );
|
| }
|
|
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdMeshVertexCurvature::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshVertexCurvatureInfo)
|
|
|
| CmdMeshVertexCurvatureInfo::CmdMeshVertexCurvatureInfo()
|
| : Command("Mesh_CurvatureInfo")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Curvature Info");
|
| sToolTipText = QT_TR_NOOP("Displays information about the curvature");
|
| sWhatsThis = "Mesh_CurvatureInfo";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_CurvatureInfo";
|
| }
|
|
|
| void CmdMeshVertexCurvatureInfo::activated(int)
|
| {
|
| Gui::Document* doc = Gui::Application::Instance->activeDocument();
|
| Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(doc->getActiveView());
|
| if (view) {
|
| Gui::View3DInventorViewer* viewer = view->getViewer();
|
| viewer->setEditing(true);
|
| viewer->setRedirectToSceneGraph(true);
|
| viewer->setSelectionEnabled(false);
|
| viewer->setEditingCursor(
|
| QCursor(Gui::BitmapFactory().pixmapFromSvg("Mesh_Pipette", QSize(32, 32)), 4, 29)
|
| );
|
| viewer->addEventCallback(
|
| SoEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshCurvature::curvatureInfoCallback
|
| );
|
| }
|
| }
|
|
|
| bool CmdMeshVertexCurvatureInfo::isActive()
|
| {
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| if (!doc || doc->countObjectsOfType<Mesh::Curvature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshPolySegm)
|
|
|
| CmdMeshPolySegm::CmdMeshPolySegm()
|
| : Command("Mesh_PolySegm")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Segment");
|
| sToolTipText = QT_TR_NOOP("Creates a mesh segment");
|
| sWhatsThis = "Mesh_PolySegm";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "PolygonPick";
|
| }
|
|
|
| void CmdMeshPolySegm::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> docObj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (std::vector<App::DocumentObject*>::iterator it = docObj.begin(); it != docObj.end(); ++it) {
|
| if (it == docObj.begin()) {
|
| Gui::Document* doc = getActiveGuiDocument();
|
| Gui::MDIView* view = doc->getActiveView();
|
| if (view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = ((Gui::View3DInventor*)view)->getViewer();
|
| viewer->setEditing(true);
|
| viewer->startSelection(Gui::View3DInventorViewer::Clip);
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::segmMeshCallback
|
| );
|
| }
|
| else {
|
| return;
|
| }
|
| }
|
|
|
| Gui::ViewProvider* pVP = getActiveGuiDocument()->getViewProvider(*it);
|
| if (pVP->isVisible()) {
|
| pVP->startEditing();
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshPolySegm::isActive()
|
| {
|
|
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshAddFacet)
|
|
|
| CmdMeshAddFacet::CmdMeshAddFacet()
|
| : Command("Mesh_AddFacet")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Add Triangle");
|
| sToolTipText = QT_TR_NOOP("Adds a triangle manually to a mesh");
|
| sWhatsThis = "Mesh_AddFacet";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_AddFacet";
|
| }
|
|
|
| void CmdMeshAddFacet::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> docObj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto it : docObj) {
|
| Gui::Document* doc = Gui::Application::Instance->getDocument(it->getDocument());
|
| Gui::MDIView* view = doc->getActiveView();
|
| if (view->isDerivedFrom<Gui::View3DInventor>()) {
|
| MeshGui::MeshFaceAddition* edit = new MeshGui::MeshFaceAddition(
|
| static_cast<Gui::View3DInventor*>(view)
|
| );
|
| edit->startEditing(
|
| static_cast<MeshGui::ViewProviderMesh*>(Gui::Application::Instance->getViewProvider(it))
|
| );
|
| break;
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshAddFacet::isActive()
|
| {
|
|
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() != 1) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshPolyCut)
|
|
|
| CmdMeshPolyCut::CmdMeshPolyCut()
|
| : Command("Mesh_PolyCut")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Cut");
|
| sToolTipText = QT_TR_NOOP("Cuts the mesh with a selected polygon");
|
| sWhatsThis = "Mesh_PolyCut";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_PolyCut";
|
| }
|
|
|
| void CmdMeshPolyCut::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> docObj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (std::vector<App::DocumentObject*>::iterator it = docObj.begin(); it != docObj.end(); ++it) {
|
| if (it == docObj.begin()) {
|
| Gui::Document* doc = getActiveGuiDocument();
|
| Gui::MDIView* view = doc->getActiveView();
|
| if (view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = ((Gui::View3DInventor*)view)->getViewer();
|
| viewer->setEditing(true);
|
|
|
| Gui::PolyClipSelection* clip = new Gui::PolyClipSelection();
|
| clip->setRole(Gui::SelectionRole::Split, true);
|
| clip->setColor(0.0f, 0.0f, 1.0f);
|
| clip->setLineWidth(1.0f);
|
| viewer->navigationStyle()->startSelection(clip);
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::clipMeshCallback
|
| );
|
| }
|
| else {
|
| return;
|
| }
|
| }
|
|
|
| Gui::ViewProvider* pVP = getActiveGuiDocument()->getViewProvider(*it);
|
| if (pVP->isVisible()) {
|
| pVP->startEditing();
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshPolyCut::isActive()
|
| {
|
|
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshPolyTrim)
|
|
|
| CmdMeshPolyTrim::CmdMeshPolyTrim()
|
| : Command("Mesh_PolyTrim")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Trim");
|
| sToolTipText = QT_TR_NOOP("Trims a mesh with a selected polygon");
|
| sWhatsThis = "Mesh_PolyTrim";
|
| sStatusTip = QT_TR_NOOP("Trims a mesh with a picked polygon");
|
| sPixmap = "Mesh_PolyTrim";
|
| }
|
|
|
| void CmdMeshPolyTrim::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> docObj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (std::vector<App::DocumentObject*>::iterator it = docObj.begin(); it != docObj.end(); ++it) {
|
| if (it == docObj.begin()) {
|
| Gui::Document* doc = getActiveGuiDocument();
|
| Gui::MDIView* view = doc->getActiveView();
|
| if (view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = ((Gui::View3DInventor*)view)->getViewer();
|
| viewer->setEditing(true);
|
|
|
| Gui::PolyClipSelection* clip = new Gui::PolyClipSelection();
|
| clip->setRole(Gui::SelectionRole::Split, true);
|
| clip->setColor(0.0f, 0.0f, 1.0f);
|
| clip->setLineWidth(1.0f);
|
| viewer->navigationStyle()->startSelection(clip);
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::trimMeshCallback
|
| );
|
| }
|
| else {
|
| return;
|
| }
|
| }
|
|
|
| Gui::ViewProvider* pVP = getActiveGuiDocument()->getViewProvider(*it);
|
| if (pVP->isVisible()) {
|
| pVP->startEditing();
|
| }
|
| }
|
| }
|
|
|
| bool CmdMeshPolyTrim::isActive()
|
| {
|
|
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshTrimByPlane)
|
|
|
| CmdMeshTrimByPlane::CmdMeshTrimByPlane()
|
| : Command("Mesh_TrimByPlane")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Trim With Plane");
|
| sToolTipText = QT_TR_NOOP("Trims a mesh by removing faces on one side of a selected plane");
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_TrimByPlane";
|
| }
|
|
|
| void CmdMeshTrimByPlane::activated(int)
|
| {
|
| const char* cmd = "import MeshPartGui\n"
|
| "import FreeCADGui\n"
|
| "FreeCADGui.runCommand('MeshPart_TrimByPlane')\n";
|
| runCommand(Doc, cmd);
|
| }
|
|
|
| bool CmdMeshTrimByPlane::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshSectionByPlane)
|
|
|
| CmdMeshSectionByPlane::CmdMeshSectionByPlane()
|
| : Command("Mesh_SectionByPlane")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Section From Plane");
|
| sToolTipText = QT_TR_NOOP("Sections the mesh with the selected plane");
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_SectionByPlane";
|
| }
|
|
|
| void CmdMeshSectionByPlane::activated(int)
|
| {
|
| const char* cmd = "import MeshPartGui\n"
|
| "import FreeCADGui\n"
|
| "FreeCADGui.runCommand('MeshPart_SectionByPlane')\n";
|
| runCommand(Doc, cmd);
|
| }
|
|
|
| bool CmdMeshSectionByPlane::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshCrossSections)
|
|
|
| CmdMeshCrossSections::CmdMeshCrossSections()
|
| : Command("Mesh_CrossSections")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Cross-Sections");
|
| sToolTipText = QT_TR_NOOP("Creates cross-sections of the mesh");
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_CrossSections";
|
| }
|
|
|
| void CmdMeshCrossSections::activated(int)
|
| {
|
| const char* cmd = "import MeshPartGui\n"
|
| "import FreeCADGui\n"
|
| "FreeCADGui.runCommand('MeshPart_CrossSections')\n";
|
| runCommand(Doc, cmd);
|
| }
|
|
|
| bool CmdMeshCrossSections::isActive()
|
| {
|
| return (Gui::Selection().countObjectsOfType<Mesh::Feature>() > 0 && !Gui::Control().activeDialog());
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshPolySplit)
|
|
|
| CmdMeshPolySplit::CmdMeshPolySplit()
|
| : Command("Mesh_PolySplit")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Split");
|
| sToolTipText = QT_TR_NOOP("Splits a mesh into 2 meshes");
|
| sWhatsThis = "Mesh_PolySplit";
|
| sStatusTip = sToolTipText;
|
| }
|
|
|
| void CmdMeshPolySplit::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> docObj = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (std::vector<App::DocumentObject*>::iterator it = docObj.begin(); it != docObj.end(); ++it) {
|
| if (it == docObj.begin()) {
|
| Gui::Document* doc = getActiveGuiDocument();
|
| Gui::MDIView* view = doc->getActiveView();
|
| if (view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = ((Gui::View3DInventor*)view)->getViewer();
|
| viewer->setEditing(true);
|
| viewer->startSelection(Gui::View3DInventorViewer::Clip);
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::partMeshCallback
|
| );
|
| }
|
| else {
|
| return;
|
| }
|
| }
|
|
|
| Gui::ViewProvider* pVP = getActiveGuiDocument()->getViewProvider(*it);
|
| pVP->startEditing();
|
| }
|
| }
|
|
|
| bool CmdMeshPolySplit::isActive()
|
| {
|
|
|
| if (getSelection().countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshEvaluation)
|
|
|
| CmdMeshEvaluation::CmdMeshEvaluation()
|
| : Command("Mesh_Evaluation")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
|
|
| sMenuText = QT_TR_NOOP("Evaluate and Repair");
|
| sToolTipText = QT_TR_NOOP("Opens a dialog to analyze and repair a mesh");
|
| sWhatsThis = "Mesh_Evaluation";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Evaluation";
|
| }
|
|
|
| void CmdMeshEvaluation::activated(int)
|
| {
|
| if (MeshGui::DockEvaluateMeshImp::hasInstance()) {
|
| MeshGui::DockEvaluateMeshImp::instance()->show();
|
| return;
|
| }
|
|
|
| MeshGui::DlgEvaluateMeshImp* dlg = MeshGui::DockEvaluateMeshImp::instance();
|
| dlg->setAttribute(Qt::WA_DeleteOnClose);
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto it : meshes) {
|
| dlg->setMesh((Mesh::Feature*)(it));
|
| break;
|
| }
|
|
|
| dlg->show();
|
| }
|
|
|
| bool CmdMeshEvaluation::isActive()
|
| {
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| if (!doc || doc->countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshEvaluateFacet)
|
|
|
| CmdMeshEvaluateFacet::CmdMeshEvaluateFacet()
|
| : Command("Mesh_EvaluateFacet")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Face Info");
|
| sToolTipText = QT_TR_NOOP("Displays information about the selected faces");
|
| sWhatsThis = "Mesh_EvaluateFacet";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_EvaluateFacet";
|
| }
|
|
|
| void CmdMeshEvaluateFacet::activated(int)
|
| {
|
| Gui::Document* doc = Gui::Application::Instance->activeDocument();
|
| Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(doc->getActiveView());
|
| if (view) {
|
| Gui::View3DInventorViewer* viewer = view->getViewer();
|
| viewer->setEditing(true);
|
| viewer->setEditingCursor(
|
| QCursor(Gui::BitmapFactory().pixmapFromSvg("Mesh_Pipette", QSize(32, 32)), 4, 29)
|
| );
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::faceInfoCallback
|
| );
|
| }
|
| }
|
|
|
| bool CmdMeshEvaluateFacet::isActive()
|
| {
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| if (!doc || doc->countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshRemoveComponents)
|
|
|
| CmdMeshRemoveComponents::CmdMeshRemoveComponents()
|
| : Command("Mesh_RemoveComponents")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Remove Components");
|
| sToolTipText = QT_TR_NOOP("Removes topologically independent components from the mesh");
|
| sWhatsThis = "Mesh_RemoveComponents";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_RemoveComponents";
|
| }
|
|
|
| void CmdMeshRemoveComponents::activated(int)
|
| {
|
| Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
|
| if (!dlg) {
|
| dlg = new MeshGui::TaskRemoveComponents();
|
| dlg->setButtonPosition(Gui::TaskView::TaskDialog::South);
|
| }
|
| Gui::Control().showDialog(dlg);
|
| }
|
|
|
| bool CmdMeshRemoveComponents::isActive()
|
| {
|
|
|
| App::Document* doc = getDocument();
|
| if (!(doc && doc->countObjectsOfType<Mesh::Feature>() > 0)) {
|
| return false;
|
| }
|
| Gui::Document* viewDoc = Gui::Application::Instance->getDocument(doc);
|
| Gui::View3DInventor* view = dynamic_cast<Gui::View3DInventor*>(viewDoc->getActiveView());
|
| if (view) {
|
| Gui::View3DInventorViewer* viewer = view->getViewer();
|
| if (viewer->isEditing()) {
|
| return false;
|
| }
|
| }
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshRemeshGmsh)
|
|
|
| CmdMeshRemeshGmsh::CmdMeshRemeshGmsh()
|
| : Command("Mesh_RemeshGmsh")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Refinement");
|
| sToolTipText = QT_TR_NOOP("Refines an existing mesh");
|
| sStatusTip = sToolTipText;
|
| sWhatsThis = "Mesh_RemeshGmsh";
|
| sPixmap = "Mesh_RemeshGmsh";
|
| }
|
|
|
| void CmdMeshRemeshGmsh::activated(int)
|
| {
|
| Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
|
| if (!dlg) {
|
| std::vector<Mesh::Feature*> mesh = getSelection().getObjectsOfType<Mesh::Feature>();
|
| if (mesh.size() != 1) {
|
| return;
|
| }
|
| dlg = new MeshGui::TaskRemeshGmsh(mesh.front());
|
| }
|
| Gui::Control().showDialog(dlg);
|
| }
|
|
|
| bool CmdMeshRemeshGmsh::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshRemoveCompByHand)
|
|
|
| CmdMeshRemoveCompByHand::CmdMeshRemoveCompByHand()
|
| : Command("Mesh_RemoveCompByHand")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Remove Components Manually");
|
| sToolTipText = QT_TR_NOOP("Marks a component to remove it from the mesh");
|
| sWhatsThis = "Mesh_RemoveCompByHand";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_RemoveCompByHand";
|
| }
|
|
|
| void CmdMeshRemoveCompByHand::activated(int)
|
| {
|
| Gui::Document* doc = Gui::Application::Instance->activeDocument();
|
| Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(doc->getActiveView());
|
| if (view) {
|
| Gui::View3DInventorViewer* viewer = view->getViewer();
|
| viewer->setEditing(true);
|
| viewer->setEditingCursor(QCursor(Qt::OpenHandCursor));
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::markPartCallback
|
| );
|
| viewer->setSelectionEnabled(false);
|
| }
|
| }
|
|
|
| bool CmdMeshRemoveCompByHand::isActive()
|
| {
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| if (!doc || doc->countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::View3DInventor* view = dynamic_cast<Gui::View3DInventor*>(
|
| Gui::getMainWindow()->activeWindow()
|
| );
|
| if (view) {
|
| Gui::View3DInventorViewer* viewer = view->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshEvaluateSolid)
|
|
|
| CmdMeshEvaluateSolid::CmdMeshEvaluateSolid()
|
| : Command("Mesh_EvaluateSolid")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Evaluate Solid");
|
| sToolTipText = QT_TR_NOOP("Checks whether the mesh is a solid");
|
| sWhatsThis = "Mesh_EvaluateSolid";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_EvaluateSolid";
|
| }
|
|
|
| void CmdMeshEvaluateSolid::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto it : meshes) {
|
| Mesh::Feature* mesh = (Mesh::Feature*)(it);
|
| QString msg;
|
| if (mesh->Mesh.getValue().getKernel().HasOpenEdges()) {
|
| msg = QObject::tr("The mesh '%1' is not a solid.")
|
| .arg(QString::fromLatin1(mesh->Label.getValue()));
|
| }
|
| else {
|
| msg = QObject::tr("The mesh '%1' is a solid.")
|
| .arg(QString::fromLatin1(mesh->Label.getValue()));
|
| }
|
| QMessageBox::information(Gui::getMainWindow(), QObject::tr("Solid Mesh"), msg);
|
| }
|
| }
|
|
|
| bool CmdMeshEvaluateSolid::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshSmoothing)
|
|
|
| CmdMeshSmoothing::CmdMeshSmoothing()
|
| : Command("Mesh_Smoothing")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Smooth");
|
| sToolTipText = QT_TR_NOOP("Smoothes the selected meshes");
|
| sWhatsThis = "Mesh_Smoothing";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Smoothing";
|
| }
|
|
|
| void CmdMeshSmoothing::activated(int)
|
| {
|
| Gui::Control().showDialog(new MeshGui::TaskSmoothing());
|
| }
|
|
|
| bool CmdMeshSmoothing::isActive()
|
| {
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshDecimating)
|
|
|
| CmdMeshDecimating::CmdMeshDecimating()
|
| : Command("Mesh_Decimating")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Decimate");
|
| sToolTipText = QT_TR_NOOP("Decimates a mesh");
|
| sWhatsThis = "Mesh_Decimating";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Decimating";
|
| }
|
|
|
| void CmdMeshDecimating::activated(int)
|
| {
|
| Gui::Control().showDialog(new MeshGui::TaskDecimating());
|
| }
|
|
|
| bool CmdMeshDecimating::isActive()
|
| {
|
| #if 1
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
| #endif
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshHarmonizeNormals)
|
|
|
| CmdMeshHarmonizeNormals::CmdMeshHarmonizeNormals()
|
| : Command("Mesh_HarmonizeNormals")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Harmonize Normals");
|
| sToolTipText = QT_TR_NOOP("Harmonizes the normals of the mesh");
|
| sWhatsThis = "Mesh_HarmonizeNormals";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_HarmonizeNormals";
|
| }
|
|
|
| void CmdMeshHarmonizeNormals::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Harmonize mesh normals"));
|
| for (auto it : meshes) {
|
| doCommand(
|
| Doc,
|
| "App.activeDocument().getObject(\"%s\").Mesh.harmonizeNormals()",
|
| it->getNameInDocument()
|
| );
|
| }
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdMeshHarmonizeNormals::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshFlipNormals)
|
|
|
| CmdMeshFlipNormals::CmdMeshFlipNormals()
|
| : Command("Mesh_FlipNormals")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Flip Normals");
|
| sToolTipText = QT_TR_NOOP("Flips the normals of the selected mesh");
|
| sWhatsThis = "Mesh_FlipNormals";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_FlipNormals";
|
| }
|
|
|
| void CmdMeshFlipNormals::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Flip mesh normals"));
|
| for (auto it : meshes) {
|
| doCommand(
|
| Doc,
|
| "App.activeDocument().getObject(\"%s\").Mesh.flipNormals()",
|
| it->getNameInDocument()
|
| );
|
| }
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdMeshFlipNormals::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshBoundingBox)
|
|
|
| CmdMeshBoundingBox::CmdMeshBoundingBox()
|
| : Command("Mesh_BoundingBox")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Bounding Box Info");
|
| sToolTipText = QT_TR_NOOP("Shows the bounding box coordinates of the selected mesh");
|
| sWhatsThis = "Mesh_BoundingBox";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_BoundingBox";
|
| }
|
|
|
| void CmdMeshBoundingBox::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto it : meshes) {
|
| const MeshCore::MeshKernel& rMesh = ((Mesh::Feature*)it)->Mesh.getValue().getKernel();
|
| const Base::BoundBox3f& box = rMesh.GetBoundBox();
|
|
|
| Base::Console().message(
|
| "Boundings: Min=<%f,%f,%f>, Max=<%f,%f,%f>\n",
|
| box.MinX,
|
| box.MinY,
|
| box.MinZ,
|
| box.MaxX,
|
| box.MaxY,
|
| box.MaxZ
|
| );
|
|
|
| QString bound = qApp->translate("Mesh_BoundingBox", "Boundings of %1:")
|
| .arg(QString::fromUtf8(it->Label.getValue()));
|
| bound += QStringLiteral("\n\nMin=<%1,%2,%3>\n\nMax=<%4,%5,%6>")
|
| .arg(box.MinX)
|
| .arg(box.MinY)
|
| .arg(box.MinZ)
|
| .arg(box.MaxX)
|
| .arg(box.MaxY)
|
| .arg(box.MaxZ);
|
| QMessageBox::information(Gui::getMainWindow(), QObject::tr("Boundings"), bound);
|
| break;
|
| }
|
| }
|
|
|
| bool CmdMeshBoundingBox::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshBuildRegularSolid)
|
|
|
| CmdMeshBuildRegularSolid::CmdMeshBuildRegularSolid()
|
| : Command("Mesh_BuildRegularSolid")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Regular Solid");
|
| sToolTipText = QT_TR_NOOP("Builds a regular solid");
|
| sWhatsThis = "Mesh_BuildRegularSolid";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_BuildRegularSolid";
|
| }
|
|
|
| void CmdMeshBuildRegularSolid::activated(int)
|
| {
|
| static QPointer<QDialog> dlg = nullptr;
|
| if (!dlg) {
|
| dlg = new MeshGui::DlgRegularSolidImp(Gui::getMainWindow());
|
| }
|
| dlg->setAttribute(Qt::WA_DeleteOnClose);
|
| dlg->show();
|
| }
|
|
|
| bool CmdMeshBuildRegularSolid::isActive()
|
| {
|
|
|
| return hasActiveDocument();
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshFillupHoles)
|
|
|
| CmdMeshFillupHoles::CmdMeshFillupHoles()
|
| : Command("Mesh_FillupHoles")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Fill Holes");
|
| sToolTipText = QT_TR_NOOP("Fills holes in the mesh");
|
| sWhatsThis = "Mesh_FillupHoles";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_FillupHoles";
|
| }
|
|
|
| void CmdMeshFillupHoles::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> meshes = getSelection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| bool ok {};
|
| int FillupHolesOfLength = QInputDialog::getInt(
|
| Gui::getMainWindow(),
|
| QObject::tr("Fill Holes"),
|
| QObject::tr("Fill holes with maximum number of edges"),
|
| 3,
|
| 3,
|
| 10000,
|
| 1,
|
| &ok,
|
| Qt::MSWindowsFixedSizeDialogHint
|
| );
|
| if (!ok) {
|
| return;
|
| }
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Fill up holes"));
|
| for (auto mesh : meshes) {
|
| doCommand(
|
| Doc,
|
| "App.activeDocument().getObject(\"%s\").Mesh.fillupHoles(%d)",
|
| mesh->getNameInDocument(),
|
| FillupHolesOfLength
|
| );
|
| }
|
| commitCommand();
|
| updateActive();
|
| }
|
|
|
| bool CmdMeshFillupHoles::isActive()
|
| {
|
|
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshFillInteractiveHole)
|
|
|
| CmdMeshFillInteractiveHole::CmdMeshFillInteractiveHole()
|
| : Command("Mesh_FillInteractiveHole")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Close Hole");
|
| sToolTipText = QT_TR_NOOP("Closes a hole interactively in the mesh");
|
| sWhatsThis = "Mesh_FillInteractiveHole";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_FillInteractiveHole";
|
| }
|
|
|
| void CmdMeshFillInteractiveHole::activated(int)
|
| {
|
| Gui::Document* doc = Gui::Application::Instance->activeDocument();
|
| Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(doc->getActiveView());
|
| if (view) {
|
| Gui::View3DInventorViewer* viewer = view->getViewer();
|
| viewer->setEditing(true);
|
| viewer->setEditingCursor(
|
| QCursor(Gui::BitmapFactory().pixmapFromSvg("Mesh_CursorFillInteractive", QSize(32, 32)), 6, 6)
|
| );
|
| viewer->addEventCallback(
|
| SoMouseButtonEvent::getClassTypeId(),
|
| MeshGui::ViewProviderMeshFaceSet::fillHoleCallback
|
| );
|
| viewer->setSelectionEnabled(false);
|
| }
|
| }
|
|
|
| bool CmdMeshFillInteractiveHole::isActive()
|
| {
|
| App::Document* doc = App::GetApplication().getActiveDocument();
|
| if (!doc || doc->countObjectsOfType<Mesh::Feature>() == 0) {
|
| return false;
|
| }
|
|
|
| Gui::MDIView* view = Gui::getMainWindow()->activeWindow();
|
| if (view && view->isDerivedFrom<Gui::View3DInventor>()) {
|
| Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
|
| return !viewer->isEditing();
|
| }
|
|
|
| return false;
|
| }
|
|
|
| DEF_STD_CMD_A(CmdMeshSegmentation)
|
|
|
| CmdMeshSegmentation::CmdMeshSegmentation()
|
| : Command("Mesh_Segmentation")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Segmentation");
|
| sToolTipText = QT_TR_NOOP("Creates new mesh segments from the mesh");
|
| sWhatsThis = "Mesh_Segmentation";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Segmentation";
|
| }
|
|
|
| void CmdMeshSegmentation::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> objs = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| Mesh::Feature* mesh = static_cast<Mesh::Feature*>(objs.front());
|
| Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
|
| if (!dlg) {
|
| dlg = new MeshGui::TaskSegmentation(mesh);
|
| }
|
| Gui::Control().showDialog(dlg);
|
| }
|
|
|
| bool CmdMeshSegmentation::isActive()
|
| {
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
| return Gui::Selection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshSegmentationBestFit)
|
|
|
| CmdMeshSegmentationBestFit::CmdMeshSegmentationBestFit()
|
| : Command("Mesh_SegmentationBestFit")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Segmentation From Best-Fit Surfaces");
|
| sToolTipText = QT_TR_NOOP("Creates new mesh segments from the best-fit surfaces");
|
| sWhatsThis = "Mesh_SegmentationBestFit";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_SegmentationBestFit";
|
| }
|
|
|
| void CmdMeshSegmentationBestFit::activated(int)
|
| {
|
| std::vector<App::DocumentObject*> objs = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| Mesh::Feature* mesh = static_cast<Mesh::Feature*>(objs.front());
|
| Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
|
| if (!dlg) {
|
| dlg = new MeshGui::TaskSegmentationBestFit(mesh);
|
| }
|
| Gui::Control().showDialog(dlg);
|
| }
|
|
|
| bool CmdMeshSegmentationBestFit::isActive()
|
| {
|
| if (Gui::Control().activeDialog()) {
|
| return false;
|
| }
|
| return Gui::Selection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshMerge)
|
|
|
| CmdMeshMerge::CmdMeshMerge()
|
| : Command("Mesh_Merge")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Merge");
|
| sToolTipText = QT_TR_NOOP("Merges selected meshes into one");
|
| sWhatsThis = "Mesh_Merge";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Merge";
|
| }
|
|
|
| void CmdMeshMerge::activated(int)
|
| {
|
| App::Document* pcDoc = App::GetApplication().getActiveDocument();
|
| if (!pcDoc) {
|
| return;
|
| }
|
|
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh merge"));
|
| Mesh::Feature* pcFeature = pcDoc->addObject<Mesh::Feature>("Mesh");
|
| Mesh::MeshObject* newMesh = pcFeature->Mesh.startEditing();
|
| std::vector<App::DocumentObject*> objs = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto obj : objs) {
|
| const MeshObject& mesh = static_cast<Mesh::Feature*>(obj)->Mesh.getValue();
|
| MeshCore::MeshKernel kernel = mesh.getKernel();
|
| kernel.Transform(mesh.getTransform());
|
| newMesh->addMesh(kernel);
|
| }
|
|
|
| pcFeature->Mesh.finishEditing();
|
| updateActive();
|
| commitCommand();
|
| }
|
|
|
| bool CmdMeshMerge::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() >= 2;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshSplitComponents)
|
|
|
| CmdMeshSplitComponents::CmdMeshSplitComponents()
|
| : Command("Mesh_SplitComponents")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Split by Components");
|
| sToolTipText = QT_TR_NOOP("Splits the selected mesh into its components");
|
| sWhatsThis = "Mesh_SplitComponents";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_SplitComponents";
|
| }
|
|
|
| void CmdMeshSplitComponents::activated(int)
|
| {
|
| App::Document* pcDoc = App::GetApplication().getActiveDocument();
|
| if (!pcDoc) {
|
| return;
|
| }
|
|
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh split"));
|
| std::vector<App::DocumentObject*> objs = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| for (auto obj : objs) {
|
| const MeshObject& mesh = static_cast<Mesh::Feature*>(obj)->Mesh.getValue();
|
| std::vector<std::vector<Mesh::FacetIndex>> comps = mesh.getComponents();
|
|
|
| for (const auto& comp : comps) {
|
| std::unique_ptr<MeshObject> kernel(mesh.meshFromSegment(comp));
|
| kernel->setTransform(mesh.getTransform());
|
|
|
| Mesh::Feature* feature = pcDoc->addObject<Mesh::Feature>("Component");
|
| feature->Mesh.setValuePtr(kernel.release());
|
| }
|
| }
|
|
|
| updateActive();
|
| commitCommand();
|
| }
|
|
|
| bool CmdMeshSplitComponents::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() == 1;
|
| }
|
|
|
|
|
|
|
| DEF_STD_CMD_A(CmdMeshScale)
|
|
|
| CmdMeshScale::CmdMeshScale()
|
| : Command("Mesh_Scale")
|
| {
|
| sAppModule = "Mesh";
|
| sGroup = QT_TR_NOOP("Mesh");
|
| sMenuText = QT_TR_NOOP("Scale");
|
| sToolTipText = QT_TR_NOOP("Scales the selected mesh objects");
|
| sWhatsThis = "Mesh_Scale";
|
| sStatusTip = sToolTipText;
|
| sPixmap = "Mesh_Scale";
|
| }
|
|
|
| void CmdMeshScale::activated(int)
|
| {
|
| App::Document* pcDoc = App::GetApplication().getActiveDocument();
|
| if (!pcDoc) {
|
| return;
|
| }
|
|
|
| bool ok {};
|
| double factor = QInputDialog::getDouble(
|
| Gui::getMainWindow(),
|
| QObject::tr("Scaling"),
|
| QObject::tr("Enter scaling factor:"),
|
| 1,
|
| 0,
|
| std::numeric_limits<double>::max(),
|
| 5,
|
| &ok,
|
| Qt::MSWindowsFixedSizeDialogHint
|
| );
|
| if (!ok || factor == 0) {
|
| return;
|
| }
|
|
|
| openCommand(QT_TRANSLATE_NOOP("Command", "Mesh scale"));
|
| std::vector<App::DocumentObject*> objs = Gui::Selection().getObjectsOfType(
|
| Mesh::Feature::getClassTypeId()
|
| );
|
| Base::Matrix4D mat;
|
| mat.scale(factor, factor, factor);
|
| for (auto obj : objs) {
|
| MeshObject* mesh = static_cast<Mesh::Feature*>(obj)->Mesh.startEditing();
|
| MeshCore::MeshKernel& kernel = mesh->getKernel();
|
| kernel.Transform(mat);
|
| static_cast<Mesh::Feature*>(obj)->Mesh.finishEditing();
|
| }
|
|
|
| updateActive();
|
| commitCommand();
|
| }
|
|
|
| bool CmdMeshScale::isActive()
|
| {
|
| return getSelection().countObjectsOfType<Mesh::Feature>() > 0;
|
| }
|
|
|
|
|
| void CreateMeshCommands()
|
| {
|
| Gui::CommandManager& rcCmdMgr = Gui::Application::Instance->commandManager();
|
| rcCmdMgr.addCommand(new CmdMeshImport());
|
| rcCmdMgr.addCommand(new CmdMeshExport());
|
| rcCmdMgr.addCommand(new CmdMeshVertexCurvature());
|
| rcCmdMgr.addCommand(new CmdMeshVertexCurvatureInfo());
|
| rcCmdMgr.addCommand(new CmdMeshUnion());
|
| rcCmdMgr.addCommand(new CmdMeshDifference());
|
| rcCmdMgr.addCommand(new CmdMeshIntersection());
|
| rcCmdMgr.addCommand(new CmdMeshPolySegm());
|
| rcCmdMgr.addCommand(new CmdMeshAddFacet());
|
| rcCmdMgr.addCommand(new CmdMeshPolyCut());
|
| rcCmdMgr.addCommand(new CmdMeshPolySplit());
|
| rcCmdMgr.addCommand(new CmdMeshPolyTrim());
|
| rcCmdMgr.addCommand(new CmdMeshTrimByPlane());
|
| rcCmdMgr.addCommand(new CmdMeshSectionByPlane());
|
| rcCmdMgr.addCommand(new CmdMeshCrossSections());
|
| rcCmdMgr.addCommand(new CmdMeshEvaluation());
|
| rcCmdMgr.addCommand(new CmdMeshEvaluateFacet());
|
| rcCmdMgr.addCommand(new CmdMeshEvaluateSolid());
|
| rcCmdMgr.addCommand(new CmdMeshHarmonizeNormals());
|
| rcCmdMgr.addCommand(new CmdMeshFlipNormals());
|
| rcCmdMgr.addCommand(new CmdMeshSmoothing());
|
| rcCmdMgr.addCommand(new CmdMeshDecimating());
|
| rcCmdMgr.addCommand(new CmdMeshBoundingBox());
|
| rcCmdMgr.addCommand(new CmdMeshBuildRegularSolid());
|
| rcCmdMgr.addCommand(new CmdMeshFillupHoles());
|
| rcCmdMgr.addCommand(new CmdMeshRemoveComponents());
|
| rcCmdMgr.addCommand(new CmdMeshRemeshGmsh());
|
| rcCmdMgr.addCommand(new CmdMeshFillInteractiveHole());
|
| rcCmdMgr.addCommand(new CmdMeshRemoveCompByHand());
|
| rcCmdMgr.addCommand(new CmdMeshFromGeometry());
|
| rcCmdMgr.addCommand(new CmdMeshFromPartShape());
|
| rcCmdMgr.addCommand(new CmdMeshSegmentation());
|
| rcCmdMgr.addCommand(new CmdMeshSegmentationBestFit);
|
| rcCmdMgr.addCommand(new CmdMeshMerge());
|
| rcCmdMgr.addCommand(new CmdMeshSplitComponents());
|
| rcCmdMgr.addCommand(new CmdMeshScale());
|
| }
|
|
|
