715 lines
27 KiB
C++
715 lines
27 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 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 <BRepAdaptor_Curve.hxx>
|
|
#include <BRep_Tool.hxx>
|
|
#include <TopExp.hxx>
|
|
#endif//#ifndef _PreComp_
|
|
|
|
#include <App/DocumentObject.h>
|
|
#include <Base/Console.h>
|
|
#include <Gui/Selection.h>
|
|
#include <Mod/TechDraw/App/DrawViewPart.h>
|
|
#include <Mod/TechDraw/App/ShapeExtractor.h>
|
|
|
|
#include "DimensionValidators.h"
|
|
|
|
|
|
using namespace TechDraw;
|
|
using DU = DrawUtil;
|
|
|
|
TechDraw::DrawViewPart* TechDraw::getReferencesFromSelection(ReferenceVector& references2d,
|
|
ReferenceVector& references3d)
|
|
{
|
|
TechDraw::DrawViewPart* dvp(nullptr);
|
|
TechDraw::DrawViewDimension* dim(nullptr);
|
|
std::vector<Gui::SelectionObject> selectionAll = Gui::Selection().getSelectionEx();
|
|
for (auto& selItem : selectionAll) {
|
|
if (selItem.getObject()->isDerivedFrom(TechDraw::DrawViewDimension::getClassTypeId())) {
|
|
//we are probably repairing a dimension, but we will check later
|
|
dim = static_cast<TechDraw::DrawViewDimension*>(selItem.getObject());
|
|
} else if (selItem.getObject()->isDerivedFrom(TechDraw::DrawViewPart::getClassTypeId())) {
|
|
//this could be a 2d geometry selection or just a DrawViewPart for context in
|
|
//a 3d selection
|
|
dvp = static_cast<TechDraw::DrawViewPart*>(selItem.getObject());
|
|
if (selItem.getSubNames().empty()) {
|
|
//there are no subNames, so we think this is a 3d case,
|
|
//and we only need to select the view. We set the reference
|
|
//subName to a null string to avoid later misunderstandings.
|
|
ReferenceEntry ref(dvp, std::string());
|
|
references2d.push_back(ref);
|
|
}
|
|
for (auto& sub : selItem.getSubNames()) {
|
|
ReferenceEntry ref(dvp, sub);
|
|
references2d.push_back(ref);
|
|
}
|
|
} else if (!selItem.getObject()->isDerivedFrom(TechDraw::DrawView::getClassTypeId())) {
|
|
//this is not a TechDraw object, so we check to see if it has 3d geometry
|
|
std::vector<App::DocumentObject*> links;
|
|
links.push_back(selItem.getObject());
|
|
if (!ShapeExtractor::getShapes(links).IsNull()) {
|
|
//this item has 3d geometry so we are interested
|
|
App::DocumentObject* obj3d = selItem.getObject();
|
|
if (selItem.getSubNames().empty()) {
|
|
if (ShapeExtractor::isPointType(obj3d)) {
|
|
//a point object may not have a subName when selected,
|
|
//so we need to perform some special handling.
|
|
ReferenceEntry ref(obj3d, "Vertex1");
|
|
references3d.push_back(ref);
|
|
continue;
|
|
} else {
|
|
//this is a whole object reference, probably for an extent dimension
|
|
ReferenceEntry ref(obj3d, std::string());
|
|
references3d.push_back(ref);
|
|
continue;
|
|
}
|
|
}
|
|
//this is a regular reference in form obj+subelement
|
|
for (auto& sub3d : selItem.getSubNames()) {
|
|
ReferenceEntry ref(obj3d, sub3d);
|
|
references3d.push_back(ref);
|
|
}
|
|
} else {
|
|
Base::Console().Message("DV::getRefsFromSel - %s has no shape!\n",
|
|
selItem.getObject()->getNameInDocument());
|
|
}
|
|
}
|
|
}
|
|
if (dim) {
|
|
if (!dvp) {
|
|
ReferenceEntry ref(dim->getViewPart(), std::string());
|
|
references2d.push_back(ref);
|
|
return dim->getViewPart();
|
|
}
|
|
}
|
|
return dvp;
|
|
}
|
|
|
|
//! verify that the proposed references contains valid geometries from a 2d DrawViewPart.
|
|
DimensionGeometryType TechDraw::validateDimSelection(
|
|
ReferenceVector references, //[(dvp*, std::string),...,(dvp*, std::string)]
|
|
StringVector acceptableGeometry,//"Edge", "Vertex", etc
|
|
std::vector<int> minimumCounts, //how many of each geometry are needed for a good dimension
|
|
std::vector<DimensionGeometryType> acceptableDimensionGeometrys)//isVertical, isHorizontal, ...
|
|
{
|
|
StringVector subNames;
|
|
TechDraw::DrawViewPart* dvpSave(nullptr);
|
|
for (auto& ref : references) {
|
|
TechDraw::DrawViewPart* dvp = dynamic_cast<TechDraw::DrawViewPart*>(ref.getObject());
|
|
if (dvp) {
|
|
dvpSave = dvp;
|
|
if (!ref.getSubName().empty()) {
|
|
subNames.push_back(ref.getSubName());
|
|
}
|
|
}
|
|
}
|
|
if (!dvpSave) {
|
|
//must have 1 DVP in selection
|
|
return isInvalid;
|
|
}
|
|
|
|
if (subNames.empty()) {
|
|
//no geometry referenced. can not make a dim from this mess. We are being called to validate
|
|
//a selection for a 3d reference
|
|
return isViewReference;
|
|
}
|
|
|
|
if (subNames.front().empty()) {
|
|
//can this still happen?
|
|
return isViewReference;
|
|
}
|
|
|
|
//check for invalid geometry descriptors in the subNames
|
|
std::unordered_set<std::string> acceptableGeometrySet(acceptableGeometry.begin(),
|
|
acceptableGeometry.end());
|
|
if (!TechDraw::validateSubnameList(subNames, acceptableGeometrySet)) {
|
|
//can not make a dimension from this
|
|
return isInvalid;
|
|
}
|
|
|
|
//check for wrong number of geometry
|
|
GeomCountVector foundCounts;
|
|
GeomCountMap minimumCountMap = loadRequiredCounts(acceptableGeometry, minimumCounts);
|
|
if (!checkGeometryOccurences(subNames, minimumCountMap)) {
|
|
//too many or too few geometry descriptors.
|
|
return isInvalid;
|
|
}
|
|
|
|
//we have a (potentially valid collection of 2d geometry
|
|
ReferenceVector valid2dReferences;
|
|
for (auto& sub : subNames) {
|
|
ReferenceEntry validEntry(dvpSave, sub);
|
|
valid2dReferences.push_back(validEntry);
|
|
}
|
|
|
|
DimensionGeometryType foundGeometry = getGeometryConfiguration(valid2dReferences);
|
|
if (acceptableDimensionGeometrys.empty()) {
|
|
//if the list is empty, we are accepting anything
|
|
return foundGeometry;
|
|
}
|
|
for (auto& acceptable : acceptableDimensionGeometrys) {
|
|
if (foundGeometry == acceptable) {
|
|
return foundGeometry;
|
|
}
|
|
}
|
|
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the proposed references contains valid geometries from non-TechDraw objects.
|
|
DimensionGeometryType TechDraw::validateDimSelection3d(
|
|
TechDraw::DrawViewPart* dvp,
|
|
ReferenceVector references, //[(dvp*, std::string),...,(dvp*, std::string)]
|
|
StringVector acceptableGeometry,//"Edge", "Vertex", etc
|
|
std::vector<int> minimumCounts, //how many of each geometry are needed for a good dimension
|
|
std::vector<DimensionGeometryType> acceptableDimensionGeometrys)//isVertical, isHorizontal, ...
|
|
{
|
|
StringVector subNames;
|
|
for (auto& ref : references) {
|
|
if (!ref.getSubName().empty()) {
|
|
subNames.push_back(ref.getSubName());
|
|
}
|
|
}
|
|
|
|
|
|
//check for invalid geometry descriptors in the subNames
|
|
std::unordered_set<std::string> acceptableGeometrySet(acceptableGeometry.begin(),
|
|
acceptableGeometry.end());
|
|
if (!TechDraw::validateSubnameList(subNames, acceptableGeometrySet)) {
|
|
//can not make a dimension from this
|
|
return isInvalid;
|
|
}
|
|
|
|
//check for wrong number of geometry
|
|
GeomCountMap minimumCountMap = loadRequiredCounts(acceptableGeometry, minimumCounts);
|
|
if (!checkGeometryOccurences(subNames, minimumCountMap)) {
|
|
//too many or too few geometry descriptors.
|
|
return isInvalid;
|
|
}
|
|
|
|
//we have a (potentially valid collection of 3d geometry
|
|
DimensionGeometryType foundGeometry = getGeometryConfiguration3d(dvp, references);
|
|
if (acceptableDimensionGeometrys.empty()) {
|
|
//if the list is empty, we are accepting anything
|
|
return foundGeometry;
|
|
}
|
|
for (auto& acceptable : acceptableDimensionGeometrys) {
|
|
if (foundGeometry == acceptable) {
|
|
return foundGeometry;
|
|
}
|
|
}
|
|
|
|
return isInvalid;
|
|
}
|
|
bool TechDraw::validateSubnameList(StringVector subNames, GeometrySet acceptableGeometrySet)
|
|
{
|
|
for (auto& sub : subNames) {
|
|
std::string geometryType = DrawUtil::getGeomTypeFromName(sub);
|
|
if (acceptableGeometrySet.count(geometryType) == 0) {
|
|
//this geometry type is not allowed
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//count how many of each "Edge", "Vertex, etc and compare totals to required minimum
|
|
bool TechDraw::checkGeometryOccurences(StringVector subNames, GeomCountMap keyedMinimumCounts)
|
|
{
|
|
//how many of each geometry descriptor are input
|
|
GeomCountMap foundCounts;
|
|
for (auto& sub : subNames) {
|
|
std::string geometryType = DrawUtil::getGeomTypeFromName(sub);
|
|
std::map<std::string, int>::iterator it0(foundCounts.find(geometryType));
|
|
if (it0 == foundCounts.end()) {
|
|
//first occurrence of this geometryType
|
|
foundCounts[geometryType] = 1;
|
|
} else {
|
|
//already have this geometryType
|
|
it0->second++;
|
|
}
|
|
}
|
|
|
|
//hybrid dims (vertex-edge) can skip this check
|
|
if (foundCounts.size() > 1) {
|
|
//this is a hybrid dimension
|
|
return true;
|
|
}
|
|
|
|
//check found geometry counts against required counts
|
|
for (auto& foundItem : foundCounts) {
|
|
std::string currentKey = foundItem.first;
|
|
int foundCount = foundItem.second;
|
|
auto itAccept = keyedMinimumCounts.find(currentKey);
|
|
if (itAccept == keyedMinimumCounts.end()) {
|
|
//not supposed to happen by this point
|
|
throw Base::IndexError("Dimension validation counts and geometry do not match");
|
|
}
|
|
if (foundCount < keyedMinimumCounts[currentKey]) {
|
|
//not enough of this type of geom to make a good dimension - ex 1 Vertex
|
|
return false;
|
|
}
|
|
}
|
|
//we have no complaints about the input
|
|
return true;
|
|
}
|
|
|
|
//return the first valid configuration contained in the already validated references
|
|
DimensionGeometryType TechDraw::getGeometryConfiguration(ReferenceVector valid2dReferences)
|
|
{
|
|
DimensionGeometryType config = isValidMultiEdge(valid2dReferences);
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
config = isValidVertexes(valid2dReferences);
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
config = isValidSingleEdge(valid2dReferences.front());
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
config = isValidHybrid(valid2dReferences);
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
|
|
// no valid configuration found
|
|
return isInvalid;
|
|
}
|
|
|
|
//return the first valid configuration contained in the already validated references
|
|
DimensionGeometryType TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp,
|
|
ReferenceVector valid3dReferences)
|
|
{
|
|
//first we check for whole object references
|
|
ReferenceVector wholeObjectRefs;
|
|
ReferenceVector subElementRefs;
|
|
for (auto& ref : valid3dReferences) {
|
|
if (ref.isWholeObject()) {
|
|
wholeObjectRefs.push_back(ref);
|
|
} else {
|
|
subElementRefs.push_back(ref);
|
|
}
|
|
}
|
|
if (subElementRefs.empty()) {
|
|
//only whole object references
|
|
return isMultiEdge;
|
|
}
|
|
if (!wholeObjectRefs.empty()) {
|
|
//mix of whole object and subelement refs
|
|
return isMultiEdge;//??? correct ???
|
|
}
|
|
|
|
//only have subelement refs
|
|
DimensionGeometryType config = isValidMultiEdge3d(dvp, valid3dReferences);
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
config = isValidVertexes3d(dvp, valid3dReferences);
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
config = isValidSingleEdge3d(dvp, valid3dReferences.front());
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
config = isValidHybrid3d(dvp, valid3dReferences);
|
|
if (config > isInvalid) {
|
|
return config;
|
|
}
|
|
|
|
// no valid configuration found
|
|
return isInvalid;
|
|
}
|
|
|
|
//fill the GeomCountMap with pairs made from corresponding items in acceptableGeometry
|
|
//and minimumCounts
|
|
GeomCountMap TechDraw::loadRequiredCounts(StringVector& acceptableGeometry,
|
|
std::vector<int>& minimumCounts)
|
|
{
|
|
if (acceptableGeometry.size() != minimumCounts.size()) {
|
|
throw Base::IndexError("acceptableGeometry and minimum counts have different sizes.");
|
|
}
|
|
|
|
GeomCountMap result;
|
|
int iCount = 0;
|
|
for (auto& acceptableItem : acceptableGeometry) {
|
|
result[acceptableItem] = minimumCounts.at(iCount);
|
|
iCount++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//! verify that Selection contains a valid Geometry for a single Edge Dimension
|
|
DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref)
|
|
{
|
|
auto objFeat(dynamic_cast<TechDraw::DrawViewPart*>(ref.getObject()));
|
|
if (!objFeat) {
|
|
return isInvalid;
|
|
}
|
|
|
|
//the Name starts with "Edge"
|
|
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName());
|
|
if (geomName != "Edge") {
|
|
return isInvalid;
|
|
}
|
|
|
|
//the geometry exists (redundant?)
|
|
int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName()));
|
|
TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
|
|
if (!geom) {
|
|
return isInvalid;
|
|
}
|
|
|
|
if (geom->getGeomType() == TechDraw::GENERIC) {
|
|
TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom);
|
|
if (gen1->points.size() < 2) {
|
|
return isInvalid;
|
|
}
|
|
Base::Vector3d line = gen1->points.at(1) - gen1->points.at(0);
|
|
if (fabs(line.y) < FLT_EPSILON) {
|
|
return TechDraw::isHorizontal;
|
|
} else if (fabs(line.x) < FLT_EPSILON) {
|
|
return TechDraw::isVertical;
|
|
} else {
|
|
return TechDraw::isDiagonal;
|
|
}
|
|
} else if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
|
|
return isCircle;
|
|
} else if (geom->getGeomType() == TechDraw::ELLIPSE || geom->getGeomType() == TechDraw::ARCOFELLIPSE) {
|
|
return isEllipse;
|
|
} else if (geom->getGeomType() == TechDraw::BSPLINE) {
|
|
TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(geom);
|
|
if (spline->isCircle()) {
|
|
return isBSplineCircle;
|
|
} else {
|
|
return isBSpline;
|
|
}
|
|
}
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that Selection contains a valid Geometry for a single Edge Dimension
|
|
DimensionGeometryType TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref)
|
|
{
|
|
(void)dvp;
|
|
//the Name starts with "Edge"
|
|
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName());
|
|
if (geomName != "Edge") {
|
|
return isInvalid;
|
|
}
|
|
|
|
TopoDS_Shape refShape = ref.getGeometry();
|
|
if (refShape.IsNull() || refShape.ShapeType() != TopAbs_EDGE) {
|
|
throw Base::RuntimeError("Geometry for reference is not an edge.");
|
|
}
|
|
|
|
TopoDS_Edge occEdge = TopoDS::Edge(refShape);
|
|
BRepAdaptor_Curve adapt(occEdge);
|
|
if (adapt.GetType() == GeomAbs_Line) {
|
|
Base::Vector3d point0 = DU::toVector3d(BRep_Tool::Pnt(TopExp::FirstVertex(occEdge)));
|
|
point0 = dvp->projectPoint(point0);
|
|
Base::Vector3d point1 = DU::toVector3d(BRep_Tool::Pnt(TopExp::LastVertex(occEdge)));
|
|
point1 = dvp->projectPoint(point1);
|
|
Base::Vector3d line = point1 - point0;
|
|
if (fabs(line.y) < FLT_EPSILON) {
|
|
return TechDraw::isHorizontal;
|
|
} else if (fabs(line.x) < FLT_EPSILON) {
|
|
return TechDraw::isVertical;
|
|
}
|
|
// else if (fabs(line.z) < FLT_EPSILON) {
|
|
// return TechDraw::isZLimited;
|
|
// }
|
|
else {
|
|
return TechDraw::isDiagonal;
|
|
}
|
|
} else if (adapt.GetType() == GeomAbs_Circle) {
|
|
return isCircle;
|
|
} else if (adapt.GetType() == GeomAbs_Ellipse) {
|
|
return isEllipse;
|
|
} else if (adapt.GetType() == GeomAbs_BSplineCurve) {
|
|
if (GeometryUtils::isCircle(occEdge)) {
|
|
return isBSplineCircle;
|
|
} else {
|
|
return isBSpline;
|
|
}
|
|
}
|
|
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the edge references can make a dimension. Currently only extent
|
|
//! dimensions support more than 2 edges
|
|
DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
|
|
{
|
|
//there has to be at least 2
|
|
if (refs.size() < 2) {
|
|
return isInvalid;
|
|
}
|
|
|
|
auto objFeat0(dynamic_cast<TechDraw::DrawViewPart*>(refs.at(0).getObject()));
|
|
if (!objFeat0) {
|
|
//probably redundant
|
|
throw Base::RuntimeError("Logic error in isValidMultiEdge");
|
|
}
|
|
|
|
//they all must start with "Edge"
|
|
for (auto& ref : refs) {
|
|
if (TechDraw::DrawUtil::getGeomTypeFromName(ref.getSubName()) != "Edge") {
|
|
return isInvalid;
|
|
}
|
|
}
|
|
|
|
if (refs.size() > 2) {
|
|
//many edges, must be an extent?
|
|
return isMultiEdge;
|
|
}
|
|
|
|
//exactly 2 edges. could be angle, could be distance
|
|
int GeoId0(TechDraw::DrawUtil::getIndexFromName(refs.at(0).getSubName()));
|
|
int GeoId1(TechDraw::DrawUtil::getIndexFromName(refs.at(1).getSubName()));
|
|
TechDraw::BaseGeomPtr geom0 = objFeat0->getGeomByIndex(GeoId0);
|
|
TechDraw::BaseGeomPtr geom1 = objFeat0->getGeomByIndex(GeoId1);
|
|
|
|
if (geom0->getGeomType() == TechDraw::GENERIC && geom1->getGeomType() == TechDraw::GENERIC) {
|
|
TechDraw::GenericPtr gen0 = std::static_pointer_cast<TechDraw::Generic>(geom0);
|
|
TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom1);
|
|
if (gen0->points.size() > 2 || gen1->points.size() > 2) {//the edge is a polyline
|
|
return isInvalid; //not supported yet
|
|
}
|
|
Base::Vector3d line0 = gen0->points.at(1) - gen0->points.at(0);
|
|
Base::Vector3d line1 = gen1->points.at(1) - gen1->points.at(0);
|
|
double xprod = fabs(line0.x * line1.y - line0.y * line1.x);
|
|
if (xprod > FLT_EPSILON) {//edges are not parallel
|
|
return isAngle; //angle or distance
|
|
} else {
|
|
return isDiagonal;//distance || line
|
|
}
|
|
} else {
|
|
return isDiagonal;//two edges, not both straight lines
|
|
}
|
|
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the edge references can make a dimension. Currently only extent
|
|
//! dimensions support more than 2 edges
|
|
DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs)
|
|
{
|
|
(void)dvp;
|
|
//there has to be at least 2
|
|
if (refs.size() < 2) {
|
|
return isInvalid;
|
|
}
|
|
|
|
std::vector<TopoDS_Edge> edges;
|
|
for (auto& ref : refs) {
|
|
std::vector<TopoDS_Shape> shapesAll = ShapeExtractor::getShapesFromObject(ref.getObject());
|
|
if (shapesAll.empty()) {
|
|
//reference has no geometry
|
|
return isInvalid;
|
|
}
|
|
|
|
//the Name starts with "Edge"
|
|
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName().c_str());
|
|
if (geomName != "Edge") {
|
|
return isInvalid;
|
|
}
|
|
}
|
|
std::vector<TopoDS_Edge> edgesAll;
|
|
std::vector<int> typeAll;
|
|
for (auto& ref : refs) {
|
|
TopoDS_Shape geometry = ref.getGeometry();
|
|
if (geometry.ShapeType() != TopAbs_EDGE) {
|
|
return isInvalid;
|
|
}
|
|
TopoDS_Edge edge = TopoDS::Edge(geometry);
|
|
BRepAdaptor_Curve adapt(edge);
|
|
if (adapt.GetType() != GeomAbs_Line) {
|
|
//not a line, so this must be an extent dim?
|
|
return isMultiEdge;
|
|
}
|
|
edgesAll.push_back(edge);
|
|
}
|
|
if (edgesAll.size() > 2) {
|
|
//must be an extent dimension of lines?
|
|
return isMultiEdge;
|
|
} else if (edgesAll.size() == 2) {
|
|
Base::Vector3d first0 = DU::toVector3d(BRep_Tool::Pnt(TopExp::FirstVertex(edgesAll.at(0))));
|
|
Base::Vector3d last0 = DU::toVector3d(BRep_Tool::Pnt(TopExp::LastVertex(edgesAll.at(1))));
|
|
Base::Vector3d line0 = last0 - first0;
|
|
Base::Vector3d first1 = DU::toVector3d(BRep_Tool::Pnt(TopExp::FirstVertex(edgesAll.at(0))));
|
|
Base::Vector3d last1 = DU::toVector3d(BRep_Tool::Pnt(TopExp::LastVertex(edgesAll.at(1))));
|
|
Base::Vector3d line1 = last1 - first1;
|
|
if (DU::fpCompare(fabs(line0.Dot(line1)), 1)) {
|
|
//lines are parallel, must be distance dim
|
|
return isDiagonal;
|
|
} else {
|
|
//lines are skew, could be angle, could be distance?
|
|
return isAngle;
|
|
}
|
|
}
|
|
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the vertex references can make a dimension
|
|
DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs)
|
|
{
|
|
TechDraw::DrawViewPart* dvp(dynamic_cast<TechDraw::DrawViewPart*>(refs.front().getObject()));
|
|
if (!dvp) {
|
|
//probably redundant
|
|
throw Base::RuntimeError("Logic error in isValidMultiEdge");
|
|
}
|
|
|
|
if (refs.size() == 2) {
|
|
//2 vertices can only make a distance dimension
|
|
TechDraw::VertexPtr v0 = dvp->getVertex(refs.at(0).getSubName());
|
|
TechDraw::VertexPtr v1 = dvp->getVertex(refs.at(1).getSubName());
|
|
Base::Vector3d line = v1->point() - v0->point();
|
|
if (fabs(line.y) < FLT_EPSILON) {
|
|
return isHorizontal;
|
|
} else if (fabs(line.x) < FLT_EPSILON) {
|
|
return isVertical;
|
|
} else {
|
|
return isDiagonal;
|
|
}
|
|
} else if (refs.size() == 3) {
|
|
//three vertices make an angle dimension
|
|
return isAngle3Pt;
|
|
}
|
|
|
|
// did not find a valid configuration
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the vertex references can make a dimension
|
|
DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs)
|
|
{
|
|
(void)dvp;
|
|
if (refs.size() == 2) {
|
|
//2 vertices can only make a distance dimension
|
|
TopoDS_Shape geometry0 = refs.at(0).getGeometry();
|
|
TopoDS_Shape geometry1 = refs.at(1).getGeometry();
|
|
if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_VERTEX
|
|
|| geometry1.ShapeType() != TopAbs_VERTEX) {
|
|
return isInvalid;
|
|
}
|
|
Base::Vector3d point0 = DU::toVector3d(BRep_Tool::Pnt(TopoDS::Vertex(geometry0)));
|
|
point0 = dvp->projectPoint(point0);
|
|
Base::Vector3d point1 = DU::toVector3d(BRep_Tool::Pnt(TopoDS::Vertex(geometry1)));
|
|
point1 = dvp->projectPoint(point1);
|
|
Base::Vector3d line = point1 - point0;
|
|
if (fabs(line.y) < FLT_EPSILON) {
|
|
return isHorizontal;
|
|
} else if (fabs(line.x) < FLT_EPSILON) {
|
|
return isVertical;
|
|
// } else if(fabs(line.z) < FLT_EPSILON) {
|
|
// return isZLimited;
|
|
} else {
|
|
return isDiagonal;
|
|
}
|
|
} else if (refs.size() == 3) {
|
|
//three vertices make an angle dimension
|
|
//we could check here that all the geometries are Vertex
|
|
return isAngle3Pt;
|
|
}
|
|
|
|
// did not find a valid configuration
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the mixed bag (ex Vertex-Edge) of references can make a dimension
|
|
DimensionGeometryType TechDraw::isValidHybrid(ReferenceVector refs)
|
|
{
|
|
if (refs.empty()) {
|
|
return isInvalid;
|
|
}
|
|
|
|
int vertexCount(0);
|
|
int edgeCount(0);
|
|
for (auto& ref : refs) {
|
|
if (DU::getGeomTypeFromName(ref.getSubName()) == "Vertex") {
|
|
vertexCount++;
|
|
}
|
|
if (DU::getGeomTypeFromName(ref.getSubName()) == "Edge") {
|
|
edgeCount++;
|
|
}
|
|
}
|
|
if (vertexCount > 0 && edgeCount > 0) {
|
|
//must be a diagonal dim? could it be isHorizontal or isVertical?
|
|
return isDiagonal;
|
|
}
|
|
|
|
return isInvalid;
|
|
}
|
|
|
|
//! verify that the mixed bag (ex Vertex-Edge) of references can make a dimension
|
|
DimensionGeometryType TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs)
|
|
{
|
|
(void)dvp;
|
|
//we don't have a special check for 3d in this case
|
|
return isValidHybrid(refs);
|
|
}
|
|
|
|
//handle situations where revised geometry type is valid but not suitable for existing dimType
|
|
long int TechDraw::mapGeometryTypeToDimType(long int dimType, DimensionGeometryType geometry2d,
|
|
DimensionGeometryType geometry3d)
|
|
{
|
|
if (geometry2d == isInvalid && geometry3d == isInvalid) {
|
|
//probably an error, but we can't do anything with this
|
|
return dimType;
|
|
}
|
|
|
|
if (geometry2d == isViewReference && geometry3d != isInvalid) {
|
|
switch (geometry3d) {
|
|
case isDiagonal:
|
|
return DrawViewDimension::Distance;
|
|
case isHorizontal:
|
|
return DrawViewDimension::DistanceX;
|
|
case isVertical:
|
|
return DrawViewDimension::DistanceY;
|
|
case isAngle:
|
|
return DrawViewDimension::Angle;
|
|
case isAngle3Pt:
|
|
return DrawViewDimension::Angle3Pt;
|
|
}
|
|
} else if (geometry2d != isViewReference) {
|
|
switch (geometry2d) {
|
|
case isDiagonal:
|
|
return DrawViewDimension::Distance;
|
|
case isHorizontal:
|
|
return DrawViewDimension::DistanceX;
|
|
case isVertical:
|
|
return DrawViewDimension::DistanceY;
|
|
case isAngle:
|
|
return DrawViewDimension::Angle;
|
|
case isAngle3Pt:
|
|
return DrawViewDimension::Angle3Pt;
|
|
}
|
|
}
|
|
return dimType;
|
|
}
|