kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

mesh segmentation algorithm for surfaces

Browse Source
This commit is contained in:
wmayer
2018-12-10 00:23:31 +01:00
parent 1471bb49d2
commit d7077f06a7
11 changed files with 871 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

464
src/Mod/Mesh/Gui/SegmentationBestFit.cpp Normal file
View File

@@ -0,0 +1,464 @@
/***************************************************************************
* Copyright (c) 2018 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include "PreCompiled.h"
#ifndef _PreComp_
# include <sstream>
# include <QDialog>
# include <QDoubleSpinBox>
# include <QVBoxLayout>
# include <QMessageBox>
# include <QPointer>
#endif
#include "SegmentationBestFit.h"
#include "ui_SegmentationBestFit.h"
#include <App/Application.h>
#include <App/Document.h>
#include <App/DocumentObjectGroup.h>
#include <Gui/SelectionObject.h>
#include <Mod/Mesh/App/Core/Approximation.h>
#include <Mod/Mesh/App/Core/Segmentation.h>
#include <Mod/Mesh/App/Mesh.h>
#include <Mod/Mesh/App/MeshFeature.h>
using namespace MeshGui;
namespace MeshGui {
class PlaneFitParameter : public FitParameter
{
public:
PlaneFitParameter() {}
virtual ~PlaneFitParameter() {}
virtual std::vector<float> getParameter(FitParameter::Points pts) const {
MeshCore::PlaneFit fit;
fit.AddPoints(pts);
fit.Fit();
Base::Vector3f base = fit.GetBase();
Base::Vector3f axis = fit.GetNormal();
std::vector<float> values;
values.push_back(base.x);
values.push_back(base.y);
values.push_back(base.z);
values.push_back(axis.x);
values.push_back(axis.y);
values.push_back(axis.z);
return values;
}
};
class CylinderFitParameter : public FitParameter
{
public:
CylinderFitParameter() {}
virtual ~CylinderFitParameter() {}
virtual std::vector<float> getParameter(FitParameter::Points pts) const {
std::vector<float> values;
return values;
}
};
class SphereFitParameter : public FitParameter
{
public:
SphereFitParameter() {}
virtual ~SphereFitParameter() {}
virtual std::vector<float> getParameter(FitParameter::Points pts) const {
std::vector<float> values;
return values;
}
};
}
ParametersDialog::ParametersDialog(std::vector<float>& val, FitParameter* fitPar,
ParameterList par, Mesh::Feature* mesh,
QWidget* parent)
: QDialog(parent)
, values(val)
, fitParameter(fitPar)
, parameter(par)
, myMesh(mesh)
{
this->setWindowTitle(tr("Surface fit"));
QGridLayout *gridLayout;
gridLayout = new QGridLayout(this);
QGroupBox *groupBox;
groupBox = new QGroupBox(this);
groupBox->setTitle(tr("Parameters"));
gridLayout->addWidget(groupBox, 0, 0, 1, 1);
QGroupBox *selectBox;
selectBox = new QGroupBox(this);
selectBox->setTitle(tr("Selection"));
gridLayout->addWidget(selectBox, 1, 0, 1, 1);
QVBoxLayout *selectLayout;
selectLayout = new QVBoxLayout(selectBox);
QPushButton *regionButton;
regionButton = new QPushButton(this);
regionButton->setText(tr("Region"));
regionButton->setObjectName(QString::fromLatin1("region"));
selectLayout->addWidget(regionButton);
QPushButton *singleButton;
singleButton = new QPushButton(this);
singleButton->setText(tr("Triangle"));
singleButton->setObjectName(QString::fromLatin1("single"));
selectLayout->addWidget(singleButton);
QPushButton *clearButton;
clearButton = new QPushButton(this);
clearButton->setText(tr("Clear"));
clearButton->setObjectName(QString::fromLatin1("clear"));
selectLayout->addWidget(clearButton);
QPushButton *computeButton;
computeButton = new QPushButton(this);
computeButton->setText(tr("Compute"));
computeButton->setObjectName(QString::fromLatin1("compute"));
gridLayout->addWidget(computeButton, 2, 0, 1, 1);
QDialogButtonBox *buttonBox;
buttonBox = new QDialogButtonBox(this);
buttonBox->setOrientation(Qt::Horizontal);
buttonBox->setStandardButtons(QDialogButtonBox::Cancel|QDialogButtonBox::Ok);
gridLayout->addWidget(buttonBox, 3, 0, 1, 1);
int index = 0;
QGridLayout *layout;
layout = new QGridLayout(groupBox);
for (auto it : parameter) {
QLabel* label = new QLabel(groupBox);
label->setText(it.first);
layout->addWidget(label, index, 0, 1, 1);
QDoubleSpinBox* doubleSpinBox = new QDoubleSpinBox(groupBox);
doubleSpinBox->setObjectName(it.first);
doubleSpinBox->setRange(-INT_MAX, INT_MAX);
doubleSpinBox->setValue(it.second);
layout->addWidget(doubleSpinBox, index, 1, 1, 1);
spinBoxes.push_back(doubleSpinBox);
++index;
}
QObject::connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
QObject::connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
QMetaObject::connectSlotsByName(this);
Gui::SelectionObject obj(mesh);
std::vector<Gui::SelectionObject> sel;
sel.push_back(obj);
meshSel.setObjects(sel);
meshSel.setCheckOnlyPointToUserTriangles(true);
meshSel.setCheckOnlyVisibleTriangles(true);
}
ParametersDialog::~ParametersDialog()
{
meshSel.clearSelection();
delete fitParameter;
}
void ParametersDialog::on_region_clicked()
{
meshSel.startSelection();
}
void ParametersDialog::on_single_clicked()
{
meshSel.selectTriangle();
}
void ParametersDialog::on_clear_clicked()
{
meshSel.clearSelection();
}
void ParametersDialog::on_compute_clicked()
{
const Mesh::MeshObject& kernel = myMesh->Mesh.getValue();
if (kernel.hasSelectedFacets()) {
std::vector<unsigned long> facets, points;
kernel.getFacetsFromSelection(facets);
points = kernel.getPointsFromFacets(facets);
MeshCore::MeshPointArray coords = kernel.getKernel().GetPoints(points);
// Copy points into right format
FitParameter::Points fitpts;
fitpts.insert(fitpts.end(), coords.begin(), coords.end());
coords.clear();
values = fitParameter->getParameter(fitpts);
if (values.size() == spinBoxes.size()) {
for (std::size_t i=0; i<values.size(); i++) {
spinBoxes[i]->setValue(values[i]);
}
}
meshSel.stopSelection();
meshSel.clearSelection();
}
else {
QMessageBox::warning(this, tr("No selection"), tr("Before fitting the surface select an area."));
}
}
void ParametersDialog::accept()
{
std::vector<float> v;
for (auto it : spinBoxes)
v.push_back(it->value());
values = v;
QDialog::accept();
}
void ParametersDialog::reject()
{
values.clear();
QDialog::reject();
}
// ----------------------------------------------------------------------------
/* TRANSLATOR MeshGui::SegmentationBestFit */
SegmentationBestFit::SegmentationBestFit(Mesh::Feature* mesh, QWidget* parent, Qt::WindowFlags fl)
: QWidget(parent, fl), myMesh(mesh)
{
ui = new Ui_SegmentationBestFit;
ui->setupUi(this);
ui->numPln->setRange(1, INT_MAX);
ui->numPln->setValue(100);
ui->numCyl->setRange(1, INT_MAX);
ui->numCyl->setValue(100);
ui->numSph->setRange(1, INT_MAX);
ui->numSph->setValue(100);
Gui::SelectionObject obj(myMesh);
std::vector<Gui::SelectionObject> sel;
sel.push_back(obj);
meshSel.setObjects(sel);
}
SegmentationBestFit::~SegmentationBestFit()
{
// no need to delete child widgets, Qt does it all for us
delete ui;
}
void SegmentationBestFit::on_planeParameters_clicked()
{
ParameterList list;
std::vector<float> p = planeParameter;
p.resize(6);
QString base = tr("Base");
QString axis = tr("Normal");
QString x = QString::fromLatin1(" x");
QString y = QString::fromLatin1(" y");
QString z = QString::fromLatin1(" z");
list.push_back(std::make_pair(base + x, p[0]));
list.push_back(std::make_pair(base + y, p[1]));
list.push_back(std::make_pair(base + z, p[2]));
list.push_back(std::make_pair(axis + x, p[3]));
list.push_back(std::make_pair(axis + y, p[4]));
list.push_back(std::make_pair(axis + z, p[5]));
static QPointer<QDialog> dialog = 0;
if (!dialog)
dialog = new ParametersDialog(planeParameter,
new PlaneFitParameter,
list, myMesh, this);
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->show();
}
void SegmentationBestFit::on_cylinderParameters_clicked()
{
ParameterList list;
std::vector<float> p = cylinderParameter;
p.resize(7);
QString base = tr("Base");
QString axis = tr("Axis");
QString radius = tr("Radius");
QString x = QString::fromLatin1(" x");
QString y = QString::fromLatin1(" y");
QString z = QString::fromLatin1(" z");
list.push_back(std::make_pair(base + x, p[0]));
list.push_back(std::make_pair(base + y, p[1]));
list.push_back(std::make_pair(base + z, p[2]));
list.push_back(std::make_pair(axis + x, p[3]));
list.push_back(std::make_pair(axis + y, p[4]));
list.push_back(std::make_pair(axis + z, p[5]));
list.push_back(std::make_pair(radius, p[6]));
static QPointer<QDialog> dialog = 0;
if (!dialog)
dialog = new ParametersDialog(cylinderParameter,
new CylinderFitParameter,
list, myMesh, this);
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->show();
}
void SegmentationBestFit::on_sphereParameters_clicked()
{
ParameterList list;
std::vector<float> p = sphereParameter;
p.resize(4);
QString base = tr("Center");
QString radius = tr("Radius");
QString x = QString::fromLatin1(" x");
QString y = QString::fromLatin1(" y");
QString z = QString::fromLatin1(" z");
list.push_back(std::make_pair(base + x, p[0]));
list.push_back(std::make_pair(base + y, p[1]));
list.push_back(std::make_pair(base + z, p[2]));
list.push_back(std::make_pair(radius, p[3]));
static QPointer<QDialog> dialog = 0;
if (!dialog)
dialog = new ParametersDialog(sphereParameter,
new SphereFitParameter,
list, myMesh, this);
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->show();
}
void SegmentationBestFit::accept()
{
const Mesh::MeshObject* mesh = myMesh->Mesh.getValuePtr();
const MeshCore::MeshKernel& kernel = mesh->getKernel();
MeshCore::MeshSegmentAlgorithm finder(kernel);
std::vector<MeshCore::MeshSurfaceSegment*> segm;
if (ui->groupBoxCyl->isChecked()) {
MeshCore::AbstractSurfaceFit* fitter;
if (cylinderParameter.size() == 7) {
std::vector<float>& p = cylinderParameter;
fitter = new MeshCore::CylinderSurfaceFit(
Base::Vector3f(p[0],p[1],p[2]),
Base::Vector3f(p[3],p[4],p[5]),
p[6]);
}
else {
fitter = new MeshCore::CylinderSurfaceFit;
}
segm.push_back(new MeshCore::MeshDistanceGenericSurfaceFitSegment
(fitter, kernel, ui->numCyl->value(), ui->tolCyl->value()));
}
if (ui->groupBoxSph->isChecked()) {
MeshCore::AbstractSurfaceFit* fitter;
if (sphereParameter.size() == 4) {
std::vector<float>& p = sphereParameter;
fitter = new MeshCore::SphereSurfaceFit(
Base::Vector3f(p[0],p[1],p[2]),
p[3]);
}
else {
fitter = new MeshCore::SphereSurfaceFit;
}
segm.push_back(new MeshCore::MeshDistanceGenericSurfaceFitSegment
(fitter, kernel, ui->numSph->value(), ui->tolSph->value()));
}
if (ui->groupBoxPln->isChecked()) {
MeshCore::AbstractSurfaceFit* fitter;
if (planeParameter.size() == 6) {
std::vector<float>& p = planeParameter;
fitter = new MeshCore::PlaneSurfaceFit(
Base::Vector3f(p[0],p[1],p[2]),
Base::Vector3f(p[3],p[4],p[5]));
}
else {
fitter = new MeshCore::PlaneSurfaceFit;
}
segm.push_back(new MeshCore::MeshDistanceGenericSurfaceFitSegment
(fitter, kernel, ui->numPln->value(), ui->tolPln->value()));
}
finder.FindSegments(segm);
App::Document* document = App::GetApplication().getActiveDocument();
document->openTransaction("Segmentation");
std::string internalname = "Segments_";
internalname += myMesh->getNameInDocument();
App::DocumentObjectGroup* group = static_cast<App::DocumentObjectGroup*>(document->addObject
("App::DocumentObjectGroup", internalname.c_str()));
std::string labelname = "Segments ";
labelname += myMesh->Label.getValue();
group->Label.setValue(labelname);
for (std::vector<MeshCore::MeshSurfaceSegment*>::iterator it = segm.begin(); it != segm.end(); ++it) {
const std::vector<MeshCore::MeshSegment>& data = (*it)->GetSegments();
for (std::vector<MeshCore::MeshSegment>::const_iterator jt = data.begin(); jt != data.end(); ++jt) {
Mesh::MeshObject* segment = mesh->meshFromSegment(*jt);
Mesh::Feature* feaSegm = static_cast<Mesh::Feature*>(group->addObject("Mesh::Feature", "Segment"));
Mesh::MeshObject* feaMesh = feaSegm->Mesh.startEditing();
feaMesh->swap(*segment);
feaSegm->Mesh.finishEditing();
delete segment;
std::stringstream label;
label << feaSegm->Label.getValue() << " (" << (*it)->GetType() << ")";
feaSegm->Label.setValue(label.str());
}
delete (*it);
}
document->commitTransaction();
}
void SegmentationBestFit::changeEvent(QEvent *e)
{
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(this);
}
QWidget::changeEvent(e);
}
// ---------------------------------------
/* TRANSLATOR MeshGui::TaskSegmentationBestFit */
TaskSegmentationBestFit::TaskSegmentationBestFit(Mesh::Feature* mesh)
{
widget = new SegmentationBestFit(mesh);
taskbox = new Gui::TaskView::TaskBox(
QPixmap(), widget->windowTitle(), false, 0);
taskbox->groupLayout()->addWidget(widget);
Content.push_back(taskbox);
}
TaskSegmentationBestFit::~TaskSegmentationBestFit()
{
// automatically deleted in the sub-class
}
bool TaskSegmentationBestFit::accept()
{
widget->accept();
return true;
}
#include "moc_SegmentationBestFit.cpp"