kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
fix/bom-registration-path
create/src/Gui/ManualAlignment.cpp
pre-commit-ci[bot] 9fe130cd73 All: Reformat according to new standard
2025-11-11 13:49:01 +01:00

1473 lines
45 KiB
C++
Raw Permalink Blame History

/***************************************************************************
* Copyright (c) 2012 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 <QAction>
#include <QApplication>
#include <QLabel>
#include <QMenu>
#include <QMessageBox>
#include <QMdiSubWindow>
#include <QPainter>
#include <QSplitter>
#include <QSurfaceFormat>
#include <QTimer>
#include <QVBoxLayout>
#include <Inventor/SoPickedPoint.h>
#include <Inventor/actions/SoSearchAction.h>
#include <Inventor/events/SoMouseButtonEvent.h>
#include <Inventor/fields/SoSFImage.h>
#include <Inventor/nodes/SoImage.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoOrthographicCamera.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoTranslation.h>
#include <Inventor/sensors/SoNodeSensor.h>
#include <App/Document.h>
#include <App/GeoFeature.h>
#include <Gui/Application.h>
#include <Gui/BitmapFactory.h>
#include <Gui/Document.h>
#include <Gui/Inventor/SoAxisCrossKit.h>
#include <Gui/MainWindow.h>
#include <Gui/Selection/Selection.h>
#include <Gui/SplitView3DInventor.h>
#include <Gui/Tools.h>
#include <Gui/View3DInventorViewer.h>
#include <Gui/ViewProviderGeometryObject.h>
#include <Gui/WaitCursor.h>
#include "ManualAlignment.h"
using namespace Gui;
namespace sp = std::placeholders;
AlignmentGroup::AlignmentGroup() = default;
AlignmentGroup::~AlignmentGroup() = default;
void AlignmentGroup::addView(App::DocumentObject* pView)
{
if (pView) {
App::Document* rDoc = pView->getDocument();
Gui::Document* pDoc = Gui::Application::Instance->getDocument(rDoc);
auto pProvider = static_cast<Gui::ViewProviderDocumentObject*>(pDoc->getViewProvider(pView));
this->_views.push_back(pProvider);
}
}
std::vector<App::DocumentObject*> AlignmentGroup::getViews() const
{
std::vector<App::DocumentObject*> views;
std::vector<Gui::ViewProviderDocumentObject*>::const_iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
App::DocumentObject* pView = (*it)->getObject();
views.push_back(pView);
}
return views;
}
bool AlignmentGroup::hasView(Gui::ViewProviderDocumentObject* pView) const
{
std::vector<Gui::ViewProviderDocumentObject*>::const_iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
if (*it == pView) {
return true;
}
}
return false;
}
void AlignmentGroup::removeView(Gui::ViewProviderDocumentObject* pView)
{
std::vector<Gui::ViewProviderDocumentObject*>::iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
if (*it == pView) {
this->_views.erase(it);
break;
}
}
}
void AlignmentGroup::addToViewer(Gui::View3DInventorViewer* viewer) const
{
std::vector<Gui::ViewProviderDocumentObject*>::const_iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
viewer->addViewProvider(*it);
}
viewer->viewAll();
}
void AlignmentGroup::removeFromViewer(Gui::View3DInventorViewer* viewer) const
{
std::vector<Gui::ViewProviderDocumentObject*>::const_iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
viewer->removeViewProvider(*it);
}
}
void AlignmentGroup::setRandomColor()
{
std::vector<Gui::ViewProviderDocumentObject*>::iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
float r = /*(float)rand()/(float)RAND_MAX*/ 0.0f;
float g = (float)rand() / (float)RAND_MAX;
float b = (float)rand() / (float)RAND_MAX;
if ((*it)->isDerivedFrom<Gui::ViewProviderGeometryObject>()) {
SoSearchAction searchAction;
searchAction.setType(SoMaterial::getClassTypeId());
searchAction.setInterest(SoSearchAction::FIRST);
searchAction.apply((*it)->getRoot());
SoPath* selectionPath = searchAction.getPath();
if (selectionPath) {
auto material = static_cast<SoMaterial*>(selectionPath->getTail());
material->diffuseColor.setValue(r, g, b);
}
}
}
}
Gui::Document* AlignmentGroup::getDocument() const
{
if (this->_views.empty()) {
return nullptr;
}
App::DocumentObject* pView = this->_views[0]->getObject();
if (pView) {
App::Document* rDoc = pView->getDocument();
Gui::Document* pDoc = Gui::Application::Instance->getDocument(rDoc);
return pDoc;
}
return nullptr;
}
void AlignmentGroup::addPoint(const PickedPoint& pnt)
{
this->_pickedPoints.push_back(pnt);
}
void AlignmentGroup::removeLastPoint()
{
this->_pickedPoints.pop_back();
}
int AlignmentGroup::countPoints() const
{
return this->_pickedPoints.size();
}
const std::vector<PickedPoint>& AlignmentGroup::getPoints() const
{
return this->_pickedPoints;
}
void AlignmentGroup::clearPoints()
{
this->_pickedPoints.clear();
}
void AlignmentGroup::setAlignable(bool align)
{
std::vector<Gui::ViewProviderDocumentObject*>::iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
auto pAlignMode = dynamic_cast<App::PropertyBool*>((*it)->getPropertyByName("AlignMode"));
if (pAlignMode) {
pAlignMode->setValue(align);
}
// leaving alignment mode
else if (!align) {
auto pAppearance = dynamic_cast<App::PropertyMaterial*>(
(*it)->getPropertyByName("ShapeAppearance")
);
if (pAppearance) {
pAppearance->touch(); // resets to color defined by property
}
}
}
}
void AlignmentGroup::moveTo(AlignmentGroup& that)
{
std::vector<Gui::ViewProviderDocumentObject*>::iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
that._views.push_back(*it);
}
this->_views.clear();
}
void AlignmentGroup::clear()
{
this->_views.clear();
this->_pickedPoints.clear();
}
bool AlignmentGroup::isEmpty() const
{
return this->_views.empty();
}
int AlignmentGroup::count() const
{
return this->_views.size();
}
Base::BoundBox3d AlignmentGroup::getBoundingBox() const
{
Base::BoundBox3d box;
std::vector<Gui::ViewProviderDocumentObject*>::const_iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
if ((*it)->isDerivedFrom<Gui::ViewProviderGeometryObject>()) {
auto geo = (*it)->getObject<App::GeoFeature>();
const App::PropertyComplexGeoData* prop = geo->getPropertyOfGeometry();
if (prop) {
box.Add(prop->getBoundingBox());
}
}
}
return box;
}
// ------------------------------------------------------------------
MovableGroup::MovableGroup() = default;
MovableGroup::~MovableGroup() = default;
// ------------------------------------------------------------------
FixedGroup::FixedGroup() = default;
FixedGroup::~FixedGroup() = default;
// ------------------------------------------------------------------
MovableGroupModel::MovableGroupModel() = default;
MovableGroupModel::~MovableGroupModel() = default;
void MovableGroupModel::addGroup(const MovableGroup& grp)
{
this->_groups.push_back(grp);
}
void MovableGroupModel::addGroups(const std::map<int, MovableGroup>& grps)
{
for (const auto& grp : grps) {
this->_groups.push_back(grp.second);
}
}
void MovableGroupModel::removeActiveGroup()
{
this->_groups.erase(this->_groups.begin());
}
MovableGroup& MovableGroupModel::activeGroup()
{
// Make sure that the array is not empty
if (this->_groups.empty()) {
throw Base::RuntimeError("Empty group");
}
return *(this->_groups.begin());
}
const MovableGroup& MovableGroupModel::activeGroup() const
{
// Make sure that the array is not empty
if (this->_groups.empty()) {
throw Base::RuntimeError("Empty group");
}
return this->_groups.front();
}
void MovableGroupModel::continueAlignment()
{
if (!isEmpty()) {
removeActiveGroup();
}
}
void MovableGroupModel::clear()
{
this->_groups.clear();
}
bool MovableGroupModel::isEmpty() const
{
return this->_groups.empty();
}
int MovableGroupModel::count() const
{
return this->_groups.size();
}
const MovableGroup& MovableGroupModel::getGroup(int i) const
{
if (i >= count()) {
throw Base::IndexError("Index out of range");
}
return this->_groups[i];
}
Base::BoundBox3d MovableGroupModel::getBoundingBox() const
{
Base::BoundBox3d box;
std::vector<MovableGroup>::const_iterator it;
for (it = this->_groups.begin(); it != this->_groups.end(); ++it) {
box.Add(it->getBoundingBox());
}
return box;
}
// ------------------------------------------------------------------
namespace Gui
{
class AlignmentView: public Gui::AbstractSplitView
{
public:
QLabel* myLabel;
AlignmentView(Gui::Document* pcDocument, QWidget* parent, Qt::WindowFlags wflags = Qt::WindowFlags())
: AbstractSplitView(pcDocument, parent, wflags)
{
// anti-aliasing settings
bool smoothing = false;
bool glformat = false;
int samples = View3DInventorViewer::getNumSamples();
QSurfaceFormat f;
if (samples > 1) {
glformat = true;
f.setSamples(samples);
}
else if (samples > 0) {
smoothing = true;
}
QSplitter* mainSplitter = nullptr;
mainSplitter = new QSplitter(Qt::Horizontal, this);
if (glformat) {
_viewer.push_back(new View3DInventorViewer(f, mainSplitter));
_viewer.push_back(new View3DInventorViewer(f, mainSplitter));
}
else {
_viewer.push_back(new View3DInventorViewer(mainSplitter));
_viewer.push_back(new View3DInventorViewer(mainSplitter));
}
setDocumentOfViewers(pcDocument);
auto vbox = new QFrame(this);
auto layout = new QVBoxLayout();
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
vbox->setLayout(layout);
myLabel = new QLabel(this);
myLabel->setAutoFillBackground(true);
QPalette pal = myLabel->palette();
pal.setColor(QPalette::Window, Qt::darkGray);
pal.setColor(QPalette::WindowText, Qt::white);
myLabel->setPalette(pal);
mainSplitter->setPalette(pal);
myLabel->setAlignment(Qt::AlignCenter);
myLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
QFont font = myLabel->font();
font.setPointSize(14);
myLabel->setFont(font);
layout->addWidget(myLabel);
layout->addWidget(mainSplitter);
vbox->show();
setCentralWidget(vbox);
// apply the user settings
setupSettings();
if (smoothing) {
for (const auto& i : _viewer) {
i->getSoRenderManager()->getGLRenderAction()->setSmoothing(true);
}
}
static_cast<SoGroup*>(getViewer(0)->getSoRenderManager()->getSceneGraph())
->addChild(setupHeadUpDisplay(tr("Movable object")));
static_cast<SoGroup*>(getViewer(1)->getSoRenderManager()->getSceneGraph())
->addChild(setupHeadUpDisplay(tr("Fixed object")));
}
~AlignmentView() override = default;
PyObject* getPyObject() override
{
Py_Return;
}
bool canClose() override
{
return false;
}
SoNode* setupHeadUpDisplay(const QString& text) const
{
auto hudRoot = new SoSeparator;
hudRoot->ref();
auto hudCam = new SoOrthographicCamera();
hudCam->viewportMapping = SoCamera::LEAVE_ALONE;
// Set the position in the window.
// [0, 0] is in the center of the screen.
//
auto hudTrans = new SoTranslation;
hudTrans->translation.setValue(-0.95f, -0.95f, 0.0f);
QFont font = this->font();
font.setPointSize(24);
QFontMetrics fm(font);
QColor front;
front.setRgbF(0.8f, 0.8f, 0.8f);
int w = QtTools::horizontalAdvance(fm, text);
int h = fm.height();
QImage image(w, h, QImage::Format_ARGB32_Premultiplied);
image.fill(0x00000000);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(front);
painter.setFont(font);
painter.drawText(0, 0, w, h, Qt::AlignLeft, text);
painter.end();
SoSFImage sfimage;
Gui::BitmapFactory().convert(image, sfimage);
auto hudImage = new SoImage();
hudImage->image = sfimage;
// Assemble the parts...
//
hudRoot->addChild(hudCam);
hudRoot->addChild(hudTrans);
hudRoot->addChild(hudImage);
return hudRoot;
}
};
} // namespace Gui
class ManualAlignment::Private
{
public:
SoSeparator* picksepLeft;
SoSeparator* picksepRight;
SoNodeSensor* sensorCam1 {nullptr};
SoNodeSensor* sensorCam2 {nullptr};
SbRotation rot_cam1, rot_cam2;
SbVec3f pos_cam1, pos_cam2;
Private()
{
// left view
picksepLeft = new SoSeparator;
picksepLeft->ref();
// right view
picksepRight = new SoSeparator;
picksepRight->ref();
}
~Private()
{
picksepLeft->unref();
picksepRight->unref();
delete sensorCam1;
delete sensorCam2;
}
static void reorientCamera(SoCamera* cam, const SbRotation& rot)
{
if (!cam) {
return;
}
// Find global coordinates of focal point.
SbVec3f direction;
cam->orientation.getValue().multVec(SbVec3f(0, 0, -1), direction);
SbVec3f focalpoint = cam->position.getValue() + cam->focalDistance.getValue() * direction;
// Set new orientation value by accumulating the new rotation.
cam->orientation = rot * cam->orientation.getValue();
// Reposition camera so we are still pointing at the same old focal point.
cam->orientation.getValue().multVec(SbVec3f(0, 0, -1), direction);
cam->position = focalpoint - cam->focalDistance.getValue() * direction;
}
static void copyCameraSettings(
SoCamera* cam1,
SbRotation& rot_cam1,
SbVec3f& pos_cam1,
SoCamera* cam2,
SbRotation& rot_cam2,
SbVec3f& pos_cam2
)
{
Q_UNUSED(pos_cam2);
// recompute the diff we have applied to the camera's orientation
SbRotation rot = cam1->orientation.getValue();
SbRotation dif = rot * rot_cam1.inverse();
rot_cam1 = rot;
// copy the values
cam2->enableNotify(false);
cam2->nearDistance = cam1->nearDistance;
cam2->farDistance = cam1->farDistance;
cam2->focalDistance = cam1->focalDistance;
reorientCamera(cam2, dif);
rot_cam2 = cam2->orientation.getValue();
// reverse engineer the translation part in wc
SbVec3f pos = cam1->position.getValue();
SbVec3f difpos = pos - pos_cam1;
pos_cam1 = pos;
// the translation in pixel coords
cam1->orientation.getValue().inverse().multVec(difpos, difpos);
// the translation again in wc for the second camera
cam2->orientation.getValue().multVec(difpos, difpos);
cam2->position.setValue(cam2->position.getValue() + difpos);
if (cam1->getTypeId() == cam2->getTypeId()) {
if (cam1->getTypeId() == SoOrthographicCamera::getClassTypeId()) {
static_cast<SoOrthographicCamera*>(cam2)->height
= static_cast<SoOrthographicCamera*>(cam1)->height;
}
}
cam2->enableNotify(true);
}
static void syncCameraCB(void* data, SoSensor* s)
{
auto self = static_cast<ManualAlignment*>(data);
if (!self->myViewer) {
return; // already destroyed
}
SoCamera* cam1 = self->myViewer->getViewer(0)->getSoRenderManager()->getCamera();
SoCamera* cam2 = self->myViewer->getViewer(1)->getSoRenderManager()->getCamera();
if (!cam1 || !cam2) {
return; // missing camera
}
auto sensor = static_cast<SoNodeSensor*>(s);
SoNode* node = sensor->getAttachedNode();
if (node && node->getTypeId().isDerivedFrom(SoCamera::getClassTypeId())) {
if (node == cam1) {
Private::copyCameraSettings(
cam1,
self->d->rot_cam1,
self->d->pos_cam1,
cam2,
self->d->rot_cam2,
self->d->pos_cam2
);
self->myViewer->getViewer(1)->redraw();
}
else if (node == cam2) {
Private::copyCameraSettings(
cam2,
self->d->rot_cam2,
self->d->pos_cam2,
cam1,
self->d->rot_cam1,
self->d->pos_cam1
);
self->myViewer->getViewer(0)->redraw();
}
}
}
static Base::Placement transformation2x2(
const Base::Vector3d& plane1_base,
const Base::Vector3d& plane1_xaxis,
const Base::Vector3d& plane2_base,
const Base::Vector3d& plane2_xaxis
)
{
// the transformation is:
// * move from plane1_base to plane2_base
// * rotate from plane1_zaxis to plane2_zaxis around plane2_base as center point
Base::Rotation rot(plane1_xaxis, plane2_xaxis);
Base::Vector3d pln_base;
rot.multVec(plane1_base, pln_base);
Base::Vector3d dif = plane2_base - pln_base;
return {dif, rot};
}
static Base::Placement transformation3x3(
const Base::Vector3d& plane1_base,
const Base::Vector3d& plane1_zaxis,
const Base::Vector3d& plane1_xaxis,
const Base::Vector3d& plane2_base,
const Base::Vector3d& plane2_zaxis,
const Base::Vector3d& plane2_xaxis
)
{
// the transformation is:
// * move from plane1_base to plane2_base
// * rotate from plane1_zaxis to plane2_zaxis around plane2_base as center point
Base::Rotation rot(plane1_zaxis, plane2_zaxis);
// first transformation to align the plane normals and base points
Base::Vector3d dif1 = plane1_base;
rot.multVec(dif1, dif1);
dif1 = plane2_base - dif1;
Base::Placement plm1(dif1, rot);
// second transformation to align the planes' x axes
Base::Vector3d pln_xaxis;
rot.multVec(plane1_xaxis, pln_xaxis);
Base::Rotation rot2(pln_xaxis, plane2_xaxis);
Base::Vector3d dif2 = plane2_base;
rot2.multVec(dif2, dif2);
dif2 = plane2_base - dif2;
Base::Placement plm2(dif2, rot2);
plm2 = plm2 * plm1;
return plm2;
}
};
/* TRANSLATOR Gui::ManualAlignment */
ManualAlignment* ManualAlignment::_instance = nullptr;
/**
* Construction.
*/
ManualAlignment::ManualAlignment()
: myViewer(nullptr)
, myDocument(nullptr)
, myPickPoints(3)
, d(new Private)
{
// NOLINTBEGIN
// connect with the application's signal for deletion of documents
this->connectApplicationDeletedDocument = Gui::Application::Instance->signalDeleteDocument.connect(
std::bind(&ManualAlignment::slotDeletedDocument, this, sp::_1)
);
// NOLINTEND
// setup sensor connection
d->sensorCam1 = new SoNodeSensor(Private::syncCameraCB, this);
d->sensorCam2 = new SoNodeSensor(Private::syncCameraCB, this);
}
/**
* Destruction.
*/
ManualAlignment::~ManualAlignment()
{
this->connectDocumentDeletedObject.disconnect();
this->connectApplicationDeletedDocument.disconnect();
closeViewer();
delete d;
_instance = nullptr;
}
/**
* Creates the one and only instance of this class.
*/
ManualAlignment* ManualAlignment::instance()
{
// not initialized?
if (!_instance) {
_instance = new ManualAlignment();
}
return _instance;
}
/**
* Destructs the one and only instance of this class.
*/
void ManualAlignment::destruct()
{
if (_instance) {
ManualAlignment* tmp = _instance;
_instance = nullptr;
delete tmp;
}
}
/**
* Checks whether the one instance exists.
*/
bool ManualAlignment::hasInstance()
{
return _instance != nullptr;
}
void ManualAlignment::setMinPoints(int minPoints)
{
if ((minPoints > 0) && (minPoints <= 3)) {
myPickPoints = minPoints;
}
}
void ManualAlignment::setFixedGroup(const FixedGroup& fixed)
{
this->myFixedGroup = fixed;
this->myDocument = fixed.getDocument();
}
void ManualAlignment::setModel(const MovableGroupModel& model)
{
this->myAlignModel = model;
}
void ManualAlignment::clearAll()
{
myFixedGroup.clear();
myAlignModel.clear();
myDocument = nullptr;
}
void ManualAlignment::setViewingDirections(
const Base::Vector3d& view1,
const Base::Vector3d& up1,
const Base::Vector3d& view2,
const Base::Vector3d& up2
)
{
if (myViewer.isNull()) {
return;
}
{
SbVec3f vz(-view1.x, -view1.y, -view1.z);
vz.normalize();
SbVec3f vy(up1.x, up1.y, up1.z);
vy.normalize();
SbVec3f vx = vy.cross(vz);
vy = vz.cross(vx);
SbMatrix rot = SbMatrix::identity();
rot[0][0] = vx[0];
rot[0][1] = vx[1];
rot[0][2] = vx[2];
rot[1][0] = vy[0];
rot[1][1] = vy[1];
rot[1][2] = vy[2];
rot[2][0] = vz[0];
rot[2][1] = vz[1];
rot[2][2] = vz[2];
SbRotation total(rot);
myViewer->getViewer(0)->getSoRenderManager()->getCamera()->orientation.setValue(total);
myViewer->getViewer(0)->viewAll();
}
{
SbVec3f vz(-view2.x, -view2.y, -view2.z);
vz.normalize();
SbVec3f vy(up2.x, up2.y, up2.z);
vy.normalize();
SbVec3f vx = vy.cross(vz);
vy = vz.cross(vx);
SbMatrix rot = SbMatrix::identity();
rot[0][0] = vx[0];
rot[0][1] = vx[1];
rot[0][2] = vx[2];
rot[1][0] = vy[0];
rot[1][1] = vy[1];
rot[1][2] = vy[2];
rot[2][0] = vz[0];
rot[2][1] = vz[1];
rot[2][2] = vz[2];
SbRotation total(rot);
myViewer->getViewer(1)->getSoRenderManager()->getCamera()->orientation.setValue(total);
myViewer->getViewer(1)->viewAll();
}
}
/**
* Performs the alignment for the specified aligned and non-aligned views specified by setModel()
* and setFixedGroup().
*/
void ManualAlignment::startAlignment(Base::Type mousemodel)
{
// allow only one alignment at a time
if (!myViewer.isNull()) {
QMessageBox::warning(
qApp->activeWindow(),
tr("Manual alignment"),
tr("The alignment is already in progress.")
);
return;
}
myTransform = Base::Placement();
if (myFixedGroup.isEmpty()) {
return;
}
if (myAlignModel.isEmpty()) {
return;
}
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
// save the current window state before opening the alignment viewer
previousWindowState = Qt::WindowNoState;
if (auto* activeDoc = Gui::Application::Instance->activeDocument()) {
if (auto* activeView = activeDoc->getActiveView()) {
if (auto* subWindow = qobject_cast<QMdiSubWindow*>(activeView->parentWidget())) {
previousWindowState = subWindow->windowState();
}
}
}
#endif
// create a split window for picking the points
myViewer = new AlignmentView(myDocument, Gui::getMainWindow());
myViewer->setWindowTitle(tr("Alignment[*]"));
myViewer->setWindowIcon(QApplication::windowIcon());
myViewer->resize(400, 300);
Gui::getMainWindow()->addWindow(myViewer);
myViewer->showMaximized();
int n = this->myPickPoints;
QString msg = n == 1 ? tr("Select at least 1 point in the left and the right view")
: tr("Select at least %1 points in the left and the right view").arg(n);
myViewer->myLabel->setText(msg);
connect(myViewer, &QObject::destroyed, this, &ManualAlignment::reset);
// show all aligned views in the 2nd view
myFixedGroup.addToViewer(myViewer->getViewer(1));
myFixedGroup.setAlignable(true);
// set picked points root
SoNode* node1 = myViewer->getViewer(0)->getSceneGraph();
if (node1->getTypeId().isDerivedFrom(SoGroup::getClassTypeId())) {
((SoGroup*)node1)->addChild(d->picksepLeft);
}
SoNode* node2 = myViewer->getViewer(1)->getSceneGraph();
if (node2->getTypeId().isDerivedFrom(SoGroup::getClassTypeId())) {
((SoGroup*)node2)->addChild(d->picksepRight);
}
myViewer->getViewer(0)->setEditing(true);
myViewer->getViewer(0)->addEventCallback(
SoMouseButtonEvent::getClassTypeId(),
ManualAlignment::probePickedCallback
);
myViewer->getViewer(1)->setEditing(true);
myViewer->getViewer(1)->addEventCallback(
SoMouseButtonEvent::getClassTypeId(),
ManualAlignment::probePickedCallback
);
// apply the mouse model
myViewer->getViewer(0)->setNavigationType(mousemodel);
myViewer->getViewer(1)->setNavigationType(mousemodel);
// Connect to the document's signal as we want to be notified when something happens
if (this->connectDocumentDeletedObject.connected()) {
this->connectDocumentDeletedObject.disconnect();
}
// NOLINTBEGIN
this->connectDocumentDeletedObject = myDocument->signalDeletedObject.connect(
std::bind(&ManualAlignment::slotDeletedObject, this, sp::_1)
);
// NOLINTEND
continueAlignment();
}
/**
* If still one view needs to be aligned then it is shown in the first window. If all views are
* aligned the process will be terminated.
*/
void ManualAlignment::continueAlignment()
{
myFixedGroup.clearPoints();
coinRemoveAllChildren(d->picksepLeft);
coinRemoveAllChildren(d->picksepRight);
if (!myAlignModel.isEmpty()) {
AlignmentGroup& grp = myAlignModel.activeGroup();
grp.clearPoints();
grp.addToViewer(myViewer->getViewer(0));
grp.setAlignable(true);
Gui::getMainWindow()->showMessage(tr("Select points in the left and right view"));
myViewer->getViewer(0)->setEditingCursor(QCursor(Qt::PointingHandCursor));
myViewer->getViewer(1)->setEditingCursor(QCursor(Qt::PointingHandCursor));
}
else {
finish();
}
}
void ManualAlignment::closeViewer()
{
if (!myViewer) {
return;
}
// Close the viewer
if (myViewer->parentWidget()) {
myViewer->parentWidget()->deleteLater();
}
myViewer = nullptr;
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QTimer::singleShot(0, [this]() {
auto* activeDoc = Gui::Application::Instance->activeDocument();
if (!activeDoc) {
return;
}
auto* activeView = activeDoc->getActiveView();
if (!activeView) {
return;
}
Gui::getMainWindow()->setActiveWindow(activeView);
if (auto* subWindow = qobject_cast<QMdiSubWindow*>(activeView->parentWidget())) {
// restore the previous window state
if (previousWindowState & Qt::WindowMaximized) {
subWindow->showMaximized();
}
else if (previousWindowState & Qt::WindowMinimized) {
subWindow->showMinimized();
}
else {
subWindow->showNormal();
}
}
});
#endif
}
/**
* Make all views unpickable and resets internal data.
*/
void ManualAlignment::reset()
{
if (!myAlignModel.isEmpty()) {
myAlignModel.activeGroup().setAlignable(false);
myAlignModel.activeGroup().clear();
myAlignModel.clear();
}
myFixedGroup.setAlignable(false);
myFixedGroup.clear();
coinRemoveAllChildren(d->picksepLeft);
coinRemoveAllChildren(d->picksepRight);
if (myDocument) {
this->connectDocumentDeletedObject.disconnect();
myDocument = nullptr;
}
}
/**
* Terminates the process and closes the windows.
*/
void ManualAlignment::finish()
{
if (myViewer.isNull()) {
return;
}
if (myDocument) {
myDocument->getDocument()->recompute();
}
closeViewer();
reset();
Gui::getMainWindow()->showMessage(tr("The alignment has finished"));
// If an event receiver has been defined send the manual alignment finished event to it
Q_EMIT emitFinished();
}
/**
* Cancels the process and closes the windows without performing an alignment.
*/
void ManualAlignment::cancel()
{
if (myViewer.isNull()) {
return;
}
closeViewer();
myTransform = Base::Placement();
reset();
Gui::getMainWindow()->showMessage(tr("The alignment has been canceled"));
// If an event receiver has been defined send the manual alignment cancelled event to it
Q_EMIT emitCanceled();
}
void ManualAlignment::align()
{
// Now we can start the actual alignment
if (myAlignModel.activeGroup().countPoints() < myPickPoints) {
QMessageBox::warning(
myViewer,
tr("Manual alignment"),
tr("Too few points picked in the left view."
" At least %1 points are needed.")
.arg(myPickPoints)
);
}
else if (myFixedGroup.countPoints() < myPickPoints) {
QMessageBox::warning(
myViewer,
tr("Manual alignment"),
tr("Too few points picked in the right view."
" At least %1 points are needed.")
.arg(myPickPoints)
);
}
else if (myAlignModel.activeGroup().countPoints() != myFixedGroup.countPoints()) {
QMessageBox::warning(
myViewer,
tr("Manual alignment"),
tr("Different number of points picked in left and right view.\n"
"On the left view %1 points are picked,\n"
"on the right view %2 points are picked.")
.arg(myAlignModel.activeGroup().countPoints())
.arg(myFixedGroup.countPoints())
);
}
else {
// do not allow one to pick further points
myAlignModel.activeGroup().removeFromViewer(myViewer->getViewer(0));
myAlignModel.activeGroup().setAlignable(false);
std::vector<App::DocumentObject*> pViews = myAlignModel.activeGroup().getViews();
Gui::getMainWindow()->showMessage(tr("Try to align group of views"));
// Compute alignment
bool ok = computeAlignment(myAlignModel.activeGroup().getPoints(), myFixedGroup.getPoints());
if (ok && myDocument) {
// Align views
myDocument->openCommand(QT_TRANSLATE_NOOP("Command", "Align"));
for (const auto& pView : pViews) {
alignObject(pView);
}
myDocument->commitCommand();
// the alignment was successful so show it in the right view now
// myAlignModel.activeGroup().setRandomColor();
myAlignModel.activeGroup().setAlignable(true);
myAlignModel.activeGroup().addToViewer(myViewer->getViewer(1));
myAlignModel.activeGroup().moveTo(myFixedGroup);
myAlignModel.continueAlignment();
}
else {
// Inform user that alignment failed
auto ret = QMessageBox::critical(
myViewer,
tr("Manual alignment"),
tr("The alignment failed.\nHow do you want to proceed?"),
QMessageBox::Retry | QMessageBox::Ignore | QMessageBox::Abort
);
if (ret == QMessageBox::Ignore) {
myAlignModel.continueAlignment();
}
else if (ret == QMessageBox::Abort) {
finish();
return;
}
}
continueAlignment();
}
}
void ManualAlignment::showInstructions()
{
// Now we can start the actual alignment
if (myAlignModel.activeGroup().countPoints() < myPickPoints) {
Gui::getMainWindow()->showMessage(tr("Too few points picked in the left view."
" At least %1 points are needed.")
.arg(myPickPoints));
}
else if (myFixedGroup.countPoints() < myPickPoints) {
Gui::getMainWindow()->showMessage(tr("Too few points picked in the right view."
" At least %1 points are needed.")
.arg(myPickPoints));
}
else if (myAlignModel.activeGroup().countPoints() != myFixedGroup.countPoints()) {
Gui::getMainWindow()->showMessage(
tr("Different number of points picked in left and right view. "
"On the left view %1 points are picked, "
"on the right view %2 points are picked.")
.arg(myAlignModel.activeGroup().countPoints())
.arg(myFixedGroup.countPoints())
);
}
}
bool ManualAlignment::canAlign() const
{
if (myAlignModel.activeGroup().countPoints() == myFixedGroup.countPoints()) {
if (myFixedGroup.countPoints() >= myPickPoints) {
return true;
}
}
return false;
}
/**
* This method computes the alignment. For the calculation of the alignment the picked points of
* both views are taken. If the alignment fails false is returned, true otherwise.
*/
bool ManualAlignment::computeAlignment(
const std::vector<PickedPoint>& movPts,
const std::vector<PickedPoint>& fixPts
)
{
assert((int)movPts.size() >= myPickPoints);
assert((int)fixPts.size() >= myPickPoints);
assert((int)movPts.size() == (int)fixPts.size());
myTransform = Base::Placement();
if (movPts.size() == 1) {
// 1 point partial solution: Simple translation only
myTransform.setPosition(fixPts[0].point - movPts[0].point);
}
else if (movPts.size() == 2) {
const Base::Vector3d& p1 = movPts[0].point;
const Base::Vector3d& p2 = movPts[1].point;
Base::Vector3d d1 = p2 - p1;
d1.Normalize();
const Base::Vector3d& q1 = fixPts[0].point;
const Base::Vector3d& q2 = fixPts[1].point;
Base::Vector3d d2 = q2 - q1;
d2.Normalize();
myTransform = Private::transformation2x2(p1, d1, q1, d2);
}
else if (movPts.size() >= 3) {
const Base::Vector3d& p1 = movPts[0].point;
const Base::Vector3d& p2 = movPts[1].point;
const Base::Vector3d& p3 = movPts[2].point;
Base::Vector3d d1 = p2 - p1;
d1.Normalize();
Base::Vector3d n1 = (p2 - p1) % (p3 - p1);
n1.Normalize();
const Base::Vector3d& q1 = fixPts[0].point;
const Base::Vector3d& q2 = fixPts[1].point;
const Base::Vector3d& q3 = fixPts[2].point;
Base::Vector3d d2 = q2 - q1;
d2.Normalize();
Base::Vector3d n2 = (q2 - q1) % (q3 - q1);
n2.Normalize();
myTransform = Private::transformation3x3(p1, d1, n1, q1, d2, n2);
}
return true;
}
/**
* This method performs the actual alignment of view \a pView.
*/
void ManualAlignment::alignObject(App::DocumentObject* obj)
{
if (obj->isDerivedFrom<App::GeoFeature>()) {
auto geom = static_cast<App::GeoFeature*>(obj);
geom->transformPlacement(this->myTransform);
}
}
/**
* Creates a point element as visible feedback for the user.
*/
SoNode* ManualAlignment::pickedPointsSubGraph(const SbVec3f& p, const SbVec3f& n, int id)
{
static const float color_table[10][3] = {
{1.0f, 0.0f, 0.0f}, // red
{0.0f, 1.0f, 0.0f}, // green
{0.0f, 0.0f, 1.0f}, // blue
{1.0f, 1.0f, 0.0f}, // yellow
{0.0f, 1.0f, 1.0f}, // cyan
{0.7f, 0.0f, 0.0f},
{0.0f, 0.7f, 0.0f},
{0.7f, 0.7f, 0.0f},
{0.7f, 0.0f, 0.5f},
{1.0f, 0.7f, 0.0f}
};
int index = (id - 1) % 10;
auto probe = new SoRegPoint();
probe->base.setValue(p);
probe->normal.setValue(n);
probe->color.setValue(color_table[index][0], color_table[index][1], color_table[index][2]);
SbString s(tr("Point_%1").arg(id).toStdString().c_str());
probe->text.setValue(s);
return probe;
}
/**
* Handle if the current document is about to being closed.
*/
void ManualAlignment::slotDeletedDocument(const Gui::Document& Doc)
{
if (&Doc == this->myDocument) {
reset();
}
}
/**
* Handle if the a view provider is about to being destroyed.
*/
void ManualAlignment::slotDeletedObject(const Gui::ViewProvider& Obj)
{
// remove the view provider either from the left or the right view
if (Obj.isDerivedFrom<Gui::ViewProviderDocumentObject>()) {
// remove the view provider immediately from the split window
bool found = false;
auto vp = const_cast<Gui::ViewProviderDocumentObject*>(
static_cast<const Gui::ViewProviderDocumentObject*>(&Obj)
);
if (myAlignModel.activeGroup().hasView(vp)) {
myViewer->getViewer(0)->removeViewProvider(vp);
found = true;
}
if (myFixedGroup.hasView(vp)) {
myViewer->getViewer(1)->removeViewProvider(vp);
found = true;
}
if (found) {
cancel();
}
}
}
void ManualAlignment::onAlign()
{
align();
}
void ManualAlignment::onRemoveLastPointMoveable()
{
int nPoints = myAlignModel.activeGroup().countPoints();
if (nPoints > 0) {
myAlignModel.activeGroup().removeLastPoint();
d->picksepLeft->removeChild(nPoints - 1);
}
}
void ManualAlignment::onRemoveLastPointFixed()
{
int nPoints = myFixedGroup.countPoints();
if (nPoints > 0) {
myFixedGroup.removeLastPoint();
d->picksepRight->removeChild(nPoints - 1);
}
}
void ManualAlignment::onClear()
{
myAlignModel.activeGroup().clear();
myFixedGroup.clear();
coinRemoveAllChildren(d->picksepLeft);
coinRemoveAllChildren(d->picksepRight);
}
void ManualAlignment::onCancel()
{
cancel();
}
void ManualAlignment::probePickedCallback(void* ud, SoEventCallback* n)
{
Q_UNUSED(ud);
auto view = static_cast<Gui::View3DInventorViewer*>(n->getUserData());
const SoEvent* ev = n->getEvent();
if (ev->getTypeId() == SoMouseButtonEvent::getClassTypeId()) {
// set as handled
n->getAction()->setHandled();
n->setHandled();
auto mbe = static_cast<const SoMouseButtonEvent*>(ev);
if (mbe->getButton() == SoMouseButtonEvent::BUTTON1
&& mbe->getState() == SoButtonEvent::DOWN) {
// if we are in 'align' mode then handle the click event
ManualAlignment* self = ManualAlignment::instance();
// Get the closest point to the camera of the whole scene.
// This point doesn't need to be part of this view provider.
Gui::WaitCursor wc;
const SoPickedPoint* point = view->getPickedPoint(n);
if (point) {
auto vp = static_cast<Gui::ViewProvider*>(
view->getViewProviderByPath(point->getPath())
);
if (vp && vp->isDerivedFrom<Gui::ViewProviderDocumentObject>()) {
auto that = static_cast<Gui::ViewProviderDocumentObject*>(vp);
if (self->applyPickedProbe(that, point)) {
const SbVec3f& vec = point->getPoint();
Gui::getMainWindow()->showMessage(
tr("Point picked at (%1,%2,%3)").arg(vec[0]).arg(vec[1]).arg(vec[2])
);
}
else {
Gui::getMainWindow()->showMessage(tr("No point was found on model"));
}
}
}
else {
Gui::getMainWindow()->showMessage(tr("No point was picked"));
}
}
else if (mbe->getButton() == SoMouseButtonEvent::BUTTON2
&& mbe->getState() == SoButtonEvent::UP) {
ManualAlignment* self = ManualAlignment::instance();
if (self->myAlignModel.isEmpty() || self->myFixedGroup.isEmpty()) {
return;
}
self->showInstructions();
int nPoints;
if (view == self->myViewer->getViewer(0)) {
nPoints = self->myAlignModel.activeGroup().countPoints();
}
else {
nPoints = self->myFixedGroup.countPoints();
}
QMenu menu;
QAction* fi = menu.addAction(tr("&Align"));
QAction* rem = menu.addAction(tr("&Remove Last Point"));
// QAction* cl = menu.addAction("C&lear");
QAction* ca = menu.addAction(tr("&Cancel"));
fi->setEnabled(self->canAlign());
rem->setEnabled(nPoints > 0);
menu.addSeparator();
QAction* sync = menu.addAction(tr("&Synchronize Views"));
sync->setCheckable(true);
if (self->d->sensorCam1->getAttachedNode()) {
sync->setChecked(true);
}
QAction* id = menu.exec(QCursor::pos());
if (id == fi) {
// call align->align();
QTimer::singleShot(300, self, &ManualAlignment::onAlign);
}
else if ((id == rem) && (view == self->myViewer->getViewer(0))) {
QTimer::singleShot(300, self, &ManualAlignment::onRemoveLastPointMoveable);
}
else if ((id == rem) && (view == self->myViewer->getViewer(1))) {
QTimer::singleShot(300, self, &ManualAlignment::onRemoveLastPointFixed);
}
// else if (id == cl) {
// // call align->clear();
// QTimer::singleShot(300, self, &ManualAlignment::onClear);
// }
else if (id == ca) {
// call align->cancel();
QTimer::singleShot(300, self, &ManualAlignment::onCancel);
}
else if (id == sync) {
// setup sensor connection
if (sync->isChecked()) {
SoCamera* cam1 = self->myViewer->getViewer(0)->getSoRenderManager()->getCamera();
SoCamera* cam2 = self->myViewer->getViewer(1)->getSoRenderManager()->getCamera();
if (cam1 && cam2) {
self->d->sensorCam1->attach(cam1);
self->d->rot_cam1 = cam1->orientation.getValue();
self->d->pos_cam1 = cam1->position.getValue();
self->d->sensorCam2->attach(cam2);
self->d->rot_cam2 = cam2->orientation.getValue();
self->d->pos_cam2 = cam2->position.getValue();
}
}
else {
self->d->sensorCam1->detach();
self->d->sensorCam2->detach();
}
}
}
}
}
/**
* This method stores the picked point \a pnt from the view provider \a prov. If enough points in
* both windows have been picked the alignment gets invoked.
*/
bool ManualAlignment::applyPickedProbe(Gui::ViewProviderDocumentObject* prov, const SoPickedPoint* pnt)
{
const SbVec3f& vec = pnt->getPoint();
const SbVec3f& nor = pnt->getNormal();
// add to the list for the non-aligned view in the left view
if (myAlignModel.activeGroup().hasView(prov)) {
std::vector<Base::Vector3d> pts = prov->getModelPoints(pnt);
if (pts.empty()) {
return false;
}
PickedPoint pp;
pp.point = pts.front();
myAlignModel.activeGroup().addPoint(pp);
// Adds a point marker for the picked point.
d->picksepLeft->addChild(
pickedPointsSubGraph(vec, nor, myAlignModel.activeGroup().countPoints())
);
return true;
}
else if (myFixedGroup.hasView(prov)) {
std::vector<Base::Vector3d> pts = prov->getModelPoints(pnt);
if (pts.empty()) {
return false;
}
PickedPoint pp;
pp.point = pts.front();
myFixedGroup.addPoint(pp);
// Adds a point marker for the picked point.
d->picksepRight->addChild(pickedPointsSubGraph(vec, nor, myFixedGroup.countPoints()));
return true;
}
return false;
}
#include "moc_ManualAlignment.cpp"
Reference in New Issue View Git Blame Copy Permalink