/***************************************************************************
 *   Copyright (c) 2013 Luke Parry <l.parry@warwick.ac.uk>                 *
 *                 2022 WandererFan <wandererfan@gmail.com>                *
 *                                                                         *
 *   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 <limits>
#include <sstream>

#include <QLocale>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QString>
#include <QStringList>

#include <BRepGProp.hxx>
#include <GProp_GProps.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepExtrema_DistShapeShape.hxx>
#include <BRepLProp_CLProps.hxx>
#include <GeomAPI_ExtremaCurveCurve.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Geom_Plane.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2dAPI_ProjectPointOnCurve.hxx>
#include <ShapeAnalysis.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Shape.hxx>
#endif

#include <App/Application.h>
#include <App/Document.h>
#include <Base/Console.h>
#include <Base/Converter.h>
#include <Base/Parameter.h>
#include <Base/Quantity.h>
#include <Base/Tools.h>
#include <Base/UnitsApi.h>

#include <Mod/Measure/App/Measurement.h>
#include <Mod/Part/App/Geometry.h>
#include <Mod/Part/App/TopoShape.h>

#include <Mod/TechDraw/App/DrawViewDimensionPy.h>  // generated from DrawViewDimensionPy.xml

#include "DrawViewDimension.h"
#include "DimensionFormatter.h"
#include "DrawUtil.h"
#include "DrawViewPart.h"
#include "Geometry.h"
#include "GeometryMatcher.h"
#include "Preferences.h"
#include "DimensionAutoCorrect.h"
#include "DrawBrokenView.h"

using namespace TechDraw;
using namespace Part;
using DU = DrawUtil;
using RefType = DrawViewDimension::RefType;

//===========================================================================
// DrawViewDimension
//===========================================================================

PROPERTY_SOURCE(TechDraw::DrawViewDimension, TechDraw::DrawView)

const char* DrawViewDimension::TypeEnums[] = {"Distance",
                                              "DistanceX",
                                              "DistanceY",
                                              "DistanceZ",
                                              "Radius",
                                              "Diameter",
                                              "Angle",
                                              "Angle3Pt",
                                              "Area",
                                              nullptr};

const char* DrawViewDimension::MeasureTypeEnums[] = {"True", "Projected", nullptr};

// constraint to set the step size to 0.1
static const App::PropertyQuantityConstraint::Constraints ToleranceConstraint = {
    -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 0.1};
// constraint to force positive values
static const App::PropertyQuantityConstraint::Constraints PositiveConstraint = {
    0.0, std::numeric_limits<double>::max(), 0.1};

DrawViewDimension::DrawViewDimension()
{
    // create the formatter since it will be needed to set default property values
    m_formatter = new DimensionFormatter(this);

    ADD_PROPERTY_TYPE(References2D,
                      (nullptr, nullptr),
                      "",
                      (App::Prop_None),
                      "Projected Geometry References");
    References2D.setScope(App::LinkScope::Global);
    ADD_PROPERTY_TYPE(References3D,
                      (nullptr, nullptr),
                      "",
                      (App::Prop_None),
                      "3D Geometry References");
    References3D.setScope(App::LinkScope::Global);

    ADD_PROPERTY_TYPE(FormatSpec,
                      (getDefaultFormatSpec()),
                      "Format",
                      App::Prop_Output,
                      "Dimension format");
    ADD_PROPERTY_TYPE(FormatSpecOverTolerance,
                      (getDefaultFormatSpec(true)),
                      "Format",
                      App::Prop_Output,
                      "Dimension overtolerance format");
    ADD_PROPERTY_TYPE(FormatSpecUnderTolerance,
                      (getDefaultFormatSpec(true)),
                      "Format",
                      App::Prop_Output,
                      "Dimension undertolerance format");
    ADD_PROPERTY_TYPE(Arbitrary, (false), "Format", App::Prop_Output, "Value overridden by user");
    ADD_PROPERTY_TYPE(ArbitraryTolerances,
                      (false),
                      "Format",
                      App::Prop_Output,
                      "Tolerance values overridden by user");

    Type.setEnums(TypeEnums);  // dimension type: length, radius etc
    ADD_PROPERTY(Type, ((long)0));
    MeasureType.setEnums(MeasureTypeEnums);
    ADD_PROPERTY(MeasureType, ((long)1));  // Projected (or True) measurement
    ADD_PROPERTY_TYPE(TheoreticalExact,
                      (false),
                      "",
                      App::Prop_Output,
                      "If theoretical exact (basic) dimension");
    ADD_PROPERTY_TYPE(EqualTolerance,
                      (true),
                      "",
                      App::Prop_Output,
                      "If over- and undertolerance are equal");

    ADD_PROPERTY_TYPE(OverTolerance,
                      (0.0),
                      "",
                      App::Prop_Output,
                      "Overtolerance value\nIf 'Equal Tolerance' is true this is also\nthe negated "
                      "value for 'Under Tolerance'");
    OverTolerance.setUnit(Base::Unit::Length);
    OverTolerance.setConstraints(&ToleranceConstraint);
    ADD_PROPERTY_TYPE(UnderTolerance,
                      (0.0),
                      "",
                      App::Prop_Output,
                      "Undertolerance value\nIf 'Equal Tolerance' is true it will be replaced\nby "
                      "negative value of 'Over Tolerance'");
    UnderTolerance.setUnit(Base::Unit::Length);
    UnderTolerance.setConstraints(&ToleranceConstraint);
    ADD_PROPERTY_TYPE(Inverted,
                      (false),
                      "",
                      App::Prop_Output,
                      "The dimensional value is displayed inverted");

    ADD_PROPERTY_TYPE(AngleOverride,
                      (false),
                      "Override",
                      App::Prop_Output,
                      "User specified angles");
    ADD_PROPERTY_TYPE(LineAngle, (0.0), "Override", App::Prop_Output, "Dimension line angle");
    ADD_PROPERTY_TYPE(ExtensionAngle, (0.0), "Override", App::Prop_Output, "Extension line angle");

    ADD_PROPERTY_TYPE(SavedGeometry,
                      (),
                      "References",
                      (App::PropertyType)(App::Prop_None),
                      "Reference Geometry");
    SavedGeometry.setOrderRelevant(true);

    ADD_PROPERTY_TYPE(
        BoxCorners,
        (),
        "References",
        (App::Prop_None),
        "Feature bounding box corners as of last reference update.  Used by autocorrect");

    // changing the references in the property editor will only cause problems
    References2D.setStatus(App::Property::ReadOnly, true);
    References3D.setStatus(App::Property::ReadOnly, true);

    // hide the DrawView properties that don't apply to Dimensions
    ScaleType.setStatus(App::Property::ReadOnly, true);
    ScaleType.setStatus(App::Property::Hidden, true);
    Scale.setStatus(App::Property::ReadOnly, true);
    Scale.setStatus(App::Property::Hidden, true);
    Rotation.setStatus(App::Property::ReadOnly, true);
    Rotation.setStatus(App::Property::Hidden, true);
    Caption.setStatus(App::Property::Hidden, true);
    LockPosition.setStatus(App::Property::Hidden, true);

    // by default EqualTolerance is true, thus make UnderTolerance read-only
    UnderTolerance.setStatus(App::Property::ReadOnly, true);
    FormatSpecUnderTolerance.setStatus(App::Property::ReadOnly, true);

    // legacy behaviour if this is false
    ADD_PROPERTY_TYPE(UseActualArea, (true), "Area", App::Prop_Output,
                      "If true, area dimensions return the area of the face minus the areas of any enclosed faces. \
                       If false, the area of the face's outer boundary is returned.");

    ADD_PROPERTY_TYPE(ShowUnits, (Preferences::showUnits()), "Format", App::Prop_None,
                                          "Show or hide the units.");
    measurement = new Measure::Measurement();
    // TODO: should have better initial datumLabel position than (0, 0) in the DVP?? something
    // closer to the object being measured?

    // initialize the descriptive geometry.
    // TODO: should this be more like DVP with a "geometry object"?
    resetLinear();
    resetAngular();
    resetArc();
    m_hasGeometry = false;
    m_matcher = new GeometryMatcher();
    m_referencesCorrect = true;
    m_corrector = new DimensionAutoCorrect(this);
}

DrawViewDimension::~DrawViewDimension()
{
    delete measurement;
    measurement = nullptr;
    delete m_formatter;
    delete m_matcher;
    delete m_corrector;
}

void DrawViewDimension::resetLinear()
{
    m_linearPoints.first(Base::Vector3d(0, 0, 0));
    m_linearPoints.second(Base::Vector3d(0, 0, 0));
}

void DrawViewDimension::resetAngular()
{
    m_anglePoints.first(Base::Vector3d(0, 0, 0));
    m_anglePoints.second(Base::Vector3d(0, 0, 0));
    m_anglePoints.vertex(Base::Vector3d(0, 0, 0));
}

void DrawViewDimension::resetArc()
{
    m_arcPoints.isArc = false;
    m_arcPoints.center = Base::Vector3d(0, 0, 0);
    m_arcPoints.onCurve.first(Base::Vector3d(0, 0, 0));
    m_arcPoints.onCurve.second(Base::Vector3d(0, 0, 0));
    m_arcPoints.arcEnds.first(Base::Vector3d(0, 0, 0));
    m_arcPoints.arcEnds.second(Base::Vector3d(0, 0, 0));
    m_arcPoints.midArc = Base::Vector3d(0, 0, 0);
    m_arcPoints.arcCW = false;
}

void DrawViewDimension::resetArea()
{
    m_areaPoint.center = Base::Vector3d(0, 0, 0);
    m_areaPoint.area = 0.0;
    m_areaPoint.actualArea = 0.0;
}

void DrawViewDimension::onChanged(const App::Property* prop)
{
    if (prop == &References3D) {
        // have to rebuild the Measurement object
        clear3DMeasurements();  // Measurement object
        if (!(References3D.getValues()).empty()) {
            setAll3DMeasurement();
        }
    }

    if (isRestoring()) {
        DrawView::onChanged(prop);
        return;
    }

    if (prop == &References2D) {
        updateSavedGeometry();
    }
    else if (prop == &References3D) {
        // remove the old measurement object
        clear3DMeasurements();
        if (!(References3D.getValues()).empty()) {
            // rebuild the Measurement object
            setAll3DMeasurement();
        }
        else if (MeasureType.isValue("True")) {  // empty 3dRefs, but True
            MeasureType.touch();                 // run MeasureType logic for this case
        }
        updateSavedGeometry();
    }
    else if (prop == &Type) {
        FormatSpec.setValue(getDefaultFormatSpec().c_str());
        auto type = static_cast<DimensionType>(Type.getValue());
        if (type == DimensionType::Angle || type == DimensionType::Angle3Pt) {
            OverTolerance.setUnit(Base::Unit::Angle);
            UnderTolerance.setUnit(Base::Unit::Angle);
        }
        else {
            OverTolerance.setUnit(Base::Unit::Length);
            UnderTolerance.setUnit(Base::Unit::Length);
        }
    }
    else if (prop == &TheoreticalExact) {
        // if TheoreticalExact disable tolerances and set them to zero
        if (TheoreticalExact.getValue()) {
            OverTolerance.setValue(0.0);
            UnderTolerance.setValue(0.0);
            OverTolerance.setReadOnly(true);
            UnderTolerance.setReadOnly(true);
            FormatSpecOverTolerance.setReadOnly(true);
            FormatSpecUnderTolerance.setReadOnly(true);
            ArbitraryTolerances.setValue(false);
            ArbitraryTolerances.setReadOnly(true);
        }
        else {
            OverTolerance.setReadOnly(false);
            FormatSpecOverTolerance.setReadOnly(false);
            ArbitraryTolerances.setReadOnly(false);
            if (!EqualTolerance.getValue()) {
                UnderTolerance.setReadOnly(false);
                FormatSpecUnderTolerance.setReadOnly(false);
            }
        }
    }
    else if (prop == &EqualTolerance) {
        // if EqualTolerance set negated overtolerance for untertolerance
        // then also the OverTolerance must be positive
        if (EqualTolerance.getValue()) {
            // if OverTolerance is negative or zero, first set it to zero
            if (OverTolerance.getValue() < 0) {
                OverTolerance.setValue(0.0);
            }
            OverTolerance.setConstraints(&PositiveConstraint);
            UnderTolerance.setValue(-1.0 * OverTolerance.getValue());
            UnderTolerance.setUnit(OverTolerance.getUnit());
            UnderTolerance.setReadOnly(true);
            FormatSpecUnderTolerance.setValue(FormatSpecOverTolerance.getValue());
            FormatSpecUnderTolerance.setReadOnly(true);
        }
        else {
            OverTolerance.setConstraints(&ToleranceConstraint);
            if (!TheoreticalExact.getValue()) {
                UnderTolerance.setReadOnly(false);
                FormatSpecUnderTolerance.setReadOnly(false);
            }
        }
    }
    else if (prop == &OverTolerance) {
        // if EqualTolerance set negated overtolerance for untertolerance
        if (EqualTolerance.getValue()) {
            UnderTolerance.setValue(-1.0 * OverTolerance.getValue());
            UnderTolerance.setUnit(OverTolerance.getUnit());
        }
    }
    else if (prop == &FormatSpecOverTolerance) {
        if (EqualTolerance.getValue() && !ArbitraryTolerances.getValue()) {
            FormatSpecUnderTolerance.setValue(FormatSpecOverTolerance.getValue());
        }
    }
    else if (prop == &FormatSpecUnderTolerance) {
        if (EqualTolerance.getValue() && !ArbitraryTolerances.getValue()) {
            FormatSpecOverTolerance.setValue(FormatSpecUnderTolerance.getValue());
        }
    }

    DrawView::onChanged(prop);
}

void DrawViewDimension::Restore(Base::XMLReader& reader)
// Old drawings did not have the equal tolerance options.
// We cannot just introduce it as being set to true because that would e.g. destroy tolerances like
// +1-2 Therefore set it to false for existing documents
{
    EqualTolerance.setValue(false);
    DrawView::Restore(reader);
}

void DrawViewDimension::onDocumentRestored()
{
    if (has3DReferences()) {
        setAll3DMeasurement();
    }

    auto type = static_cast<DimensionType>(Type.getValue());
    if (type == DimensionType::Angle || type == DimensionType::Angle3Pt) {
        OverTolerance.setUnit(Base::Unit::Angle);
        UnderTolerance.setUnit(Base::Unit::Angle);
    }
}

void DrawViewDimension::handleChangedPropertyType(Base::XMLReader& reader,
                                                  const char* TypeName,
                                                  App::Property* prop)
{
    if (prop == &OverTolerance && strcmp(TypeName, "App::PropertyFloat") == 0) {
        App::PropertyFloat value;
        value.Restore(reader);
        OverTolerance.setValue(value.getValue());
    }
    else if (prop == &UnderTolerance && strcmp(TypeName, "App::PropertyFloat") == 0) {
        App::PropertyFloat value;
        value.Restore(reader);
        UnderTolerance.setValue(value.getValue());
    }
    else {
        TechDraw::DrawView::handleChangedPropertyType(reader, TypeName, prop);
    }

    // Over/Undertolerance were further changed from App::PropertyQuantity to
    // App::PropertyQuantityConstraint
    if (prop == &OverTolerance && strcmp(TypeName, "App::PropertyQuantity") == 0) {
        App::PropertyQuantity OverToleranceProperty;
        // restore the PropertyQuantity to be able to set its value
        OverToleranceProperty.Restore(reader);
        OverTolerance.setValue(OverToleranceProperty.getValue());
    }
    else if (prop == &UnderTolerance && strcmp(TypeName, "App::PropertyQuantity") == 0) {
        App::PropertyQuantity UnderToleranceProperty;
        // restore the PropertyQuantity to be able to set its value
        UnderToleranceProperty.Restore(reader);
        UnderTolerance.setValue(UnderToleranceProperty.getValue());
    }
}

short DrawViewDimension::mustExecute() const
{
    if (!isRestoring()) {
        if (References2D.isTouched() || References3D.isTouched() || Type.isTouched()) {
            return 1;
        }
    }

    return DrawView::mustExecute();
}

App::DocumentObjectExecReturn* DrawViewDimension::execute()
{
    if (!okToProceed()) {
        // if we set an error here, it will be triggered many times during
        // document load.
        return  DrawView::execute();
    }

    m_referencesCorrect = true;
    if (Preferences::autoCorrectDimRefs()) {
        m_referencesCorrect = autocorrectReferences();
    }
    if (!m_referencesCorrect) {
        // this test needs Phase 2 of auto correct to be useful
        Base::Console().Log("The references for %s have changed and autocorrect could not match the geometry\n", Label.getValue());
    }

    resetLinear();
    resetAngular();
    resetArc();
    resetArea();

    // we have either or both valid References3D and References2D
    ReferenceVector references = getEffectiveReferences();

    if (Type.isValue("Distance") || Type.isValue("DistanceX") || Type.isValue("DistanceY")) {
        if (getRefType() == RefType::oneEdge) {
            m_linearPoints = getPointsOneEdge(references);
        }
        else if (getRefType() == RefType::twoEdge) {
            m_linearPoints = getPointsTwoEdges(references);
        }
        else if (getRefType() == RefType::twoVertex) {
            m_linearPoints = getPointsTwoVerts(references);
        }
        else if (getRefType() == RefType::vertexEdge) {
            m_linearPoints = getPointsEdgeVert(references);
        }
        m_hasGeometry = true;
    }
    else if (Type.isValue("Radius") ||
             Type.isValue("Diameter") ) {
        m_arcPoints = getArcParameters(references);
        m_hasGeometry = true;
    }
    else if (Type.isValue("Angle")) {
        if (getRefType() != RefType::twoEdge) {
            throw Base::RuntimeError("Angle dimension has non-edge references");
        }
        m_anglePoints = getAnglePointsTwoEdges(references);
        m_hasGeometry = true;
    }
    else if (Type.isValue("Angle3Pt")) {
        if (getRefType() != RefType::threeVertex) {
            throw Base::RuntimeError("3 point angle dimension has non-vertex references");
        }
        m_anglePoints = getAnglePointsThreeVerts(references);
        m_hasGeometry = true;
    }
    else if (Type.isValue("Area")) {
        if (getRefType() != RefType::oneFace) {
            throw Base::RuntimeError("area dimension has non-face references");
        }
        m_areaPoint = getAreaParameters(references);
        m_hasGeometry = true;
    }

    overrideKeepUpdated(false);
    return DrawView::execute();
}

// true if we have enough information to execute, false otherwise
bool DrawViewDimension::okToProceed()
{
    if (!keepUpdated()) {
        return false;
    }
    DrawViewPart* dvp = getViewPart();
    if (!dvp) {
        // TODO: translate these messages and figure out how to present them to
        // the user since we can't pop up a message box here.
        // this case is probably temporary during restore
        // Base::Console().Message("DVD::okToProceed - no view for dimension\n");
        return false;
    }

    if (!(has2DReferences() || has3DReferences())) {
        // no references, can't do anything
        // Base::Console().Message("DVD::okToProceed - Dimension object has no valid references\n");
        return false;
    }

    if (!getViewPart()->hasGeometry()) {
        // can't do anything until Source has geometry
        // Base::Console().Message("DVD::okToProceed - Dimension object has no geometry\n");
        return false;
    }

    // is this check still relevant or is it replaced by the autocorrect and
    // validate methods?
    if (References3D.getValues().empty() && !checkReferences2D()) {
        // Base::Console().Warning("%s has invalid 2D References\n", getNameInDocument());
        return false;
    }
    return validateReferenceForm();
}

//! check if geometry pointed to by references matches the saved version. If
//! everything matches, we don't need to correct anything.
bool DrawViewDimension::autocorrectReferences()
{
    // TODO: check for saved geometry here.  If we don't have saved geometry, we can't
    // successfully auto correct in phase 1.  This check is currently in
    // referencesHaveValidGeometry.
    std::vector<bool> referenceState;
    bool refsAreValid = m_corrector->referencesHaveValidGeometry(referenceState);
    if (!refsAreValid) {
        m_corrector->set3dObjectCache(m_3dObjectCache);
        ReferenceVector repairedRefs;
        refsAreValid = m_corrector->autocorrectReferences(referenceState, repairedRefs);
        if (!refsAreValid) {
            // references are broken and we can not fix them
            return false;

        }
        if (repairedRefs.front().is3d()) {
            setReferences3d(repairedRefs);
        }
        else {
            setReferences2d(repairedRefs);
        }
    }
    return true;
}

bool DrawViewDimension::isMultiValueSchema() const
{
    return m_formatter->isMultiValueSchema();
}

std::string
DrawViewDimension::formatValue(qreal value, QString qFormatSpec, DimensionFormatter::Format partial, bool isDim)
{
    return m_formatter->formatValue(value, qFormatSpec, partial, isDim);
}

bool DrawViewDimension::haveTolerance()
{
    // if a numeric tolerance is specified AND
    // tolerances are NOT arbitrary
    if ((!DrawUtil::fpCompare(OverTolerance.getValue(), 0.0)
         || !DrawUtil::fpCompare(UnderTolerance.getValue(), 0.0))
        && !ArbitraryTolerances.getValue()) {
        return true;
    }
    return false;
}

std::string DrawViewDimension::getFormattedToleranceValue(DimensionFormatter::Format partial)
{
    return m_formatter->getFormattedToleranceValue(partial);
}

////get over and under tolerances
std::pair<std::string, std::string> DrawViewDimension::getFormattedToleranceValues(DimensionFormatter::Format partial)
{
    return m_formatter->getFormattedToleranceValues(partial);
}

////partial = 2 unit only
std::string DrawViewDimension::getFormattedDimensionValue(DimensionFormatter::Format partial)
{
    return m_formatter->getFormattedDimensionValue(partial);
}

QStringList DrawViewDimension::getPrefixSuffixSpec(const QString &fSpec)
{
    return m_formatter->getPrefixSuffixSpec(fSpec);
}

//! NOTE: this returns the Dimension value in internal units (ie mm)!!!!
double DrawViewDimension::getDimValue()
{
    constexpr double CircleDegrees{360.0};
    double result = 0.0;
    if (!has2DReferences() && !has3DReferences()) {
        // nothing to measure
        return result;
    }
    if (!getViewPart()) {
        return result;
    }

    if (!getViewPart()->hasGeometry()) {  // happens when loading saved document
        return result;
    }

    if (MeasureType.isValue("True")) {
        // True Values
        if (!measurement->has3DReferences()) {
            Base::Console().Warning("%s - True dimension has no 3D References\n",
                                    getNameInDocument());
            return result;
        }
        result = getTrueDimValue();
    }
    else {
        // Projected Values
        if (!checkReferences2D()) {
            Base::Console().Warning("DVD::getDimValue - %s - 2D references are corrupt (5)\n",
                                    getNameInDocument());
            return result;
        }
        result = getProjectedDimValue();
    }

    result = fabs(result);
    if (Inverted.getValue()) {
        if (Type.isValue("Angle") || Type.isValue("Angle3Pt")) {
            result = CircleDegrees - result;
        }
        else {
            result = -result;
        }
    }
    return result;
}

//! retrieve the dimension value for "true" dimensions. The returned value is in internal units (mm).
double DrawViewDimension::getTrueDimValue() const
{
    double result = 0.0;

    if (Type.isValue("Distance") || Type.isValue("DistanceX") || Type.isValue("DistanceY")) {
        result = measurement->length();
    }
    else if (Type.isValue("Radius")) {
        result = measurement->radius();
    }
    else if (Type.isValue("Diameter")) {
        result = 2 * measurement->radius();
    }
    else if (Type.isValue("Angle") || Type.isValue("Angle3Pt")) {
        result = measurement->angle();
    }
    else if (Type.isValue("Area")) {
        result = measurement->area();
    }
    else {  // tarfu
        throw Base::ValueError("getDimValue() - Unknown Dimension Type (3)");
    }
    return result;
}

//! retrieve the dimension value for "projected" (2d) dimensions. The returned value is in internal units (mm).
double DrawViewDimension::getProjectedDimValue() const
{
    double result = 0.0;
    double scale = getViewPart()->getScale();

    if (Type.isValue("Distance") || Type.isValue("DistanceX") || Type.isValue("DistanceY")) {
        pointPair pts = getLinearPoints();
        auto dbv = dynamic_cast<DrawBrokenView*>(getViewPart());
        if (dbv)  {
            // raw pts from view are inverted Y, so we need to un-invert them before mapping
            // raw pts are scaled, so we need to unscale them for mapPoint2dFromView
            // then rescale them for the distance calculation below
            // centers are right side up
            // if both points are on the expanded side  of the last (rightmost/upmost) break
            // then we should not move the points.
            //
            pts.invertY();
            // unscale the points, map them to the broken view then rescale them to draw.
            pts.scale(1 / scale);
            pts.first(dbv->mapPoint2dFromView(pts.first()));
            pts.second(dbv->mapPoint2dFromView(pts.second()));
            pts.invertY();
            pts.scale(scale);
        }
        Base::Vector3d dimVec = pts.first() - pts.second();
        if (Type.isValue("Distance")) {
            result = dimVec.Length() / scale;
        }
        else if (Type.isValue("DistanceX")) {
            result = fabs(dimVec.x) / scale;
        }
        else {
            result = fabs(dimVec.y) / scale;
        }
    }
    else if (Type.isValue("Radius")) {
        // Projected BaseGeom is scaled for drawing
        result = m_arcPoints.radius / scale;
    }
    else if (Type.isValue("Diameter")) {
        arcPoints pts = m_arcPoints;
        result = (pts.radius * 2.0) / scale; // Projected BaseGeom is scaled for drawing
    }
    else if (Type.isValue("Angle") || Type.isValue("Angle3Pt")) {  // same as case "Angle"?
        anglePoints pts = m_anglePoints;
        Base::Vector3d vertex = pts.vertex();
        Base::Vector3d leg0 = pts.first() - vertex;
        Base::Vector3d leg1 = pts.second() - vertex;
        double legAngle = Base::toDegrees(leg0.GetAngle(leg1));
        result = legAngle;
    }
    else if (Type.isValue("Area")) {
        // 2d reference makes scaled values in areaPoint
        // 3d reference makes actual values in areaPoint :p
        double divisor{scale / scale};
        if (has3DReferences()) {
            divisor = 1.0;
        }
        if (UseActualArea.getValue()) {
           result = m_areaPoint.actualArea / divisor;
        } else {
            result = m_areaPoint.area / divisor;
        }
    }

    return result;
}


pointPair DrawViewDimension::getLinearPoints() const
{
    Base::Vector3d stdY{0, 1, 0};
    if (Type.isValue("Distance")) {
        // if the dimVec points the wrong way on generally vertical dims, the dim text will be
        // placed on the wrong side of the dim line.
        auto dimVec = m_linearPoints.second() - m_linearPoints.first();
        dimVec.Normalize();
        auto dotY = stdY.Dot(dimVec);
        if (dotY > 0) {
            // dimVec points up (ish) so the dim text will be to right of dim line and readable from
            // left side of the page.  Dimensions should always be readable from the bottom-right, so
            // we flip the points.
            return {m_linearPoints.second(), m_linearPoints.first()};
        }
    }
    return m_linearPoints;
}

pointPair DrawViewDimension::getPointsOneEdge(ReferenceVector references)
{
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement = DrawUtil::getIndexFromName(references.front().getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // TODO: Notify if not straight line Edge?
        // this is a 2d object (a DVP + subelements)
        TechDraw::BaseGeomPtr geom = getViewPart()->getGeomByIndex(iSubelement);
        if (!geom) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " can not find geometry for 2d reference (1)";
            throw Base::RuntimeError(ssMessage.str());
        }
        if (geom->getGeomType() != GeomType::GENERIC) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " 2d reference is a " << geom->geomTypeName();
            throw Base::RuntimeError(ssMessage.str());
        }
        TechDraw::GenericPtr generic = std::static_pointer_cast<TechDraw::Generic>(geom);
        // these points are from 2d geometry, so they are scaled and rotated
        return {generic->points[0], generic->points[1]};
    }

    // this is a 3d object
    // get the endpoints of the edge in the DVP's coordinates
    TopoDS_Shape geometry = references.front().getGeometry();
    if (geometry.IsNull() || geometry.ShapeType() != TopAbs_EDGE) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }
    const TopoDS_Edge& edge = TopoDS::Edge(geometry);
    gp_Pnt gEnd0 = BRep_Tool::Pnt(TopExp::FirstVertex(edge));
    gp_Pnt gEnd1 = BRep_Tool::Pnt(TopExp::LastVertex(edge));

    pointPair pts(Base::convertTo<Base::Vector3d>(gEnd0), Base::convertTo<Base::Vector3d>(gEnd1));
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

pointPair DrawViewDimension::getPointsTwoEdges(ReferenceVector references)
{
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement0 = DrawUtil::getIndexFromName(references.at(0).getSubName());
    int iSubelement1 = DrawUtil::getIndexFromName(references.at(1).getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::BaseGeomPtr geom0 = getViewPart()->getGeomByIndex(iSubelement0);
        TechDraw::BaseGeomPtr geom1 = getViewPart()->getGeomByIndex(iSubelement1);
        if (!geom0 || !geom1) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " can not find geometry for 2d reference (2)";
            throw Base::RuntimeError(ssMessage.str());
        }
        return closestPoints(geom0->getOCCEdge(), geom1->getOCCEdge());
    }

    // this is a 3d object
    TopoDS_Shape geometry0 = references.at(0).getGeometry();
    TopoDS_Shape geometry1 = references.at(1).getGeometry();
    if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_EDGE
        || geometry1.ShapeType() != TopAbs_EDGE) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }

    pointPair pts = closestPoints(geometry0, geometry1);
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

pointPair DrawViewDimension::getPointsTwoVerts(ReferenceVector references)
{
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement0 = DrawUtil::getIndexFromName(references.at(0).getSubName());
    int iSubelement1 = DrawUtil::getIndexFromName(references.at(1).getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::VertexPtr v0 = getViewPart()->getProjVertexByIndex(iSubelement0);
        TechDraw::VertexPtr v1 = getViewPart()->getProjVertexByIndex(iSubelement1);
        if (!v0 || !v1) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " can not find geometry for 2d reference (3)";
            throw Base::RuntimeError(ssMessage.str());
        }

        return {v0->point(), v1->point()};
    }

    // this is a 3d object
    TopoDS_Shape geometry0 = references.at(0).getGeometry();
    TopoDS_Shape geometry1 = references.at(1).getGeometry();
    if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_VERTEX
        || geometry1.ShapeType() != TopAbs_VERTEX) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }
    const TopoDS_Vertex& vertex0 = TopoDS::Vertex(geometry0);
    const TopoDS_Vertex& vertex1 = TopoDS::Vertex(geometry1);
    gp_Pnt gPoint0 = BRep_Tool::Pnt(vertex0);
    gp_Pnt gPoint1 = BRep_Tool::Pnt(vertex1);

    pointPair pts(Base::convertTo<Base::Vector3d>(gPoint0), Base::convertTo<Base::Vector3d>(gPoint1));
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

pointPair DrawViewDimension::getPointsEdgeVert(ReferenceVector references)
{
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement0 = DrawUtil::getIndexFromName(references.at(0).getSubName());
    int iSubelement1 = DrawUtil::getIndexFromName(references.at(1).getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::BaseGeomPtr edge;
        TechDraw::VertexPtr vertex;
        if (DrawUtil::getGeomTypeFromName(references.at(0).getSubName()) == "Edge") {
            edge = getViewPart()->getGeomByIndex(iSubelement0);
            vertex = getViewPart()->getProjVertexByIndex(iSubelement1);
        }
        else {
            edge = getViewPart()->getGeomByIndex(iSubelement1);
            vertex = getViewPart()->getProjVertexByIndex(iSubelement0);
        }
        if (!vertex || !edge) {
            throw Base::RuntimeError("Missing geometry for dimension (4)");
        }

        // get curve from edge
        double start{0.0};  // curve parameters
        double end{0.0};  // curve parameters
        const Handle(Geom_Surface) hplane = new Geom_Plane(gp_Ax3());
        auto const occCurve =
            BRep_Tool::CurveOnPlane(edge->getOCCEdge(), hplane, TopLoc_Location(), start, end);
        auto const occPoint = gp_Pnt2d(vertex->x(), vertex->y());
        // project point on curve
        auto projector = Geom2dAPI_ProjectPointOnCurve(occPoint, occCurve);
        if (projector.NbPoints() > 0) {
            auto p1 = Base::Vector3d(vertex->x(), vertex->y(), 0.0);
            auto p2 =
                Base::Vector3d(projector.NearestPoint().X(), projector.NearestPoint().Y(), 0.0);
            pointPair result = pointPair(p1, p2);
            result.setExtensionLine(closestPoints(edge->getOCCEdge(), vertex->getOCCVertex()));
            return result;
        }
            // unable to project
            return closestPoints(edge->getOCCEdge(), vertex->getOCCVertex());
    }

    // this is a 3d object
    TopoDS_Shape geometry0 = references.at(0).getGeometry();
    TopoDS_Shape geometry1 = references.at(1).getGeometry();
    if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_VERTEX
        || geometry1.ShapeType() != TopAbs_VERTEX) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }

    pointPair pts = closestPoints(geometry0, geometry1);
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

arcPoints DrawViewDimension::getArcParameters(ReferenceVector references)
{
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement = DrawUtil::getIndexFromName(references.front().getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::BaseGeomPtr geom = getViewPart()->getGeomByIndex(iSubelement);
        if (!geom) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " can not find geometry for 2d reference (4)";
            throw Base::RuntimeError(ssMessage.str());
        }
        return arcPointsFromBaseGeom(geom);
    }

    // this is a 3d reference
    TopoDS_Shape geometry = references.front().getGeometry();
    if (geometry.IsNull() || geometry.ShapeType() != TopAbs_EDGE) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }
    const TopoDS_Edge& edge = TopoDS::Edge(geometry);
    arcPoints pts = arcPointsFromEdge(edge);
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
{
    TechDraw::CirclePtr circle;
    arcPoints pts;
    pts.center = Base::Vector3d(0.0, 0.0, 0.0);
    pts.radius = 0.0;
    if ((base && base->getGeomType() == GeomType::CIRCLE)
        || (base && base->getGeomType() == GeomType::ARCOFCIRCLE)) {
        circle = std::static_pointer_cast<TechDraw::Circle>(base);
        pts.center = Base::Vector3d(circle->center.x, circle->center.y, 0.0);
        pts.radius = circle->radius;
        if (base->getGeomType() == GeomType::ARCOFCIRCLE) {
            TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(circle);
            pts.isArc = true;
            pts.onCurve.first(Base::Vector3d(aoc->midPnt.x, aoc->midPnt.y, 0.0));
            pts.midArc = Base::Vector3d(aoc->midPnt.x, aoc->midPnt.y, 0.0);
            pts.arcEnds.first(Base::Vector3d(aoc->startPnt.x, aoc->startPnt.y, 0.0));
            pts.arcEnds.second(Base::Vector3d(aoc->endPnt.x, aoc->endPnt.y, 0.0));
            pts.arcCW = aoc->cw;
        }
        else {
            pts.isArc = false;
            pts.onCurve.first(
                pts.center + Base::Vector3d(1, 0, 0) * circle->radius);  // arbitrary point on edge
            pts.onCurve.second(
                pts.center + Base::Vector3d(-1, 0, 0) * circle->radius);  // arbitrary point on edge
        }
    }
    else if ((base && base->getGeomType() == GeomType::ELLIPSE)
             || (base && base->getGeomType() == GeomType::ARCOFELLIPSE)) {
        TechDraw::EllipsePtr ellipse = std::static_pointer_cast<TechDraw::Ellipse>(base);
        if (ellipse->closed()) {
            double r1 = ellipse->minor;
            double r2 = ellipse->major;
            double rAvg = (r1 + r2) / 2;
            pts.center = Base::Vector3d(ellipse->center.x, ellipse->center.y, 0.0);
            pts.radius = rAvg;
            pts.isArc = false;
            pts.onCurve.first(pts.center
                              + Base::Vector3d(1, 0, 0) * rAvg);  // arbitrary point on edge
            pts.onCurve.second(pts.center
                               + Base::Vector3d(-1, 0, 0) * rAvg);  // arbitrary point on edge
        }
        else {
            TechDraw::AOEPtr aoe = std::static_pointer_cast<TechDraw::AOE>(base);
            double r1 = aoe->minor;
            double r2 = aoe->major;
            double rAvg = (r1 + r2) / 2;
            pts.isArc = true;
            pts.center = Base::Vector3d(aoe->center.x, aoe->center.y, 0.0);
            pts.radius = rAvg;
            pts.arcEnds.first(Base::Vector3d(aoe->startPnt.x, aoe->startPnt.y, 0.0));
            pts.arcEnds.second(Base::Vector3d(aoe->endPnt.x, aoe->endPnt.y, 0.0));
            pts.midArc = Base::Vector3d(aoe->midPnt.x, aoe->midPnt.y, 0.0);
            pts.arcCW = aoe->cw;
            pts.onCurve.first(Base::Vector3d(aoe->midPnt.x, aoe->midPnt.y, 0.0));  // for radius
            //            pts.onCurve.first(pts.center + Base::Vector3d(1, 0,0) * rAvg);   //for
            //            diameter
            pts.onCurve.second(pts.center
                               + Base::Vector3d(-1, 0, 0) * rAvg);  // arbitrary point on edge
        }
    }
    else if (base && base->getGeomType() == GeomType::BSPLINE) {
        TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(base);
        if (spline->isCircle()) {
            bool arc{false};
            double rad{0};
            Base::Vector3d center;
            // bool circ =
            GeometryUtils::getCircleParms(spline->getOCCEdge(), rad, center, arc);
            pts.center = Base::Vector3d(center.x, center.y, 0.0);
            pts.radius = rad;
            pts.arcEnds.first(Base::Vector3d(spline->startPnt.x, spline->startPnt.y, 0.0));
            pts.arcEnds.second(Base::Vector3d(spline->endPnt.x, spline->endPnt.y, 0.0));
            pts.midArc = Base::Vector3d(spline->midPnt.x, spline->midPnt.y, 0.0);
            pts.isArc = arc;
            pts.arcCW = spline->cw;
            if (arc) {
                pts.onCurve.first(Base::Vector3d(spline->midPnt.x, spline->midPnt.y, 0.0));
            }
            else {
                pts.onCurve.first(pts.center
                                  + Base::Vector3d(1, 0, 0) * rad);  // arbitrary point on edge
                pts.onCurve.second(pts.center
                                   + Base::Vector3d(-1, 0, 0) * rad);  // arbitrary point on edge
            }
        }
        else {
            // fubar - can't have non-circular spline as target of Diameter dimension, but this is
            // already checked, so something has gone badly wrong.
            Base::Console().Error("%s: can not make a Circle from this B-spline edge\n",
                                  getNameInDocument());
            throw Base::RuntimeError("Bad B-spline geometry for arc dimension");
        }
    }
    else {
        std::stringstream ssMessage;
        ssMessage << getNameInDocument() << " 2d reference is a " << base->geomTypeName();
        throw Base::RuntimeError(ssMessage.str());
    }
    return pts;
}

arcPoints DrawViewDimension::arcPointsFromEdge(TopoDS_Edge occEdge)
{
    arcPoints pts;
    pts.isArc = !BRep_Tool::IsClosed(occEdge);
    pts.arcCW = false;

    // get all the common information for circle, ellipse and bspline conversions
    BRepAdaptor_Curve adapt(occEdge);
    double pFirst = adapt.FirstParameter();
    double pLast = adapt.LastParameter();
    double pMid = (pFirst + pLast) / 2;
    BRepLProp_CLProps props(adapt, pFirst, 0, Precision::Confusion());
    pts.arcEnds.first(Base::convertTo<Base::Vector3d>(props.Value()));
    props.SetParameter(pLast);
    pts.arcEnds.second(Base::convertTo<Base::Vector3d>(props.Value()));
    props.SetParameter(pMid);
    pts.onCurve.first(Base::convertTo<Base::Vector3d>(props.Value()));
    pts.onCurve.second(Base::convertTo<Base::Vector3d>(props.Value()));
    pts.midArc = Base::convertTo<Base::Vector3d>(props.Value());

    if (adapt.GetType() == GeomAbs_Circle) {
        gp_Circ circle = adapt.Circle();
        pts.center = Base::convertTo<Base::Vector3d>(circle.Location());
        pts.radius = circle.Radius();
        if (pts.isArc) {
            // part of circle
            gp_Ax1 axis = circle.Axis();
            gp_Vec startVec = Base::convertTo<gp_Vec>(pts.arcEnds.first() - pts.center);
            gp_Vec endVec = Base::convertTo<gp_Vec>(pts.arcEnds.second() - pts.center);
            double angle = startVec.AngleWithRef(endVec, axis.Direction().XYZ());
            pts.arcCW = (angle < 0.0);
        }
        else {
            // full circle
            pts.onCurve.first(pts.center
                              + Base::Vector3d(1, 0, 0) * pts.radius);  // arbitrary point on edge
            pts.onCurve.second(pts.center
                               + Base::Vector3d(-1, 0, 0) * pts.radius);  // arbitrary point on edge
        }
    }
    else if (adapt.GetType() == GeomAbs_Ellipse) {
        gp_Elips ellipse = adapt.Ellipse();
        pts.center = Base::convertTo<Base::Vector3d>(ellipse.Location());
        pts.radius = (ellipse.MajorRadius() + ellipse.MinorRadius()) / 2.0;
        if (pts.isArc) {
            // part of ellipse
            gp_Ax1 axis = ellipse.Axis();
            gp_Vec startVec = Base::convertTo<gp_Vec>(pts.arcEnds.first() - pts.center);
            gp_Vec endVec = Base::convertTo<gp_Vec>(pts.arcEnds.second() - pts.center);
            double angle = startVec.AngleWithRef(endVec, axis.Direction().XYZ());
            pts.arcCW = (angle < 0.0);
        }
        else {
            // full ellipse
            pts.onCurve.first(pts.center
                              + Base::Vector3d(1, 0, 0) * pts.radius);  // arbitrary point on edge
            pts.onCurve.second(pts.center
                               + Base::Vector3d(-1, 0, 0) * pts.radius);  // arbitrary point on edge
        }
    }
    else if (adapt.GetType() == GeomAbs_BSplineCurve) {
        if (GeometryUtils::isCircle(occEdge)) {
            bool isArc(false);
            TopoDS_Edge circleEdge = GeometryUtils::asCircle(occEdge, isArc);
            pts.isArc = isArc;
            BRepAdaptor_Curve adaptCircle(circleEdge);
            if (adaptCircle.GetType() != GeomAbs_Circle) {
                throw Base::RuntimeError("failed to get circle from B-spline");
            }
            gp_Circ circle = adapt.Circle();
            // TODO: same code as above. reuse opportunity.
            pts.center = Base::convertTo<Base::Vector3d>(circle.Location());
            pts.radius = circle.Radius();
            if (pts.isArc) {
                // part of circle
                gp_Ax1 axis = circle.Axis();
                gp_Vec startVec = Base::convertTo<gp_Vec>(pts.arcEnds.first() - pts.center);
                gp_Vec endVec = Base::convertTo<gp_Vec>(pts.arcEnds.second() - pts.center);
                double angle = startVec.AngleWithRef(endVec, axis.Direction().XYZ());
                pts.arcCW = (angle < 0.0);
            }
            else {
                // full circle
                pts.onCurve.first(
                    pts.center + Base::Vector3d(1, 0, 0) * pts.radius);  // arbitrary point on edge
                pts.onCurve.second(
                    pts.center + Base::Vector3d(-1, 0, 0) * pts.radius);  // arbitrary point on edge
            }
        }
        else {
            throw Base::RuntimeError("failed to make circle from B-spline");
        }
    }
    else {
        throw Base::RuntimeError("can not get arc points from this edge");
    }

    return pts;
}

anglePoints DrawViewDimension::getAnglePointsTwoEdges(ReferenceVector references)
{
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement0 = DrawUtil::getIndexFromName(references.at(0).getSubName());
    int iSubelement1 = DrawUtil::getIndexFromName(references.at(1).getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::BaseGeomPtr geom0 = getViewPart()->getGeomByIndex(iSubelement0);
        TechDraw::BaseGeomPtr geom1 = getViewPart()->getGeomByIndex(iSubelement1);
        if (!geom0 || !geom1) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " can not find geometry for 2d reference (5)";
            throw Base::RuntimeError(ssMessage.str());
        }
        if (geom0->getGeomType() != GeomType::GENERIC) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " first 2d reference is a "
                      << geom0->geomTypeName();
            throw Base::RuntimeError(ssMessage.str());
        }
        if (geom1->getGeomType() != GeomType::GENERIC) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " second 2d reference is a "
                      << geom0->geomTypeName();
            throw Base::RuntimeError(ssMessage.str());
        }
        TechDraw::GenericPtr generic0 = std::static_pointer_cast<TechDraw::Generic>(geom0);
        TechDraw::GenericPtr generic1 = std::static_pointer_cast<TechDraw::Generic>(geom1);
        Base::Vector3d apex = generic0->apparentInter(generic1);
        Base::Vector3d farPoint0;
        Base::Vector3d farPoint1;
        // pick the end of generic0 farthest from the apex
        if ((generic0->getStartPoint() - apex).Length()
            > (generic0->getEndPoint() - apex).Length()) {
            farPoint0 = generic0->getStartPoint();
        }
        else {
            farPoint0 = generic0->getEndPoint();
        }
        // pick the end of generic1 farthest from the apex
        if ((generic1->getStartPoint() - apex).Length()
            > (generic1->getEndPoint() - apex).Length()) {
            farPoint1 = generic1->getStartPoint();
        }
        else {
            farPoint1 = generic1->getEndPoint();
        }
        Base::Vector3d leg0Dir = (generic0->getStartPoint() - generic0->getEndPoint()).Normalize();
        Base::Vector3d leg1Dir = (generic1->getStartPoint() - generic1->getEndPoint()).Normalize();
        if (DrawUtil::fpCompare(fabs(leg0Dir.Dot(leg1Dir)), 1.0)) {
            // legs of the angle are parallel.
            throw Base::RuntimeError("Can not make angle from parallel edges");
        }
        Base::Vector3d extenPoint0 = farPoint0;  // extension line points
        Base::Vector3d extenPoint1 = farPoint1;
        if (DrawUtil::fpCompare(fabs(leg0Dir.Dot(leg1Dir)), 0.0)) {
            // legs of angle are perpendicular farPoints will do
        }
        else {
            // legs of the angle are skew
            // project farthest points onto opposite edge
            Base::Vector3d projFar0OnLeg1 = farPoint0.Perpendicular(apex, leg1Dir);
            Base::Vector3d projFar1OnLeg0 = farPoint1.Perpendicular(apex, leg0Dir);
            if (DrawUtil::isBetween(projFar0OnLeg1,
                                    generic1->getStartPoint(),
                                    generic1->getEndPoint())) {
                extenPoint1 = projFar0OnLeg1;
            }
            else if (DrawUtil::isBetween(projFar1OnLeg0,
                                         generic0->getStartPoint(),
                                         generic0->getEndPoint())) {
                extenPoint0 = projFar1OnLeg0;
            }
        }

        anglePoints pts;
        pts.first(extenPoint0);
        pts.second(extenPoint1);
        pts.vertex(apex);
        return pts;
    }

    // this is a 3d object
    TopoDS_Shape geometry0 = references.at(0).getGeometry();
    TopoDS_Shape geometry1 = references.at(1).getGeometry();
    if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_EDGE
        || geometry1.ShapeType() != TopAbs_EDGE) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }
    TopoDS_Edge edge0 = TopoDS::Edge(geometry0);
    BRepAdaptor_Curve adapt0(edge0);
    TopoDS_Edge edge1 = TopoDS::Edge(geometry1);
    BRepAdaptor_Curve adapt1(edge1);

    if (adapt0.GetType() != GeomAbs_Line || adapt1.GetType() != GeomAbs_Line) {
        throw Base::RuntimeError("Geometry for angle dimension must be lines.");
    }
    gp_Pnt gStart0 = BRep_Tool::Pnt(TopExp::FirstVertex(edge0));
    gp_Pnt gEnd0 = BRep_Tool::Pnt(TopExp::LastVertex(edge0));
    gp_Vec gDir0(gEnd0.XYZ() - gStart0.XYZ());
    gp_Pnt gStart1 = BRep_Tool::Pnt(TopExp::FirstVertex(edge1));
    gp_Pnt gEnd1 = BRep_Tool::Pnt(TopExp::LastVertex(edge1));
    gp_Vec gDir1(gEnd1.XYZ() - gStart1.XYZ());
    Base::Vector3d vApex;
    bool haveIntersection = DrawUtil::intersect2Lines3d(Base::convertTo<Base::Vector3d>(gStart0),
                                                        Base::convertTo<Base::Vector3d>(gDir0),
                                                        Base::convertTo<Base::Vector3d>(gStart1),
                                                        Base::convertTo<Base::Vector3d>(gDir1),
                                                        vApex);
    if (!haveIntersection) {
        throw Base::RuntimeError("Geometry for 3d angle dimension does not intersect");
    }
    gp_Pnt gApex = Base::convertTo<gp_Pnt>(vApex);

    gp_Pnt gFar0 = gEnd0;
    if (gStart0.Distance(gApex) > gEnd0.Distance(gApex)) {
        gFar0 = gStart0;
    }

    gp_Pnt gFar1 = gEnd1;
    if (gStart1.Distance(gApex) > gEnd1.Distance(gApex)) {
        gFar1 = gStart1;
    }
    anglePoints pts(Base::convertTo<Base::Vector3d>(gApex),
                    Base::convertTo<Base::Vector3d>(gFar0),
                    Base::convertTo<Base::Vector3d>(gFar1));
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

// TODO: this makes assumptions about the order of references (p - v - p). is this checked
// somewhere?
anglePoints DrawViewDimension::getAnglePointsThreeVerts(ReferenceVector references)
{
    if (references.size() < 3) {
        throw Base::RuntimeError("Not enough references to make angle dimension");
    }
    App::DocumentObject* refObject = references.front().getObject();
    int iSubelement0 = DrawUtil::getIndexFromName(references.at(0).getSubName());
    int iSubelement1 = DrawUtil::getIndexFromName(references.at(1).getSubName());
    int iSubelement2 = DrawUtil::getIndexFromName(references.at(2).getSubName());
    if (refObject->isDerivedFrom<TechDraw::DrawViewPart>()
        && !references.at(0).getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::VertexPtr vert0 = getViewPart()->getProjVertexByIndex(iSubelement0);
        TechDraw::VertexPtr vert1 = getViewPart()->getProjVertexByIndex(iSubelement1);
        TechDraw::VertexPtr vert2 = getViewPart()->getProjVertexByIndex(iSubelement2);
        if (!vert0 || !vert1 || !vert2) {
            throw Base::RuntimeError("References for three point angle dimension are not vertices");
        }
        anglePoints pts(vert1->point(), vert0->point(), vert2->point());
        return pts;
    }

    // this is a 3d object
    TopoDS_Shape geometry0 = references.at(0).getGeometry();
    TopoDS_Shape geometry1 = references.at(1).getGeometry();
    TopoDS_Shape geometry2 = references.at(2).getGeometry();
    if (geometry0.IsNull() || geometry1.IsNull() || geometry2.IsNull()
        || geometry0.ShapeType() != TopAbs_VERTEX || geometry1.ShapeType() != TopAbs_VERTEX
        || geometry2.ShapeType() != TopAbs_VERTEX) {
        throw Base::RuntimeError("Geometry for dimension reference is null.");
    }
    TopoDS_Vertex vertex0 = TopoDS::Vertex(geometry0);
    gp_Pnt point0 = BRep_Tool::Pnt(vertex0);
    TopoDS_Vertex vertex1 = TopoDS::Vertex(geometry1);
    gp_Pnt point1 = BRep_Tool::Pnt(vertex1);
    TopoDS_Vertex vertex2 = TopoDS::Vertex(geometry2);
    gp_Pnt point2 = BRep_Tool::Pnt(vertex2);
    anglePoints pts(Base::convertTo<Base::Vector3d>(point1),
                    Base::convertTo<Base::Vector3d>(point0),
                    Base::convertTo<Base::Vector3d>(point2));
    pts.move(getViewPart()->getCurrentCentroid());
    pts.project(getViewPart());
    return pts;
}

areaPoint DrawViewDimension::getAreaParameters(ReferenceVector references)
{
    areaPoint pts;

    App::DocumentObject* refObject = references.front().getObject();
    if (refObject->isDerivedFrom<DrawViewPart>() && !references[0].getSubName().empty()) {
        // this is a 2d object (a DVP + subelements)
        TechDraw::FacePtr face = getViewPart()->getFace(references[0].getSubName());
        if (!face) {
            std::stringstream ssMessage;
            ssMessage << getNameInDocument() << " can not find geometry for 2d reference (4)";
            throw Base::RuntimeError(ssMessage.str());
        }
        auto dvp = static_cast<DrawViewPart*>(refObject);

        auto filteredFaces  = GeometryUtils::findHolesInFace(dvp, references.front().getSubName());
        auto perforatedFace = GeometryUtils::makePerforatedFace(face, filteredFaces);

        // these areas are scaled because the source geometry is scaled, but it makes no sense to
        // report a scaled area.
        auto unscale = getViewPart()->getScale() * getViewPart()->getScale();
        pts.area = face->getArea() / unscale;     // this will be the 2d area as projected onto the page? not really filled area?
        pts.actualArea = getActualArea(perforatedFace)  / unscale;
        pts.center = getFaceCenter(perforatedFace);
        pts.invertY();      // geometry class is over, back to -Y up/.
    }
    else {
        // this is a 3d reference. perforations should be handled for us by OCC
        TopoDS_Shape geometry = references[0].getGeometry();
        if (geometry.IsNull() || geometry.ShapeType() != TopAbs_FACE) {
            throw Base::RuntimeError("Geometry for dimension reference is null.");
        }
        const TopoDS_Face& face = TopoDS::Face(geometry);

        // these areas are unscaled as the source is 3d geometry.
        pts.area = getFilledArea(face);
        pts.actualArea = getActualArea(face);
        pts.center = getFaceCenter(face);
        pts.move(getViewPart()->getCurrentCentroid());
        pts.project(getViewPart());
    }

    return pts;
}


//! returns the center of mass of a face (density = k)
Base::Vector3d DrawViewDimension::getFaceCenter(const TopoDS_Face& face)
{
    GProp_GProps props;
    BRepGProp::SurfaceProperties(face, props);
    auto center = Base::convertTo<Base::Vector3d>(props.CentreOfMass());
    return center;
}


//! returns the "net" area of a face (area of the face's outer boundary less the area of any holes)
double DrawViewDimension::getActualArea(const TopoDS_Face& face)
{
    GProp_GProps props;
    BRepGProp::SurfaceProperties(face, props);
    return props.Mass();
}


//! returns the "gross" area of a face (area of the face's outer boundary)
double DrawViewDimension::getFilledArea(const TopoDS_Face& face)
{
    TopoDS_Wire outerwire = ShapeAnalysis::OuterWire(face);
    if (outerwire.IsNull()) {
        return 0.0;
    }

    double area = ShapeAnalysis::ContourArea(outerwire);
    return area;
}


DrawViewPart* DrawViewDimension::getViewPart() const
{
    if (References2D.getValues().empty()) {
        return nullptr;
    }
    return dynamic_cast<TechDraw::DrawViewPart*>(References2D.getValues().at(0));
}

// return the references controlling this dimension. 3d references are used when available
// otherwise 2d references are returned. no checking is performed. Result is pairs of (object,
// subName)
ReferenceVector DrawViewDimension::getEffectiveReferences() const
{
    const std::vector<App::DocumentObject*>& objects3d = References3D.getValues();
    const std::vector<std::string>& subElements3d = References3D.getSubValues();
    const std::vector<App::DocumentObject*>& objects = References2D.getValues();
    const std::vector<std::string>& subElements = References2D.getSubValues();
    ReferenceVector effectiveRefs;

    // note that 3d references can be destroyed without our notice if the object
    // is deleted.
    if (objects3d.empty()) {
        // use 2d references
        int refCount = objects.size();
        for (int i = 0; i < refCount; i++) {
            if (subElements.empty()) {
                // the 3d references have likely been nulled out by an object
                // deletion.
                ReferenceEntry ref(objects.at(i), std::string());
                effectiveRefs.push_back(ref);
            }
            else {
                // normal 2d reference
                ReferenceEntry ref(objects.at(i), subElements.at(i));
                effectiveRefs.push_back(ref);
            }
        }
    }
    else {
        // use 3d references
        int refCount = objects3d.size();
        for (int i = 0; i < refCount; i++) {
            ReferenceEntry ref(objects3d.at(i), std::string(subElements3d.at(i)));
            effectiveRefs.push_back(ref);
        }
    }
    return effectiveRefs;
}


// what configuration of references do we have - Vertex-Vertex, Edge-Vertex, Edge, ...
RefType DrawViewDimension::getRefType() const
{
    if (isExtentDim()) {
        return RefType::extent;
    }

    ReferenceVector refs = getEffectiveReferences();
    std::vector<std::string> subNames;

    // std::vector<std::string> subNames = getEffectiveSubNames();   //???
    for (auto& ref : refs) {
        if (ref.getSubName().empty()) {
            // skip this one
            continue;
        }
        subNames.push_back(ref.getSubName());
    }

    if (subNames.empty()) {
        // something went wrong, there were no subNames.
        Base::Console().Message("DVD::getRefType - %s - there are no subNames.\n",
                                getNameInDocument());
        return RefType::invalidRef;
    }

    return getRefTypeSubElements(subNames);
}

// TODO: Gui/DimensionValidators.cpp has almost the same code
// decide what the reference configuration is by examining the names of the sub elements
RefType DrawViewDimension::getRefTypeSubElements(const std::vector<std::string>& subElements)
{
    RefType refType{RefType::invalidRef};
    int refEdges{0};
    int refVertices{0};
    int refFaces{0};

    for (const auto& se : subElements) {
        if (DrawUtil::getGeomTypeFromName(se) == "Vertex") {
            refVertices++;
        }
        if (DrawUtil::getGeomTypeFromName(se) == "Edge") {
            refEdges++;
        }
        if (DrawUtil::getGeomTypeFromName(se) == "Face") {
            refFaces++;
        }
    }

    if (refEdges == 0 && refVertices == 2 && refFaces == 0) {
        refType = RefType::twoVertex;
    }
    if (refEdges == 0 && refVertices == 3 && refFaces == 0) {
        refType = RefType::threeVertex;
    }
    if (refEdges == 1 && refVertices == 0 && refFaces == 0) {
        refType = RefType::oneEdge;
    }
    if (refEdges == 1 && refVertices == 1 && refFaces == 0) {
        refType = RefType::vertexEdge;
    }
    if (refEdges == 2 && refVertices == 0 && refFaces == 0) {
        refType = RefType::twoEdge;
    }
    if (refEdges == 0 && refVertices == 0 && refFaces == 1) {
        refType = RefType::oneFace;
    }

    return refType;
}

//! validate 2D references - only checks if the target exists
bool DrawViewDimension::checkReferences2D() const
{
    const std::vector<App::DocumentObject*>& objects = References2D.getValues();
    if (objects.empty()) {
        return false;
    }

    const std::vector<std::string>& subElements = References2D.getSubValues();
    if (subElements.empty()) {
        // must have at least 1 null string entry to balance DVP
        return false;
    }

    if (subElements.front().empty() && !References3D.getValues().empty()) {
        // this is (probably) a dim with 3d refs
        return true;
    }

    for (auto& sub : subElements) {
        if (sub.empty()) {
            return false;
        }

        int idx = DrawUtil::getIndexFromName(sub);
        if (DrawUtil::getGeomTypeFromName(sub) == "Edge") {
            TechDraw::BaseGeomPtr geom = getViewPart()->getGeomByIndex(idx);
            if (!geom) {
                return false;
            }
        }
        else if (DrawUtil::getGeomTypeFromName(sub) == "Vertex") {
            TechDraw::VertexPtr vert = getViewPart()->getProjVertexByIndex(idx);
            if (!vert) {
                return false;
            }
        }
    }

    return true;
}

//! detect the state where 3d references have been nulled out due to
//! object deletion and the reference will need to be rebuilt.
bool DrawViewDimension::hasBroken3dReferences() const
{
    const std::vector<App::DocumentObject*>& objects3d = References3D.getValues();
    const std::vector<App::DocumentObject*>& objects = References2D.getValues();
    const std::vector<std::string>& subElements = References2D.getSubValues();

    // if we have the reference to the View, but no 2d subelements or 3d objects
    // this means that the 3d references have been nulled out due to
    // object deletion and the reference will need to be rebuilt.
    return (objects.size() == 1 &&
            objects3d.empty() &&
            subElements.empty());
}


void DrawViewDimension::updateSavedGeometry()
{
    ReferenceVector references = getEffectiveReferences();
    if (references.empty()) {
        // no references to save
        return;
    }
    std::vector<TopoShape> newGeometry;
    const std::vector<TopoShape> oldGeometry = SavedGeometry.getValues();
    // need to clean up old saved geometry objects here?

    for (auto& entry : references) {
        if (entry.getSubName().empty()) {
            // view only reference has no geometry.
            continue;
        }
        if (entry.hasGeometry()) {
            newGeometry.push_back(entry.asCanonicalTopoShape());
        }
        else {
            // have to put something in the vector so SavedGeometry and references stay in sync.
                newGeometry.push_back(Part::TopoShape());
        }
    }
    if (!newGeometry.empty()) {
        SavedGeometry.setValues(newGeometry);
        saveFeatureBox();
    }
}


// based on Part::TopoShapePyImp::getShapes. Produces a vector of unique edges within the shape
std::vector<TopoShape> DrawViewDimension::getEdges(const TopoShape& inShape)
{
    std::vector<TopoShape> ret;
    TopTools_IndexedMapOfShape shapeMap;
    TopExp_Explorer Ex(inShape.getShape(), TopAbs_EDGE);
    while (Ex.More()) {
        shapeMap.Add(Ex.Current());
        Ex.Next();
    }

    for (Standard_Integer k = 1; k <= shapeMap.Extent(); k++) {
        const TopoDS_Shape& shape = shapeMap(k);
        ret.push_back(TopoShape(shape));
    }

    return ret;
}

// based on Part::TopoShapePyImp::getShapes
std::vector<TopoShape> DrawViewDimension::getVertexes(const TopoShape& inShape)
{
    std::vector<TopoShape> ret;
    TopTools_IndexedMapOfShape shapeMap;
    TopExp_Explorer Ex(inShape.getShape(), TopAbs_VERTEX);
    while (Ex.More()) {
        shapeMap.Add(Ex.Current());
        Ex.Next();
    }

    for (Standard_Integer k = 1; k <= shapeMap.Extent(); k++) {
        const TopoDS_Shape& shape = shapeMap(k);
        ret.push_back(TopoShape(shape));
    }

    return ret;
}

//! returns the angle subtended by an arc from 3 points.
double DrawViewDimension::getArcAngle(Base::Vector3d center, Base::Vector3d startPoint, Base::Vector3d endPoint)
{
    auto leg0 = startPoint - center;
    auto leg1 = endPoint - startPoint;
    auto referenceDirection = leg0.Cross(leg1);
    gp_Ax1 axis{Base::convertTo<gp_Pnt>(center), Base::convertTo<gp_Vec>(referenceDirection)};
    gp_Vec startVec = Base::convertTo<gp_Vec>(leg0);
    gp_Vec endVec = Base::convertTo<gp_Vec>(leg1);
    double angle = startVec.AngleWithRef(endVec, axis.Direction().XYZ());
    return angle;
}


pointPair DrawViewDimension::closestPoints(TopoDS_Shape s1, TopoDS_Shape s2) const
{
    pointPair result;
    BRepExtrema_DistShapeShape extss(s1, s2);
    if (!extss.IsDone()) {
        throw Base::RuntimeError("DVD::closestPoints - BRepExtrema_DistShapeShape failed");
    }
    int count = extss.NbSolution();
    if (count != 0) {
        gp_Pnt point = extss.PointOnShape1(1);
        result.first(Base::Vector3d(point.X(), point.Y(), point.Z()));
        point = extss.PointOnShape2(1);
        result.second(Base::Vector3d(point.X(), point.Y(), point.Z()));
    }  // TODO: else { explode }

    return result;
}

// set the reference property from a reference vector
void DrawViewDimension::setReferences2d(const ReferenceVector& refsAll)
{
    std::vector<App::DocumentObject*> objects;
    std::vector<std::string> subNames;
    if (objects.size() != subNames.size()) {
        throw Base::IndexError("DVD::setReferences2d - objects and subNames do not match.");
    }

    for (auto& ref : refsAll) {
        objects.push_back(ref.getObject());
        subNames.push_back(ref.getSubName());
    }

    References2D.setValues(objects, subNames);
    m_referencesCorrect = true;
}

// set the reference property from a reference vector
void DrawViewDimension::setReferences3d(const ReferenceVector &refsAll)
{
    if (refsAll.empty() && !References3D.getValues().empty()) {
        // clear the property of any old links
        References3D.setValue(nullptr, nullptr);
        return;
    }
    std::vector<App::DocumentObject*> objects;
    std::vector<std::string> subNames;
    if (objects.size() != subNames.size()) {
        throw Base::IndexError("DVD::setReferences3d - objects and subNames do not match.");
    }

    for (auto& ref : refsAll) {
        objects.push_back(ref.getObject());
        subNames.push_back(ref.getSubName(true));
        // cache the referenced object
        m_3dObjectCache.insert(ref.getObject()->getNameInDocument());
        // cache the parent object if available.  Ideally, we would handle deletion
        // of a reference object in a slot for DocumentObject::signalDeletedObject,
        // but by the time we get the signal the document will have severed any links
        // between our object and its parents. So we need to cache the parent here while
        // we still have the link
        App::DocumentObject* firstParent = ref.getObject()->getFirstParent();
        if (firstParent) {
            m_3dObjectCache.insert(firstParent->getNameInDocument());
        }
    }

    References3D.setValues(objects, subNames);
    m_referencesCorrect = true;
}

//! add Dimension 3D references to measurement
void DrawViewDimension::setAll3DMeasurement()
{
    measurement->clear();
    const std::vector<App::DocumentObject*>& Objs = References3D.getValues();
    const std::vector<std::string>& Subs = References3D.getSubValues();
    int end = Objs.size();
    int iObject = 0;
    for (; iObject < end; iObject++) {
        static_cast<void>(measurement->addReference3D(Objs.at(iObject), Subs.at(iObject)));
        // cache the referenced object
        m_3dObjectCache.insert(Objs.at(iObject)->getNameInDocument());
        // cache the parent object if available.  Ideally, we would handle deletion
        // of a reference object in a slot for DocumentObject::signalDeletedObject,
        // but by the time we get the signal the document will have severed any links
        // between our object and its parents. So we need to cache the parent here while
        // we still have the link
        App::DocumentObject* firstParent = Objs.at(iObject)->getFirstParent();
        if (firstParent) {
            m_3dObjectCache.insert(firstParent->getNameInDocument());
        }
    }
}

//! check the effective references have the correct number and type for this
//! dimension.
bool DrawViewDimension::validateReferenceForm() const
{
   // we have either or both valid References3D and References2D
    ReferenceVector references = getEffectiveReferences();
    if (references.empty()) {
        return false;
    }

    if (Type.isValue("Distance") || Type.isValue("DistanceX") || Type.isValue("DistanceY")) {
        if (getRefType() == RefType::oneEdge) {
            if (references.size() != 1) {
                return false;
            }
            std::string subGeom = DrawUtil::getGeomTypeFromName(references.front().getSubName());
            return subGeom == "Edge";
        }
        if (getRefType() == RefType::twoEdge) {
            if (references.size() != 2) {
                return false;
            }
            std::string subGeom0 = DrawUtil::getGeomTypeFromName(references.front().getSubName());
            std::string subGeom1 = DrawUtil::getGeomTypeFromName(references.back().getSubName());
            return (subGeom0 == "Edge" && subGeom1 == "Edge");
        }

        if (getRefType() == RefType::twoVertex) {
            if (references.size() != 2) {
                return false;
            }
            std::string subGeom0 = DrawUtil::getGeomTypeFromName(references.front().getSubName());
            std::string subGeom1 = DrawUtil::getGeomTypeFromName(references.back().getSubName());
            return (subGeom0 == "Vertex" && subGeom1 == "Vertex");
        }

        if (getRefType() == RefType::vertexEdge) {
            if (references.size() != 2) {
                return false;
            }
            std::string subGeom0 = DrawUtil::getGeomTypeFromName(references.front().getSubName());
            std::string subGeom1 = DrawUtil::getGeomTypeFromName(references.back().getSubName());
            return ( (subGeom0 == "Vertex" && subGeom1 == "Edge") ||
                     (subGeom0 == "Edge" && subGeom1 == "Vertex") );
        }
    }

    if (Type.isValue("Radius")) {
        if (references.size() != 1) {
            return false;
        }
        std::string subGeom = DrawUtil::getGeomTypeFromName(references.front().getSubName());
        return subGeom == "Edge";
    }

    if (Type.isValue("Diameter")) {
        if (references.size() != 1) {
            return false;
        }
        std::string subGeom = DrawUtil::getGeomTypeFromName(references.front().getSubName());
        return (subGeom == "Edge");
    }

    if (Type.isValue("Angle")) {
        if (references.size() != 2) {
            return false;
        }
        std::string subGeom0 = DrawUtil::getGeomTypeFromName(references.front().getSubName());
        std::string subGeom1 = DrawUtil::getGeomTypeFromName(references.back().getSubName());
        return (subGeom0 == "Edge" && subGeom1 == "Edge");
    }

    if (Type.isValue("Angle3Pt")) {
        if (references.size() != 3) {
            return false;
        }
        std::string subGeom0 = DrawUtil::getGeomTypeFromName(references.at(0).getSubName());
        std::string subGeom1 = DrawUtil::getGeomTypeFromName(references.at(1).getSubName());
        std::string subGeom2 = DrawUtil::getGeomTypeFromName(references.at(2).getSubName());
        return (subGeom0 == "Vertex" &&  subGeom1 == "Vertex" && subGeom2 == "Vertex");
    }

    if (Type.isValue("Area")) {
        if (references.size() != 1) {
            return false;
        }
        std::string subGeom = DrawUtil::getGeomTypeFromName(references.front().getSubName());
        if (subGeom != "Face") {
            return false;
        }
        return true;
    }

    return false;
}

// delete all previous measurements
void DrawViewDimension::clear3DMeasurements()
{
    // set sublinklist to empty?
    measurement->clear();
}

void DrawViewDimension::dumpRefs2D(const char* text) const
{
    Base::Console().Message("DUMP - %s\n", text);
    const std::vector<App::DocumentObject*>& objects = References2D.getValues();
    const std::vector<std::string>& subElements = References2D.getSubValues();
    auto objIt = objects.begin();
    auto subIt = subElements.begin();
    int i = 0;
    for (; objIt != objects.end(); objIt++, subIt++, i++) {
        Base::Console().Message("DUMP - ref: %d object: %s subElement: %s\n",
                                i,
                                (*objIt)->getNameInDocument(),
                                (*subIt).c_str());
    }
}

// TODO: this should go into DrawUtil or ShapeUtil or ??
double DrawViewDimension::dist2Segs(Base::Vector3d s1,
                                    Base::Vector3d e1,
                                    Base::Vector3d s2,
                                    Base::Vector3d e2) const
{
    gp_Pnt start(s1.x, s1.y, 0.0);
    gp_Pnt end(e1.x, e1.y, 0.0);
    TopoDS_Vertex v1 = BRepBuilderAPI_MakeVertex(start);
    TopoDS_Vertex v2 = BRepBuilderAPI_MakeVertex(end);
    BRepBuilderAPI_MakeEdge makeEdge1(v1, v2);
    TopoDS_Edge edge1 = makeEdge1.Edge();

    start = gp_Pnt(s2.x, s2.y, 0.0);
    end = gp_Pnt(e2.x, e2.y, 0.0);
    v1 = BRepBuilderAPI_MakeVertex(start);
    v2 = BRepBuilderAPI_MakeVertex(end);
    BRepBuilderAPI_MakeEdge makeEdge2(v1, v2);
    TopoDS_Edge edge2 = makeEdge2.Edge();

    BRepExtrema_DistShapeShape extss(edge1, edge2);
    if (!extss.IsDone()) {
        throw Base::RuntimeError("DVD::dist2Segs - BRepExtrema_DistShapeShape failed");
    }
    int count = extss.NbSolution();
    double minDist = 0.0;
    if (count != 0) {
        minDist = extss.Value();
    }  // TODO: else { explode }

    return minDist;
}

bool DrawViewDimension::leaderIntersectsArc(Base::Vector3d s, Base::Vector3d pointOnCircle)
{
    bool result = false;
    const std::vector<std::string>& subElements = References2D.getSubValues();
    int idx = DrawUtil::getIndexFromName(subElements[0]);
    TechDraw::BaseGeomPtr base = getViewPart()->getGeomByIndex(idx);
    if (base && base->getGeomType() == GeomType::ARCOFCIRCLE) {
        TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(base);
        if (aoc->intersectsArc(s, pointOnCircle)) {
            result = true;
        }
    }
    else if (base && base->getGeomType() == GeomType::BSPLINE) {
        TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(base);
        if (spline->isCircle()) {
            if (spline->intersectsArc(s, pointOnCircle)) {
                result = true;
            }
        }
    }

    return result;
}

void DrawViewDimension::saveArrowPositions(const Base::Vector2d positions[])
{
    if (!positions) {
        m_arrowPositions.first(Base::Vector3d(0.0, 0.0, 0.0));
        m_arrowPositions.second(Base::Vector3d(0.0, 0.0, 0.0));
    }
    else {
        double scale = getViewPart()->getScale();
        m_arrowPositions.first(Base::Vector3d(positions[0].x, positions[0].y, 0.0) / scale);
        m_arrowPositions.second(Base::Vector3d(positions[1].x, positions[1].y, 0.0) / scale);
    }
}

// return the 2d references as a ReferenceVector
ReferenceVector DrawViewDimension::getReferences2d() const
{
    const std::vector<App::DocumentObject*>& objects = References2D.getValues();
    const std::vector<std::string>& subElements = References2D.getSubValues();
    ReferenceVector refs2d;
    int refCount = objects.size();
    for (int i = 0; i < refCount; i++) {
        ReferenceEntry ref(objects.at(i), subElements.at(i));
        refs2d.push_back(ref);
    }
    return refs2d;
}

// return the 3d references as a ReferenceVector
ReferenceVector DrawViewDimension::getReferences3d() const
{
    const std::vector<App::DocumentObject*>& objects3d = References3D.getValues();
    const std::vector<std::string>& subElements3d = References3D.getSubValues();
    ReferenceVector refs3d;
    int refCount = objects3d.size();
    for (int i = 0; i < refCount; i++) {
        ReferenceEntry ref(objects3d.at(i), subElements3d.at(i));
        refs3d.push_back(ref);
    }
    return refs3d;
}


// return position within parent view of dimension arrow heads/dimline endpoints
// note positions are in apparent coord (inverted y).
pointPair DrawViewDimension::getArrowPositions()
{
    return m_arrowPositions;
}

bool DrawViewDimension::has2DReferences() const
{
    const std::vector<App::DocumentObject*>& objects = References2D.getValues();
    const std::vector<std::string>& subNames = References2D.getSubValues();
    if (objects.empty()) {
        // we don't even have a DVP
        return false;
    }

    if (subNames.front().empty()) {
        // this is ok, as we must have a null string entry to balance DVP in first object position
        return true;
    }

    // we have a reference to a DVP and at least 1 subName entry, so we have 2d references
    return true;
}

// there is no special structure to 3d references, so anything > 0 is good
bool DrawViewDimension::has3DReferences() const
{
    return (References3D.getSize() > 0);
}

// has arbitrary or nonzero tolerance
bool DrawViewDimension::hasOverUnderTolerance() const
{
    return (ArbitraryTolerances.getValue() ||
            !DrawUtil::fpCompare(OverTolerance.getValue(), 0.0) ||
            !DrawUtil::fpCompare(UnderTolerance.getValue(), 0.0));
}

bool DrawViewDimension::showUnits() const
{
    return ShowUnits.getValue();
}

bool DrawViewDimension::useDecimals() const
{
    return Preferences::useGlobalDecimals();
}

std::string DrawViewDimension::getPrefixForDimType() const
{
    if (Type.isValue("Radius")) {
        return "R";
    }

    if (Type.isValue("Diameter")) {
        return std::string(Preferences::getPreferenceGroup("Dimensions")
                               ->GetASCII("DiameterSymbol", "\xe2\x8c\x80"));  // Diameter symbol
    }

    return "";
}

std::string DrawViewDimension::getDefaultFormatSpec(bool isToleranceFormat) const
{
    return m_formatter->getDefaultFormatSpec(isToleranceFormat);
}

bool DrawViewDimension::isExtentDim() const
{
    constexpr int DimExtentLength{9};
    std::string name(getNameInDocument());
    return (name.substr(0, DimExtentLength) == "DimExtent");
}


PyObject* DrawViewDimension::getPyObject()
{
    if (PythonObject.is(Py::_None())) {
        // ref counter is set to 1
        PythonObject = Py::Object(new DrawViewDimensionPy(this), true);
    }
    return Py::new_reference_to(PythonObject);
}


//! store the corners of this dimension's base view for use by phase 2 of the auto correct process.
void DrawViewDimension::saveFeatureBox()
{
    std::vector<Base::Vector3d> bbxCorners;
    auto bbx = getFeatureBox();
    bbxCorners.push_back(bbx.GetMinimum());
    bbxCorners.push_back(bbx.GetMaximum());
    BoxCorners.setValues(bbxCorners);
}

Base::BoundBox3d DrawViewDimension::getSavedBox()
{
    std::vector<Base::Vector3d> bbxCorners = BoxCorners.getValues();
    if (bbxCorners.empty()) {
        // need to advise caller if BoxCorners not filled in yet.  zero length
        // diagonal?
        Base::Console().Message("DVD::getSavedBox - no corners!\n");
        return Base::BoundBox3d();
    }
    return Base::BoundBox3d(bbxCorners.front().x,
                            bbxCorners.front().y,
                            bbxCorners.front().z,
                            bbxCorners.back().x,
                            bbxCorners.back().y,
                            bbxCorners.back().z);
}

Base::BoundBox3d DrawViewDimension::getFeatureBox()
{
    if (getViewPart() && getViewPart()->getBoundingBox().IsValid()) {
        return getViewPart()->getBoundingBox();
    }
    return Base::BoundBox3d();
}