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

SketcherGui: apply clang-format

Browse Source
This commit is contained in:
Abdullah Tahiri
2023-05-25 15:09:30 +02:00
committed by abdullahtahiriyo
parent dc2d861bf0
commit 78ae9c1d7d
98 changed files with 17648 additions and 13572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
src/Mod/Sketcher/Gui/EditModeInformationOverlayCoinConverter.cpp
View File

@@ -22,43 +22,43 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <Inventor/nodes/SoCoordinate3.h>
# include <Inventor/nodes/SoLineSet.h>
# include <Inventor/nodes/SoFont.h>
# include <Inventor/nodes/SoGroup.h>
# include <Inventor/nodes/SoMaterial.h>
# include <Inventor/nodes/SoSeparator.h>
# include <Inventor/nodes/SoSwitch.h>
# include <Inventor/nodes/SoText2.h>
# include <Inventor/nodes/SoTranslation.h>
#endif // #ifndef _PreComp_
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoFont.h>
#include <Inventor/nodes/SoGroup.h>
#include <Inventor/nodes/SoLineSet.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoSwitch.h>
#include <Inventor/nodes/SoText2.h>
#include <Inventor/nodes/SoTranslation.h>
#endif// #ifndef _PreComp_
#include <Base/Console.h>
#include <Base/Exception.h>
#include <Base/UnitsApi.h>
#include "EditModeInformationOverlayCoinConverter.h"
#include "EditModeCoinManagerParameters.h"
#include "EditModeInformationOverlayCoinConverter.h"
#include "ViewProviderSketchCoinAttorney.h"
using namespace SketcherGui;
EditModeInformationOverlayCoinConverter::EditModeInformationOverlayCoinConverter(
ViewProviderSketch & vp,
SoGroup * infogroup,
OverlayParameters & overlayparameters,
DrawingParameters & drawingparameters): viewProvider(vp),
infoGroup(infogroup),
overlayParameters(overlayparameters),
drawingParameters(drawingparameters),
nodeId(0){
ViewProviderSketch& vp, SoGroup* infogroup, OverlayParameters& overlayparameters,
DrawingParameters& drawingparameters)
: viewProvider(vp)
, infoGroup(infogroup)
, overlayParameters(overlayparameters)
, drawingParameters(drawingparameters)
, nodeId(0) {
};
};
void EditModeInformationOverlayCoinConverter::convert(const Part::Geometry * geometry, int geoid) {
void EditModeInformationOverlayCoinConverter::convert(const Part::Geometry* geometry, int geoid)
{
if (geometry->getTypeId() == Part::GeomBSplineCurve::getClassTypeId()){
if (geometry->getTypeId() == Part::GeomBSplineCurve::getClassTypeId()) {
// at this point all calculations relate to BSplineCurves
calculate<CalculationType::BSplineDegree>(geometry, geoid);
calculate<CalculationType::BSplineControlPolygon>(geometry, geoid);
@@ -71,23 +71,27 @@ void EditModeInformationOverlayCoinConverter::convert(const Part::Geometry * geo
addUpdateNode(curvatureComb);
addUpdateNode(knotMultiplicity);
addUpdateNode(poleWeights);
} else if (geometry->getTypeId() == Part::GeomArcOfCircle::getClassTypeId()){
}
else if (geometry->getTypeId() == Part::GeomArcOfCircle::getClassTypeId()) {
// at this point all calculations relate to ArcOfCircle
calculate<CalculationType::ArcCircleHelper>(geometry, geoid);
addUpdateNode(circleHelper);
}
}
void EditModeInformationOverlayCoinConverter::addToInfoGroup(SoSwitch * sw) {
void EditModeInformationOverlayCoinConverter::addToInfoGroup(SoSwitch* sw)
{
infoGroup->addChild(sw);
nodeId++;
}
template < EditModeInformationOverlayCoinConverter::CalculationType calculation >
void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * geometry, [[maybe_unused]] int geoid) {
template<EditModeInformationOverlayCoinConverter::CalculationType calculation>
void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry* geometry,
[[maybe_unused]] int geoid)
{
if constexpr (calculation == CalculationType::ArcCircleHelper ) {
const Part::GeomArcOfCircle *arc = static_cast<const Part::GeomArcOfCircle *>(geometry);
if constexpr (calculation == CalculationType::ArcCircleHelper) {
const Part::GeomArcOfCircle* arc = static_cast<const Part::GeomArcOfCircle*>(geometry);
clearCalculation(circleHelper);
Base::Vector3d center = arc->getCenter();
@@ -100,15 +104,16 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
circleHelper.coordinates.reserve(ndiv);
for (int i = 0; i < ndiv; i++) {
double param = i * std::atan(1) * 8 / ndiv;
circleHelper.coordinates.emplace_back(circle.value(param));
double param = i * std::atan(1) * 8 / ndiv;
circleHelper.coordinates.emplace_back(circle.value(param));
}
circleHelper.coordinates.emplace_back(circle.value(0.0));
circleHelper.coordinates.emplace_back(circle.value(0.0));
circleHelper.indices.push_back(ndiv + 1);
} else {
const Part::GeomBSplineCurve *spline = static_cast<const Part::GeomBSplineCurve *>(geometry);
}
else {
const Part::GeomBSplineCurve* spline = static_cast<const Part::GeomBSplineCurve*>(geometry);
if constexpr (calculation == CalculationType::BSplineDegree ) {
if constexpr (calculation == CalculationType::BSplineDegree) {
clearCalculation(degree);
std::vector<Base::Vector3d> poles = spline->getPoles();
@@ -116,7 +121,7 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
degree.strings.clear();
degree.positions.clear();
Base::Vector3d midp = Base::Vector3d(0,0,0);
Base::Vector3d midp = Base::Vector3d(0, 0, 0);
for (auto val : poles)
midp += val;
@@ -126,7 +131,7 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
degree.strings.emplace_back(std::to_string(spline->getDegree()));
degree.positions.emplace_back(midp);
}
else if constexpr (calculation == CalculationType::BSplineControlPolygon ) {
else if constexpr (calculation == CalculationType::BSplineControlPolygon) {
clearCalculation(controlPolygon);
@@ -138,21 +143,22 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
size_t nvertices;
if (spline->isPeriodic())
nvertices = poles.size()+1;
nvertices = poles.size() + 1;
else
nvertices = poles.size();
controlPolygon.coordinates.reserve(nvertices);
for (auto & v : poles)
for (auto& v : poles)
controlPolygon.coordinates.emplace_back(v);
if (spline->isPeriodic())
controlPolygon.coordinates.emplace_back(poles[0]);
controlPolygon.indices.push_back(nvertices); // single continuous polygon starting at index 0
controlPolygon.indices.push_back(
nvertices);// single continuous polygon starting at index 0
}
else if constexpr (calculation == CalculationType::BSplineCurvatureComb ) {
else if constexpr (calculation == CalculationType::BSplineCurvatureComb) {
clearCalculation(curvatureComb);
// curvature graph --------------------------------------------------------
@@ -165,7 +171,7 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
auto knots = spline->getKnots();
auto mults = spline->getMultiplicities();
const int ndivPerPiece = 64; // heuristic of number of division to fill in
const int ndivPerPiece = 64;// heuristic of number of division to fill in
const int ndiv = ndivPerPiece * (knots.size() - 1);
std::vector<Base::Vector3d> pointatcurvelist;
@@ -177,10 +183,13 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
normallist.reserve(ndiv);
// go through the polynomial pieces (i.e. from one knot to next)
for (size_t k = 0; k < knots.size()-1; ++k) {
// first and last params are a little off to account for possible discontinuity at knots
double firstparam = knots[k] + Precision::Approximation()*(knots[k + 1] - knots[k]);
double lastparam = knots[k + 1] - Precision::Approximation()*(knots[k + 1] - knots[k]);
for (size_t k = 0; k < knots.size() - 1; ++k) {
// first and last params are a little off to account for possible discontinuity at
// knots
double firstparam =
knots[k] + Precision::Approximation() * (knots[k + 1] - knots[k]);
double lastparam =
knots[k + 1] - Precision::Approximation() * (knots[k + 1] - knots[k]);
// TODO: Maybe this can be improved, specifically adapted for each piece
double step = (lastparam - firstparam) / (ndivPerPiece - 1);
@@ -192,12 +201,15 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
try {
curvaturelist.emplace_back(spline->curvatureAt(param));
}
catch(Base::CADKernelError &e) {
catch (Base::CADKernelError& e) {
// it is "just" a visualisation matter OCC could not calculate the curvature
// terminating here would mean that the other shapes would not be drawn.
// Solution: Report the issue and set dummy curvature to 0
e.ReportException();
Base::Console().DeveloperError("EditModeInformationOverlayCoinConverter","Curvature graph for B-Spline with GeoId=%d could not be calculated.\n", geoid);
Base::Console().DeveloperError(
"EditModeInformationOverlayCoinConverter",
"Curvature graph for B-Spline with GeoId=%d could not be calculated.\n",
geoid);
curvaturelist.emplace_back(0);
}
@@ -206,8 +218,8 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
spline->normalAt(param, normal);
normallist.emplace_back(normal);
}
catch(Base::Exception&) {
normallist.emplace_back(0,0,0);
catch (Base::Exception&) {
normallist.emplace_back(0, 0, 0);
}
}
}
@@ -216,52 +228,64 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
pointatcomblist.reserve(ndiv);
for (int i = 0; i < ndiv; i++) {
pointatcomblist.emplace_back(pointatcurvelist[i] - overlayParameters.currentBSplineCombRepresentationScale * curvaturelist[i] * normallist[i]);
pointatcomblist.emplace_back(
pointatcurvelist[i]
- overlayParameters.currentBSplineCombRepresentationScale * curvaturelist[i]
* normallist[i]);
}
curvatureComb.coordinates.reserve(3*ndiv); // 2*ndiv +1 points of ndiv separate segments + ndiv points for last segment
curvatureComb.indices.reserve(ndiv+1); // ndiv separate segments of radials + 1 segment connecting at comb end
curvatureComb.coordinates.reserve(
3
* ndiv);// 2*ndiv +1 points of ndiv separate segments + ndiv points for last segment
curvatureComb.indices.reserve(
ndiv + 1);// ndiv separate segments of radials + 1 segment connecting at comb end
auto zInfoH = ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider) * drawingParameters.zInfo;
auto zInfoH = ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider)
* drawingParameters.zInfo;
for (int i = 0; i < ndiv; i++) {
// note emplace emplaces on the position BEFORE the iterator given.
curvatureComb.coordinates.emplace_back(pointatcurvelist[i].x, pointatcurvelist[i].y, zInfoH); // radials
curvatureComb.coordinates.emplace_back(pointatcomblist[i].x, pointatcomblist[i].y, zInfoH); // radials
curvatureComb.coordinates.emplace_back(
pointatcurvelist[i].x, pointatcurvelist[i].y, zInfoH);// radials
curvatureComb.coordinates.emplace_back(
pointatcomblist[i].x, pointatcomblist[i].y, zInfoH);// radials
curvatureComb.indices.emplace_back(2); // line
curvatureComb.indices.emplace_back(2);// line
}
for (int i = 0; i < ndiv; i++)
curvatureComb.coordinates.emplace_back(pointatcomblist[i].x, pointatcomblist[i].y, zInfoH); // // comb endpoint closing segment
curvatureComb.coordinates.emplace_back(pointatcomblist[i].x,
pointatcomblist[i].y,
zInfoH);// // comb endpoint closing segment
curvatureComb.indices.emplace_back(ndiv); // Comb line
curvatureComb.indices.emplace_back(ndiv);// Comb line
}
else if constexpr (calculation == CalculationType::BSplineKnotMultiplicity ) {
else if constexpr (calculation == CalculationType::BSplineKnotMultiplicity) {
clearCalculation(knotMultiplicity);
std::vector<double> knots = spline->getKnots();
std::vector<int> mult = spline->getMultiplicities();
for (size_t i=0; i<knots.size(); i++) {
for (size_t i = 0; i < knots.size(); i++) {
knotMultiplicity.positions.emplace_back(spline->pointAtParameter(knots[i]));
std::ostringstream stringStream;
stringStream << "(" << mult[i] << ")";
knotMultiplicity.strings.emplace_back( stringStream.str());
knotMultiplicity.strings.emplace_back(stringStream.str());
}
}
else if constexpr (calculation == CalculationType::BSplinePoleWeight ) {
else if constexpr (calculation == CalculationType::BSplinePoleWeight) {
clearCalculation(poleWeights);
std::vector<Base::Vector3d> poles = spline->getPoles();
auto weights = spline->getWeights();
for (size_t i=0; i<poles.size(); i++) {
for (size_t i = 0; i < poles.size(); i++) {
poleWeights.positions.emplace_back(poles[i]);
QString WeightString = QString::fromLatin1("[%1]").arg(weights[i], 0, 'f', Base::UnitsApi::getDecimals());
QString WeightString = QString::fromLatin1("[%1]").arg(
weights[i], 0, 'f', Base::UnitsApi::getDecimals());
poleWeights.strings.emplace_back(WeightString.toStdString());
}
@@ -269,8 +293,9 @@ void EditModeInformationOverlayCoinConverter::calculate(const Part::Geometry * g
}
}
template <typename Result>
void EditModeInformationOverlayCoinConverter::addUpdateNode(const Result & result) {
template<typename Result>
void EditModeInformationOverlayCoinConverter::addUpdateNode(const Result& result)
{
if (overlayParameters.rebuildInformationLayer)
addNode(result);
@@ -278,40 +303,46 @@ void EditModeInformationOverlayCoinConverter::addUpdateNode(const Result & resul
updateNode(result);
}
template < EditModeInformationOverlayCoinConverter::CalculationType calculation >
bool EditModeInformationOverlayCoinConverter::isVisible() {
if constexpr ( calculation == CalculationType::BSplineDegree ) {
template<EditModeInformationOverlayCoinConverter::CalculationType calculation>
bool EditModeInformationOverlayCoinConverter::isVisible()
{
if constexpr (calculation == CalculationType::BSplineDegree) {
return overlayParameters.bSplineDegreeVisible;
}
else if constexpr ( calculation == CalculationType::BSplineControlPolygon ) {
else if constexpr (calculation == CalculationType::BSplineControlPolygon) {
return overlayParameters.bSplineControlPolygonVisible;
}
else if constexpr ( calculation == CalculationType::BSplineCurvatureComb ) {
else if constexpr (calculation == CalculationType::BSplineCurvatureComb) {
return overlayParameters.bSplineCombVisible;
}
else if constexpr ( calculation == CalculationType::BSplineKnotMultiplicity ) {
else if constexpr (calculation == CalculationType::BSplineKnotMultiplicity) {
return overlayParameters.bSplineKnotMultiplicityVisible;
}
else if constexpr ( calculation == CalculationType::BSplinePoleWeight ) {
else if constexpr (calculation == CalculationType::BSplinePoleWeight) {
return overlayParameters.bSplinePoleWeightVisible;
}
else if constexpr ( calculation == CalculationType::ArcCircleHelper ) {
else if constexpr (calculation == CalculationType::ArcCircleHelper) {
return overlayParameters.arcCircleHelperVisible;
}
}
template < typename Result >
void EditModeInformationOverlayCoinConverter::setPolygon(const Result & result, SoLineSet *polygonlineset, SoCoordinate3 *polygoncoords) {
template<typename Result>
void EditModeInformationOverlayCoinConverter::setPolygon(const Result& result,
SoLineSet* polygonlineset,
SoCoordinate3* polygoncoords)
{
polygoncoords->point.setNum(result.coordinates.size());
polygonlineset->numVertices.setNum(result.indices.size());
int32_t *index = polygonlineset->numVertices.startEditing();
SbVec3f *vts = polygoncoords->point.startEditing();
int32_t* index = polygonlineset->numVertices.startEditing();
SbVec3f* vts = polygoncoords->point.startEditing();
for (size_t i = 0; i < result.coordinates.size(); i++)
vts[i].setValue(result.coordinates[i].x, result.coordinates[i].y,
ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider) * drawingParameters.zInfo);
vts[i].setValue(result.coordinates[i].x,
result.coordinates[i].y,
ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider)
* drawingParameters.zInfo);
for (size_t i = 0; i < result.indices.size(); i++)
index[i] = result.indices[i];
@@ -320,8 +351,9 @@ void EditModeInformationOverlayCoinConverter::setPolygon(const Result & result,
polygonlineset->numVertices.finishEditing();
}
template < int line >
void EditModeInformationOverlayCoinConverter::setText(const std::string & string, SoText2 * text) {
template<int line>
void EditModeInformationOverlayCoinConverter::setText(const std::string& string, SoText2* text)
{
if constexpr (line == 1) {
text->string = SbString(string.c_str());
@@ -329,65 +361,72 @@ void EditModeInformationOverlayCoinConverter::setText(const std::string & string
else {
assert(line > 1);
SoMFString label;
for ( int l = 0; l < (line - 1) ; l++)
for (int l = 0; l < (line - 1); l++)
label.set1Value(l, SbString(""));
label.set1Value(line-1, SbString(string.c_str()));
label.set1Value(line - 1, SbString(string.c_str()));
text->string = label;
}
}
template < typename Result >
void EditModeInformationOverlayCoinConverter::clearCalculation(Result & result) {
if constexpr (Result::visualisationType == VisualisationType::Text) {
template<typename Result>
void EditModeInformationOverlayCoinConverter::clearCalculation(Result& result)
{
if constexpr (Result::visualisationType == VisualisationType::Text) {
result.positions.clear();
result.strings.clear();
}
else if constexpr (Result::visualisationType == VisualisationType::Polygon) {
}
else if constexpr (Result::visualisationType == VisualisationType::Polygon) {
result.coordinates.clear();
result.indices.clear();
}
}
}
template < typename Result>
void EditModeInformationOverlayCoinConverter::addNode(const Result & result) {
template<typename Result>
void EditModeInformationOverlayCoinConverter::addNode(const Result& result)
{
if constexpr (Result::visualisationType == VisualisationType::Text) {
for(size_t i = 0; i < result.strings.size(); i++) {
for (size_t i = 0; i < result.strings.size(); i++) {
SoSwitch *sw = new SoSwitch();
SoSwitch* sw = new SoSwitch();
sw->whichChild = isVisible<Result::calculationType>()?SO_SWITCH_ALL:SO_SWITCH_NONE;
sw->whichChild = isVisible<Result::calculationType>() ? SO_SWITCH_ALL : SO_SWITCH_NONE;
SoSeparator *sep = new SoSeparator();
SoSeparator* sep = new SoSeparator();
sep->ref();
// no caching for frequently-changing data structures
sep->renderCaching = SoSeparator::OFF;
// every information visual node gets its own material for to-be-implemented preselection and selection
SoMaterial *mat = new SoMaterial;
// every information visual node gets its own material for to-be-implemented
// preselection and selection
SoMaterial* mat = new SoMaterial;
mat->ref();
mat->diffuseColor = drawingParameters.InformationColor;
SoTranslation *translate = new SoTranslation;
SoTranslation* translate = new SoTranslation;
translate->translation.setValue(result.positions[i].x, result.positions[i].y,
ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider) * drawingParameters.zInfo);
translate->translation.setValue(
result.positions[i].x,
result.positions[i].y,
ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider)
* drawingParameters.zInfo);
SoFont *font = new SoFont;
SoFont* font = new SoFont;
font->name.setValue("Helvetica");
font->size.setValue(drawingParameters.coinFontSize);
SoText2 *text = new SoText2;
SoText2* text = new SoText2;
// since the first and last control point of a spline is also treated as knot and thus
// can also have a displayed multiplicity, we must assure the multiplicity is not visibly overwritten
// therefore be output the weight in a second line
// can also have a displayed multiplicity, we must assure the multiplicity is not
// visibly overwritten therefore be output the weight in a second line
//
// This could be made into a more generic form, but it is probably not worth the effort at this time.
if constexpr ( Result::calculationType == CalculationType::BSplinePoleWeight )
// This could be made into a more generic form, but it is probably not worth the effort
// at this time.
if constexpr (Result::calculationType == CalculationType::BSplinePoleWeight)
setText<2>(result.strings[i], text);
else
setText(result.strings[i], text);
@@ -406,23 +445,24 @@ void EditModeInformationOverlayCoinConverter::addNode(const Result & result) {
}
else if constexpr (Result::visualisationType == VisualisationType::Polygon) {
SoSwitch *sw = new SoSwitch();
SoSwitch* sw = new SoSwitch();
// hGrpsk->GetBool("BSplineControlPolygonVisible", true)
sw->whichChild = isVisible<Result::calculationType>()?SO_SWITCH_ALL:SO_SWITCH_NONE;
sw->whichChild = isVisible<Result::calculationType>() ? SO_SWITCH_ALL : SO_SWITCH_NONE;
SoSeparator *sep = new SoSeparator();
SoSeparator* sep = new SoSeparator();
sep->ref();
// no caching for frequently-changing data structures
sep->renderCaching = SoSeparator::OFF;
// every information visual node gets its own material for to-be-implemented preselection and selection
SoMaterial *mat = new SoMaterial;
// every information visual node gets its own material for to-be-implemented preselection
// and selection
SoMaterial* mat = new SoMaterial;
mat->ref();
mat->diffuseColor = drawingParameters.InformationColor;
SoLineSet *polygonlineset = new SoLineSet;
SoCoordinate3 *polygoncoords = new SoCoordinate3;
SoLineSet* polygonlineset = new SoLineSet;
SoCoordinate3* polygoncoords = new SoCoordinate3;
setPolygon<Result>(result, polygonlineset, polygoncoords);
@@ -438,47 +478,61 @@ void EditModeInformationOverlayCoinConverter::addNode(const Result & result) {
}
}
template < typename Result >
void EditModeInformationOverlayCoinConverter::updateNode(const Result & result) {
template<typename Result>
void EditModeInformationOverlayCoinConverter::updateNode(const Result& result)
{
if constexpr (Result::visualisationType == VisualisationType::Text ) {
if constexpr (Result::visualisationType == VisualisationType::Text) {
for(size_t i = 0; i < result.strings.size(); i++) {
SoSwitch *sw = static_cast<SoSwitch *>(infoGroup->getChild(nodeId));
for (size_t i = 0; i < result.strings.size(); i++) {
SoSwitch* sw = static_cast<SoSwitch*>(infoGroup->getChild(nodeId));
if (overlayParameters.visibleInformationChanged)
sw->whichChild = isVisible<Result::calculationType>()?SO_SWITCH_ALL:SO_SWITCH_NONE;
sw->whichChild =
isVisible<Result::calculationType>() ? SO_SWITCH_ALL : SO_SWITCH_NONE;
SoSeparator *sep = static_cast<SoSeparator *>(sw->getChild(0));
SoSeparator* sep = static_cast<SoSeparator*>(sw->getChild(0));
static_cast<SoTranslation *>(sep->getChild(static_cast<int>(TextNodePosition::TextCoordinates)))->translation.setValue(result.positions[i].x, result.positions[i].y, ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider) * drawingParameters.zInfo);
static_cast<SoTranslation*>(
sep->getChild(static_cast<int>(TextNodePosition::TextCoordinates)))
->translation.setValue(
result.positions[i].x,
result.positions[i].y,
ViewProviderSketchCoinAttorney::getViewOrientationFactor(viewProvider)
* drawingParameters.zInfo);
// since the first and last control point of a spline is also treated as knot and thus
// can also have a displayed multiplicity, we must assure the multiplicity is not visibly overwritten
// therefore be output the weight in a second line
// can also have a displayed multiplicity, we must assure the multiplicity is not
// visibly overwritten therefore be output the weight in a second line
//
// This could be made into a more generic form, but it is probably not worth the effort at this time.
if constexpr ( Result::calculationType == CalculationType::BSplinePoleWeight )
setText<2>(result.strings[i], static_cast<SoText2 *>(sep->getChild(static_cast<int>(TextNodePosition::TextInformation))));
// This could be made into a more generic form, but it is probably not worth the effort
// at this time.
if constexpr (Result::calculationType == CalculationType::BSplinePoleWeight)
setText<2>(result.strings[i],
static_cast<SoText2*>(
sep->getChild(static_cast<int>(TextNodePosition::TextInformation))));
else
setText(result.strings[i], static_cast<SoText2 *>(sep->getChild(static_cast<int>(TextNodePosition::TextInformation))));
setText(result.strings[i],
static_cast<SoText2*>(
sep->getChild(static_cast<int>(TextNodePosition::TextInformation))));
nodeId++;
}
}
else if constexpr (Result::visualisationType == VisualisationType::Polygon) {
SoSwitch *sw = static_cast<SoSwitch *>(infoGroup->getChild(nodeId));
SoSwitch* sw = static_cast<SoSwitch*>(infoGroup->getChild(nodeId));
if(overlayParameters.visibleInformationChanged)
sw->whichChild = isVisible<Result::calculationType>()?SO_SWITCH_ALL:SO_SWITCH_NONE;
if (overlayParameters.visibleInformationChanged)
sw->whichChild = isVisible<Result::calculationType>() ? SO_SWITCH_ALL : SO_SWITCH_NONE;
SoSeparator *sep = static_cast<SoSeparator *>(sw->getChild(0));
SoSeparator* sep = static_cast<SoSeparator*>(sw->getChild(0));
SoCoordinate3 *polygoncoords = static_cast<SoCoordinate3 *>(sep->getChild(static_cast<int>(PolygonNodePosition::PolygonCoordinates)));
SoCoordinate3* polygoncoords = static_cast<SoCoordinate3*>(
sep->getChild(static_cast<int>(PolygonNodePosition::PolygonCoordinates)));
SoLineSet *polygonlineset = static_cast<SoLineSet *>(sep->getChild(static_cast<int>(PolygonNodePosition::PolygonLineSet)));
SoLineSet* polygonlineset = static_cast<SoLineSet*>(
sep->getChild(static_cast<int>(PolygonNodePosition::PolygonLineSet)));
setPolygon(result, polygonlineset, polygoncoords);