kindred/create
1
1
Fork 0
Code Issues 44 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
2d4c5a4cfb3ce631ded45525e6770418d05c5dbe
create/src/Mod/Mesh/Gui/MeshEditor.cpp
berniev 2d4c5a4cfb Mod: use emplace_back
2022-08-05 10:36:16 +02:00

739 lines
27 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2010 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 <algorithm>
# include <functional>
# include <QMenu>
# include <QTimer>
# include <Inventor/SbLine.h>
# include <Inventor/SbPlane.h>
# include <Inventor/SoPickedPoint.h>
# include <Inventor/details/SoFaceDetail.h>
# include <Inventor/details/SoPointDetail.h>
# include <Inventor/events/SoKeyboardEvent.h>
# include <Inventor/events/SoLocation2Event.h>
# include <Inventor/events/SoMouseButtonEvent.h>
# include <Inventor/nodes/SoBaseColor.h>
# include <Inventor/nodes/SoCamera.h>
# include <Inventor/nodes/SoCoordinate3.h>
# include <Inventor/nodes/SoDirectionalLight.h>
# include <Inventor/nodes/SoDrawStyle.h>
# include <Inventor/nodes/SoFaceSet.h>
# include <Inventor/nodes/SoLineSet.h>
# include <Inventor/nodes/SoMarkerSet.h>
# include <Inventor/nodes/SoPickStyle.h>
# include <Inventor/nodes/SoSeparator.h>
# include <Inventor/nodes/SoShapeHints.h>
#endif
#include "MeshEditor.h"
#include "SoFCMeshObject.h"
#include "SoPolygon.h"
#include <App/Document.h>
#include <Mod/Mesh/App/MeshFeature.h>
#include <Mod/Mesh/App/Core/Algorithm.h>
#include <Mod/Mesh/App/Core/Triangulation.h>
#include <Gui/Application.h>
#include <Gui/WaitCursor.h>
#include <Gui/View3DInventor.h>
#include <Gui/View3DInventorViewer.h>
using namespace MeshGui;
namespace sp = std::placeholders;
PROPERTY_SOURCE(MeshGui::ViewProviderFace, Gui::ViewProviderDocumentObject)
ViewProviderFace::ViewProviderFace() : mesh(nullptr), current_index(-1)
{
pcCoords = new SoCoordinate3();
pcCoords->ref();
pcCoords->point.setNum(0);
pcFaces = new SoFaceSet;
pcFaces->ref();
pcMeshPick = new SoFCMeshPickNode();
pcMeshPick->ref();
}
ViewProviderFace::~ViewProviderFace()
{
pcCoords->unref();
pcFaces->unref();
pcMeshPick->unref();
}
void ViewProviderFace::attach(App::DocumentObject* obj)
{
ViewProviderDocumentObject::attach(obj);
pcMeshPick->mesh.setValue(static_cast<Mesh::Feature*>(obj)->Mesh.getValuePtr());
// Draw markers
SoGroup* markers = new SoGroup();
SoDrawStyle* pointStyle = new SoDrawStyle();
pointStyle->style = SoDrawStyle::POINTS;
pointStyle->pointSize = 8.0f;
markers->addChild(pointStyle);
SoBaseColor * markcol = new SoBaseColor;
markcol->rgb.setValue(1.0f, 1.0f, 0.0f);
SoPointSet* marker = new SoPointSet();
markers->addChild(markcol);
markers->addChild(pcCoords);
markers->addChild(marker);
// Draw face
SoGroup* faces = new SoGroup();
SoDrawStyle* faceStyle = new SoDrawStyle();
faceStyle->style = SoDrawStyle::FILLED;
faces->addChild(faceStyle);
SoShapeHints * flathints = new SoShapeHints;
//flathints->vertexOrdering = SoShapeHints::COUNTERCLOCKWISE ;
//flathints->shapeType = SoShapeHints::UNKNOWN_SHAPE_TYPE;
faces->addChild(flathints);
SoBaseColor* basecol = new SoBaseColor;
if (mesh) {
App::Color col = mesh->ShapeColor.getValue();
basecol->rgb.setValue(col.r, col.g, col.b);
}
else {
basecol->rgb.setValue(1.0f, 0.0f, 0.0f);
}
faces->addChild(basecol);
faces->addChild(pcCoords);
faces->addChild(pcFaces);
SoGroup* face_marker = new SoGroup();
face_marker->addChild(faces);
face_marker->addChild(markers);
addDisplayMaskMode(markers, "Marker");
addDisplayMaskMode(face_marker, "Face");
setDisplayMode("Marker");
}
void ViewProviderFace::setDisplayMode(const char* ModeName)
{
if (strcmp(ModeName, "Face") == 0)
setDisplayMaskMode("Face");
else if (strcmp(ModeName, "Marker") == 0)
setDisplayMaskMode("Marker");
ViewProviderDocumentObject::setDisplayMode(ModeName);
}
const char* ViewProviderFace::getDefaultDisplayMode() const
{
return "Marker";
}
std::vector<std::string> ViewProviderFace::getDisplayModes() const
{
std::vector<std::string> modes;
modes.emplace_back("Marker");
modes.emplace_back("Face");
return modes;
}
SoPickedPoint* ViewProviderFace::getPickedPoint(const SbVec2s& pos, const Gui::View3DInventorViewer* viewer) const
{
SoSeparator* root = new SoSeparator;
root->ref();
root->addChild(viewer->getHeadlight());
root->addChild(viewer->getSoRenderManager()->getCamera());
root->addChild(this->pcMeshPick);
SoRayPickAction rp(viewer->getSoRenderManager()->getViewportRegion());
rp.setPoint(pos);
rp.apply(root);
root->unref();
// returns a copy of the point
SoPickedPoint* pick = rp.getPickedPoint();
//return (pick ? pick->copy() : 0); // needs the same instance of CRT under MS Windows
return (pick ? new SoPickedPoint(*pick) : nullptr);
}
// ----------------------------------------------------------------------
/* TRANSLATOR MeshGui::MeshFaceAddition */
MeshFaceAddition::MeshFaceAddition(Gui::View3DInventor* parent)
: QObject(parent), faceView(new MeshGui::ViewProviderFace())
{
}
MeshFaceAddition::~MeshFaceAddition()
{
delete faceView;
}
void MeshFaceAddition::startEditing(MeshGui::ViewProviderMesh* vp)
{
Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(parent());
Gui::View3DInventorViewer* viewer = view->getViewer();
viewer->setEditing(true);
viewer->setSelectionEnabled(false);
viewer->setRedirectToSceneGraph(true);
viewer->setRedirectToSceneGraphEnabled(true);
faceView->mesh = vp;
faceView->attach(vp->getObject());
viewer->addViewProvider(faceView);
//faceView->mesh->startEditing();
viewer->addEventCallback(SoEvent::getClassTypeId(),
MeshFaceAddition::addFacetCallback, this);
}
void MeshFaceAddition::finishEditing()
{
Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(parent());
Gui::View3DInventorViewer* viewer = view->getViewer();
viewer->setEditing(false);
viewer->setSelectionEnabled(true);
viewer->setRedirectToSceneGraph(false);
viewer->setRedirectToSceneGraphEnabled(false);
viewer->removeViewProvider(faceView);
//faceView->mesh->finishEditing();
viewer->removeEventCallback(SoEvent::getClassTypeId(),
MeshFaceAddition::addFacetCallback, this);
this->deleteLater();
}
void MeshFaceAddition::addFace()
{
Mesh::Feature* mf = static_cast<Mesh::Feature*>(faceView->mesh->getObject());
App::Document* doc = mf->getDocument();
doc->openTransaction("Add triangle");
Mesh::MeshObject* mesh = mf->Mesh.startEditing();
MeshCore::MeshFacet f;
f._aulPoints[0] = faceView->index[0];
f._aulPoints[1] = faceView->index[1];
f._aulPoints[2] = faceView->index[2];
std::vector<MeshCore::MeshFacet> faces;
faces.push_back(f);
mesh->addFacets(faces, true);
mf->Mesh.finishEditing();
doc->commitTransaction();
clearPoints();
}
void MeshFaceAddition::clearPoints()
{
faceView->index.clear();
faceView->current_index = -1;
faceView->pcCoords->point.setNum(0);
faceView->setDisplayMode("Marker");
}
void MeshFaceAddition::flipNormal()
{
if (faceView->index.size() < 3)
return;
std::swap(faceView->index[0], faceView->index[1]);
SbVec3f v1 = faceView->pcCoords->point[0];
SbVec3f v2 = faceView->pcCoords->point[1];
faceView->pcCoords->point.set1Value(0, v2);
faceView->pcCoords->point.set1Value(1, v1);
}
bool MeshFaceAddition::addMarkerPoint()
{
if (faceView->current_index < 0)
return false;
if (faceView->index.size() >= 3)
return false;
faceView->index.push_back(faceView->current_index);
faceView->current_index = -1;
if (faceView->index.size() == 3)
faceView->setDisplayMode("Face");
return true;
}
void MeshFaceAddition::showMarker(SoPickedPoint* pp)
{
const SbVec3f& vec = pp->getPoint();
const SoDetail* detail = pp->getDetail();
if (detail) {
if (detail->isOfType(SoFaceDetail::getClassTypeId())) {
const SoFaceDetail* fd = static_cast<const SoFaceDetail*>(detail);
Mesh::Feature* mf = static_cast<Mesh::Feature*>(faceView->mesh->getObject());
const MeshCore::MeshFacetArray& facets = mf->Mesh.getValuePtr()->getKernel().GetFacets();
const MeshCore::MeshPointArray& points = mf->Mesh.getValuePtr()->getKernel().GetPoints();
// is the face index valid?
int face_index = fd->getFaceIndex();
if (face_index >= (int)facets.size())
return;
// is a border facet picked?
MeshCore::MeshFacet f = facets[face_index];
if (!f.HasOpenEdge()) {
// check if a neighbour facet is at the border
bool ok=false;
for (int i=0; i<3; i++) {
if (facets[f._aulNeighbours[i]].HasOpenEdge()) {
f = facets[f._aulNeighbours[i]];
ok = true;
break;
}
}
if (!ok)
return;
}
int point_index = -1;
float distance = FLT_MAX;
Base::Vector3f pnt;
SbVec3f face_pnt;
for (int i=0; i<3; i++) {
int index = (int)f._aulPoints[i];
if (std::find(faceView->index.begin(), faceView->index.end(), index) != faceView->index.end())
continue; // already inside
if (f._aulNeighbours[i] == MeshCore::FACET_INDEX_MAX ||
f._aulNeighbours[(i+2)%3] == MeshCore::FACET_INDEX_MAX) {
pnt = points[index];
float len = Base::DistanceP2(pnt, Base::Vector3f(vec[0],vec[1],vec[2]));
if (len < distance) {
distance = len;
point_index = index;
face_pnt.setValue(pnt.x,pnt.y,pnt.z);
}
}
}
if (point_index < 0)
return; // picked point is rejected
int num = faceView->pcCoords->point.getNum();
if (faceView->current_index >= 0) {
num = std::max<int>(num-1, 0);
}
faceView->current_index = point_index;
faceView->pcCoords->point.set1Value(num, face_pnt);
return;
}
}
}
void MeshFaceAddition::addFacetCallback(void * ud, SoEventCallback * n)
{
MeshFaceAddition* that = static_cast<MeshFaceAddition*>(ud);
ViewProviderFace* face = that->faceView;
Gui::View3DInventorViewer* view = static_cast<Gui::View3DInventorViewer*>(n->getUserData());
const SoEvent* ev = n->getEvent();
// If we are in navigation mode then ignore all but key events
if (!view->isRedirectedToSceneGraph()) {
if (!ev->getTypeId().isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
return;
}
}
if (ev->getTypeId() == SoLocation2Event::getClassTypeId()) {
n->setHandled();
if (face->index.size() < 3) {
SoPickedPoint * point = face->getPickedPoint(ev->getPosition(), view);
if (point) {
that->showMarker(point);
delete point;
}
}
}
else if (ev->getTypeId() == SoMouseButtonEvent::getClassTypeId()) {
const SoMouseButtonEvent * mbe = static_cast<const SoMouseButtonEvent *>(ev);
if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 ||
mbe->getButton() == SoMouseButtonEvent::BUTTON2 ||
mbe->getButton() == SoMouseButtonEvent::BUTTON3) {
n->setHandled();
}
if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 && mbe->getState() == SoButtonEvent::DOWN) {
that->addMarkerPoint();
}
else if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 && mbe->getState() == SoButtonEvent::UP) {
if (face->index.size() == 3) {
QMenu menu;
QAction* add = menu.addAction(MeshFaceAddition::tr("Add triangle"));
QAction* swp = menu.addAction(MeshFaceAddition::tr("Flip normal"));
QAction* clr = menu.addAction(MeshFaceAddition::tr("Clear"));
QAction* act = menu.exec(QCursor::pos());
if (act == add) {
QTimer::singleShot(300, that, SLOT(addFace()));
}
else if (act == swp) {
QTimer::singleShot(300, that, SLOT(flipNormal()));
}
else if (act == clr) {
QTimer::singleShot(300, that, SLOT(clearPoints()));
}
}
}
else if (mbe->getButton() == SoMouseButtonEvent::BUTTON2 && mbe->getState() == SoButtonEvent::UP) {
QMenu menu;
QAction* fin = menu.addAction(MeshFaceAddition::tr("Finish"));
QAction* act = menu.exec(QCursor::pos());
if (act == fin) {
QTimer::singleShot(300, that, SLOT(finishEditing()));
}
}
}
// toggle between edit and navigation mode
else if (ev->getTypeId().isDerivedFrom(SoKeyboardEvent::getClassTypeId())) {
const SoKeyboardEvent * const ke = static_cast<const SoKeyboardEvent *>(ev);
if (ke->getState() == SoButtonEvent::DOWN &&
ke->getKey() == SoKeyboardEvent::ESCAPE) {
SbBool toggle = view->isRedirectedToSceneGraph();
view->setRedirectToSceneGraph(!toggle);
n->setHandled();
}
}
}
// ----------------------------------------------------------------------
namespace MeshGui {
// for sorting of elements
struct NofFacetsCompare
{
bool operator () (const std::vector<Mesh::PointIndex> &rclC1,
const std::vector<Mesh::PointIndex> &rclC2)
{
return rclC1.size() < rclC2.size();
}
};
}
/* TRANSLATOR MeshGui::MeshFillHole */
MeshFillHole::MeshFillHole(MeshHoleFiller& hf, Gui::View3DInventor* parent)
: QObject(parent)
, myMesh(nullptr)
, myNumPoints(0)
, myVertex1(0)
, myVertex2(0)
, myHoleFiller(hf)
{
myBoundariesRoot = new SoSeparator;
myBoundariesRoot->ref();
myBoundaryRoot = new SoSeparator;
myBoundaryRoot->ref();
myBoundariesGroup = new SoSeparator();
myBoundariesGroup->ref();
myBridgeRoot = new SoSeparator;
myBridgeRoot->ref();
SoDrawStyle* pointStyle = new SoDrawStyle();
pointStyle->style = SoDrawStyle::POINTS;
pointStyle->pointSize = 8.0f;
myBridgeRoot->addChild(pointStyle);
SoBaseColor * markcol = new SoBaseColor;
markcol->rgb.setValue(1.0f, 1.0f, 0.0f);
myBridgeRoot->addChild(markcol);
myVertex = new SoCoordinate3();
myBridgeRoot->addChild(myVertex);
myBridgeRoot->addChild(new SoPointSet);
}
MeshFillHole::~MeshFillHole()
{
myBoundariesRoot->unref();
myBoundariesGroup->unref();
myBoundaryRoot->unref();
myBridgeRoot->unref();
}
void MeshFillHole::startEditing(MeshGui::ViewProviderMesh* vp)
{
this->myMesh = static_cast<Mesh::Feature*>(vp->getObject());
Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(parent());
Gui::View3DInventorViewer* viewer = view->getViewer();
viewer->setEditing(true);
//viewer->setRedirectToSceneGraph(true);
viewer->addEventCallback(SoEvent::getClassTypeId(),
MeshFillHole::fileHoleCallback, this);
myConnection = App::GetApplication().signalChangedObject.connect(
std::bind(&MeshFillHole::slotChangedObject, this, sp::_1, sp::_2));
Gui::coinRemoveAllChildren(myBoundariesRoot);
myBoundariesRoot->addChild(viewer->getHeadlight());
myBoundariesRoot->addChild(viewer->getSoRenderManager()->getCamera());
myBoundariesRoot->addChild(myBoundariesGroup);
Gui::coinRemoveAllChildren(myBoundaryRoot);
myBoundaryRoot->addChild(viewer->getHeadlight());
myBoundaryRoot->addChild(viewer->getSoRenderManager()->getCamera());
createPolygons();
static_cast<SoGroup*>(viewer->getSceneGraph())->addChild(myBridgeRoot);
}
void MeshFillHole::finishEditing()
{
Gui::View3DInventor* view = static_cast<Gui::View3DInventor*>(parent());
Gui::View3DInventorViewer* viewer = view->getViewer();
viewer->setEditing(false);
//viewer->setRedirectToSceneGraph(false);
viewer->removeEventCallback(SoEvent::getClassTypeId(),
MeshFillHole::fileHoleCallback, this);
myConnection.disconnect();
this->deleteLater();
static_cast<SoGroup*>(viewer->getSceneGraph())->removeChild(myBridgeRoot);
}
void MeshFillHole::closeBridge()
{
// Do the hole-filling
Gui::WaitCursor wc;
TBoundary::iterator it = std::find(myPolygon.begin(), myPolygon.end(), myVertex1);
TBoundary::iterator jt = std::find(myPolygon.begin(), myPolygon.end(), myVertex2);
if (it != myPolygon.end() && jt != myPolygon.end()) {
// which iterator comes first
if (jt < it)
std::swap(it, jt);
// split the boundary into two loops and take the shorter one
std::list<TBoundary> bounds;
TBoundary loop1, loop2;
loop1.insert(loop1.end(), myPolygon.begin(), it);
loop1.insert(loop1.end(), jt, myPolygon.end());
loop2.insert(loop2.end(), it, jt);
// this happens when myVertex1 == myVertex2
if (loop2.empty())
bounds.push_back(loop1);
else if (loop1.size() < loop2.size())
bounds.push_back(loop1);
else
bounds.push_back(loop2);
App::Document* doc = myMesh->getDocument();
doc->openTransaction("Bridge && Fill hole");
Mesh::MeshObject* pMesh = myMesh->Mesh.startEditing();
bool ok = myHoleFiller.fillHoles(*pMesh, bounds, myVertex1, myVertex2);
myMesh->Mesh.finishEditing();
if (ok)
doc->commitTransaction();
else
doc->abortTransaction();
}
}
void MeshFillHole::slotChangedObject(const App::DocumentObject& Obj, const App::Property& Prop)
{
if (&Obj == myMesh && strcmp(Prop.getName(),"Mesh") == 0) {
Gui::coinRemoveAllChildren(myBoundariesGroup);
myVertex->point.setNum(0);
myNumPoints = 0;
myPolygon.clear();
createPolygons();
}
}
void MeshFillHole::createPolygons()
{
Gui::WaitCursor wc;
myPolygons.clear();
SoPickStyle* pickStyle = new SoPickStyle();
pickStyle->style = SoPickStyle::BOUNDING_BOX;
myBoundariesGroup->addChild(pickStyle);
myBoundaryRoot->addChild(pickStyle);
// get mesh kernel
const MeshCore::MeshKernel & rMesh = this->myMesh->Mesh.getValue().getKernel();
// get the mesh boundaries as an array of point indices
std::list<std::vector<Mesh::PointIndex> > borders;
MeshCore::MeshAlgorithm cAlgo(rMesh);
MeshCore::MeshPointIterator p_iter(rMesh);
cAlgo.GetMeshBorders(borders);
cAlgo.SplitBoundaryLoops(borders);
// sort the borders in ascending order of the number of edges
borders.sort(NofFacetsCompare());
int32_t count=0;
for (std::list<std::vector<Mesh::PointIndex> >::iterator it =
borders.begin(); it != borders.end(); ++it) {
if (it->front() == it->back())
it->pop_back();
count += it->size();
}
SoCoordinate3* coords = new SoCoordinate3();
myBoundariesGroup->addChild(coords);
myBoundaryRoot->addChild(coords);
coords->point.setNum(count);
int32_t index = 0;
for (std::list<std::vector<Mesh::PointIndex> >::iterator it =
borders.begin(); it != borders.end(); ++it) {
SoPolygon* polygon = new SoPolygon();
polygon->startIndex = index;
polygon->numVertices = it->size();
myBoundariesGroup->addChild(polygon);
myPolygons[polygon] = *it;
for (std::vector<Mesh::PointIndex>::iterator jt = it->begin();
jt != it->end(); ++jt) {
p_iter.Set(*jt);
coords->point.set1Value(index++,p_iter->x,p_iter->y,p_iter->z);
}
}
}
SoNode* MeshFillHole::getPickedPolygon(const SoRayPickAction& action/*SoNode* root, const SbVec2s& pos*/) const
{
SoPolygon* poly = nullptr;
const SoPickedPointList & points = action.getPickedPointList();
for (int i=0; i < points.getLength(); i++) {
const SoPickedPoint * point = points[i];
if (point && point->getPath()->getTail()->getTypeId() == MeshGui::SoPolygon::getClassTypeId()) {
// we have something picked, now check if it was an SoPolygon node
SoPolygon* node = static_cast<SoPolygon*>(point->getPath()->getTail());
if (!poly) {
poly = node;
}
// check which polygon has less edges
else if (node->numVertices.getValue() < poly->numVertices.getValue()) {
poly = node;
}
}
}
return poly;
}
float MeshFillHole::findClosestPoint(const SbLine& ray, const TBoundary& polygon,
Mesh::PointIndex& vertex_index, SbVec3f& closestPoint) const
{
// now check which vertex of the polygon is closest to the ray
float minDist = FLT_MAX;
vertex_index = MeshCore::POINT_INDEX_MAX;
const MeshCore::MeshKernel & rMesh = myMesh->Mesh.getValue().getKernel();
const MeshCore::MeshPointArray& pts = rMesh.GetPoints();
for (TBoundary::const_iterator it = polygon.begin(); it != polygon.end(); ++it) {
SbVec3f vertex;
const Base::Vector3f& v = pts[*it];
vertex.setValue(v.x,v.y,v.z);
SbVec3f point = ray.getClosestPoint(vertex);
float distance = (vertex-point).sqrLength();
if (distance < minDist) {
minDist = distance;
vertex_index = *it;
closestPoint = vertex;
}
}
return minDist;
}
void MeshFillHole::fileHoleCallback(void * ud, SoEventCallback * n)
{
MeshFillHole* self = static_cast<MeshFillHole*>(ud);
Gui::View3DInventorViewer* view = static_cast<Gui::View3DInventorViewer*>(n->getUserData());
const SoEvent* ev = n->getEvent();
if (ev->getTypeId() == SoLocation2Event::getClassTypeId()) {
n->setHandled();
SoRayPickAction rp(view->getSoRenderManager()->getViewportRegion());
rp.setPoint(ev->getPosition());
rp.setPickAll(true);
if (self->myNumPoints == 0)
rp.apply(self->myBoundariesRoot);
else
rp.apply(self->myBoundaryRoot);
SoNode* node = self->getPickedPolygon(rp);
if (node) {
std::map<SoNode*, TBoundary>::iterator it = self->myPolygons.find(node);
if (it != self->myPolygons.end()) {
// now check which vertex of the polygon is closest to the ray
Mesh::PointIndex vertex_index;
SbVec3f closestPoint;
float minDist = self->findClosestPoint(rp.getLine(), it->second, vertex_index, closestPoint);
if (minDist < 1.0f) {
if (self->myNumPoints == 0)
self->myVertex->point.set1Value(0, closestPoint);
else
self->myVertex->point.set1Value(1, closestPoint);
}
}
}
}
else if (ev->getTypeId() == SoMouseButtonEvent::getClassTypeId()) {
n->setHandled();
const SoMouseButtonEvent * mbe = static_cast<const SoMouseButtonEvent *>(ev);
if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 && mbe->getState() == SoButtonEvent::UP) {
if (self->myNumPoints > 1)
return;
SoRayPickAction rp(view->getSoRenderManager()->getViewportRegion());
rp.setPoint(ev->getPosition());
rp.setPickAll(true);
if (self->myNumPoints == 0)
rp.apply(self->myBoundariesRoot);
else
rp.apply(self->myBoundaryRoot);
SoNode* node = self->getPickedPolygon(rp);
if (node) {
std::map<SoNode*, TBoundary>::iterator it = self->myPolygons.find(node);
if (it != self->myPolygons.end()) {
// now check which vertex of the polygon is closest to the ray
Mesh::PointIndex vertex_index;
SbVec3f closestPoint;
float minDist = self->findClosestPoint(rp.getLine(), it->second, vertex_index, closestPoint);
if (minDist < 1.0f) {
if (self->myNumPoints == 0) {
self->myBoundaryRoot->addChild(node);
self->myVertex->point.set1Value(0, closestPoint);
self->myNumPoints = 1;
self->myVertex1 = vertex_index;
}
else {
// myVertex2 can be equal to myVertex1 which does a full hole-filling
self->myBoundaryRoot->removeChild(node);
self->myVertex->point.set1Value(1, closestPoint);
self->myNumPoints = 2;
self->myVertex2 = vertex_index;
self->myPolygon = it->second;
QTimer::singleShot(300, self, SLOT(closeBridge()));
}
}
}
}
}
else if (mbe->getButton() == SoMouseButtonEvent::BUTTON2 && mbe->getState() == SoButtonEvent::UP) {
QMenu menu;
QAction* fin = menu.addAction(MeshFillHole::tr("Finish"));
QAction* act = menu.exec(QCursor::pos());
if (act == fin) {
QTimer::singleShot(300, self, SLOT(finishEditing()));
}
}
}
}
#include "moc_MeshEditor.cpp"
Reference in New Issue View Git Blame Copy Permalink