/*************************************************************************** * Copyright (c) 2022 WandererFan * * * * 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 # include # include #include #include #include #include "DimensionGeometry.h" #include "DrawUtil.h" #include "DrawViewPart.h" #include "DrawViewDetail.h" using namespace TechDraw; using DU = DrawUtil; pointPair::pointPair(const pointPair& pp) { first(pp.first()); second(pp.second()); overrideFirst(pp.extensionLineFirst()); overrideSecond(pp.extensionLineSecond()); } // set extension line points from argument base points void pointPair::setExtensionLine(const pointPair& pp){ overrideFirst(pp.first()); overrideSecond(pp.second()); } //move the points by offset void pointPair::move(const Base::Vector3d& offset) { m_first = m_first - offset; m_second = m_second - offset; m_overrideFirst = m_overrideFirst - offset; m_overrideSecond = m_overrideSecond - offset; } //move the points by factor void pointPair::scale(double factor) { m_first = m_first * factor; m_second = m_second * factor; m_overrideFirst = m_overrideFirst * factor; m_overrideSecond = m_overrideSecond * factor; } // project the points onto the dvp's paper plane. void pointPair::project(const DrawViewPart* dvp) { auto detailView = dynamic_cast(dvp); if (detailView) { m_first = detailView->mapPoint3dToDetail(m_first) * detailView->getScale(); m_second = detailView->mapPoint3dToDetail(m_second) * detailView->getScale(); m_overrideFirst = detailView->mapPoint3dToDetail(m_overrideFirst) * detailView->getScale(); m_overrideSecond = detailView->mapPoint3dToDetail(m_overrideSecond) * detailView->getScale(); return; } m_first = dvp->projectPoint(m_first) * dvp->getScale(); m_second = dvp->projectPoint(m_second) * dvp->getScale(); m_overrideFirst = dvp->projectPoint(m_overrideFirst) * dvp->getScale(); m_overrideSecond = dvp->projectPoint(m_overrideSecond) * dvp->getScale(); } // map the points onto the dvp's XY coordinate system // this routine is no longer needed since we now use the hlr projector instead // of "projectToPlane" from Vector3d void pointPair::mapToPage(const DrawViewPart* dvp) { gp_Trsf xOXYZ; gp_Ax3 OXYZ; xOXYZ.SetTransformation(OXYZ, gp_Ax3(dvp->getRotatedCS())); gp_Vec gvFirst = Base::convertTo(m_first).Transformed(xOXYZ); m_first = Base::convertTo(gvFirst); gp_Vec gvSecond = Base::convertTo(m_second).Transformed(xOXYZ); m_second = Base::convertTo(gvSecond); } // this routine is no longer needed since we now use the dvp's projectPoint // which performs Y inversion by default void pointPair::invertY() { m_first = DU::invertY(m_first); m_second = DU::invertY(m_second); } void pointPair::dump(const std::string& text) const { Base::Console().message("pointPair - %s\n", text.c_str()); Base::Console().message("pointPair - first: %s second: %s\n", DU::formatVector(first()).c_str(), DU::formatVector(second()).c_str()); } //! return unscaled, unrotated version of this pointPair. caller is responsible for //! for ensuring this pointPair is in scaled, rotated form before calling this method. pointPair pointPair::toCanonicalForm(DrawViewPart* dvp) const { pointPair result; // invert points? result.m_first = CosmeticVertex::makeCanonicalPoint(dvp, m_first); result.m_second = CosmeticVertex::makeCanonicalPoint(dvp, m_second); result.m_overrideFirst = CosmeticVertex::makeCanonicalPoint(dvp, m_overrideFirst); result.m_overrideSecond = CosmeticVertex::makeCanonicalPoint(dvp, m_overrideSecond); return result; } //! return scaled and rotated version of this pointPair. caller is responsible for //! for ensuring this pointPair is in canonical form before calling this method. pointPair pointPair::toDisplayForm(DrawViewPart* dvp) const { pointPair result; // invert points? result.m_first = m_first * dvp->getScale(); result.m_second = m_second * dvp->getScale(); result.m_overrideFirst = m_overrideFirst * dvp->getScale(); result.m_overrideSecond = m_overrideSecond * dvp->getScale(); auto rotationDeg = dvp->Rotation.getValue(); if (rotationDeg != 0.0) { auto rotationRad = Base::toRadians(rotationDeg); result.m_first.RotateZ(rotationRad); result.m_second.RotateZ(rotationRad); result.m_overrideFirst.RotateZ(rotationRad); result.m_overrideSecond.RotateZ(rotationRad); } return result; } anglePoints::anglePoints() { m_ends.first(Base::Vector3d(0.0, 0.0, 0.0)); m_ends.second(Base::Vector3d(0.0, 0.0, 0.0)); m_vertex = Base::Vector3d(0.0, 0.0, 0.0); } anglePoints::anglePoints(const anglePoints& ap) : m_ends(ap.ends()), m_vertex(ap.vertex()) {} anglePoints& anglePoints::operator=(const anglePoints& ap) { m_ends = ap.ends(); m_vertex = ap.vertex(); return *this; } // move the points by offset void anglePoints::move(const Base::Vector3d& offset) { m_ends.move(offset); m_vertex = m_vertex - offset; } // project the points onto the dvp's paper plane. void anglePoints::project(const DrawViewPart* dvp) { m_ends.project(dvp); m_vertex = dvp->projectPoint(m_vertex) * dvp->getScale(); } // map the points onto the dvp's XY coordinate system // obsolete. see above. void anglePoints::mapToPage(const DrawViewPart* dvp) { m_ends.mapToPage(dvp); gp_Trsf xOXYZ; gp_Ax3 OXYZ; xOXYZ.SetTransformation(OXYZ, gp_Ax3(dvp->getRotatedCS())); gp_Vec gvVertex = Base::convertTo(m_vertex).Transformed(xOXYZ); m_vertex = Base::convertTo(gvVertex); } // map the points onto the coordinate system used for drawing where -Y direction is "up" // obsolete. see above void anglePoints::invertY() { m_ends.invertY(); m_vertex = DU::invertY(m_vertex); } //! return unscaled, unrotated version of this anglePoints. caller is responsible for //! for ensuring this anglePoints is in scaled, rotated form before calling this method. anglePoints anglePoints::toCanonicalForm(DrawViewPart* dvp) const { anglePoints result; result.m_ends = m_ends.toCanonicalForm(dvp); result.m_vertex = CosmeticVertex::makeCanonicalPoint(dvp, m_vertex); return result; } //! return scaled and rotated version of this anglePoints. caller is responsible for //! for ensuring this anglePoints is in canonical form before calling this method. anglePoints anglePoints::toDisplayForm(DrawViewPart* dvp) const { anglePoints result; result.m_ends = m_ends.toDisplayForm(dvp); result.m_vertex = m_vertex * dvp->getScale(); auto rotationDeg = dvp->Rotation.getValue(); if (rotationDeg != 0.0) { auto rotationRad = Base::toRadians(rotationDeg); result.m_vertex.RotateZ(rotationRad); } return result; } void anglePoints::dump(const std::string& text) const { Base::Console().message("anglePoints - %s\n", text.c_str()); Base::Console().message("anglePoints - ends - first: %s second: %s\n", DU::formatVector(first()).c_str(), DU::formatVector(second()).c_str()); Base::Console().message("anglePoints - vertex: %s\n", DU::formatVector(vertex()).c_str()); } arcPoints::arcPoints() : isArc(false), radius(0.0), arcCW(false) { center = Base::Vector3d(0.0, 0.0, 0.0); onCurve.first(Base::Vector3d(0.0, 0.0, 0.0)); onCurve.second(Base::Vector3d(0.0, 0.0, 0.0)); arcEnds.first(Base::Vector3d(0.0, 0.0, 0.0)); arcEnds.second(Base::Vector3d(0.0, 0.0, 0.0)); midArc = Base::Vector3d(0.0, 0.0, 0.0); } arcPoints& arcPoints::operator=(const arcPoints& ap) { isArc = ap.isArc; radius = ap.radius; center = ap.center; onCurve = ap.onCurve; arcEnds = ap.arcEnds; midArc = ap.midArc; arcCW = ap.arcCW; return *this; } void arcPoints::move(const Base::Vector3d& offset) { center = center - offset; onCurve.first(onCurve.first() - offset); onCurve.second(onCurve.second() - offset); arcEnds.first(arcEnds.first() - offset); arcEnds.second(arcEnds.second() - offset); midArc = midArc - offset; } void arcPoints::project(const DrawViewPart* dvp) { radius = radius * dvp->getScale(); center = dvp->projectPoint(center) * dvp->getScale(); onCurve.first(dvp->projectPoint(onCurve.first()) * dvp->getScale()); onCurve.second(dvp->projectPoint(onCurve.second()) * dvp->getScale()); arcEnds.first(dvp->projectPoint(arcEnds.first()) * dvp->getScale()); arcEnds.second(dvp->projectPoint(arcEnds.second()) * dvp->getScale()); midArc = dvp->projectPoint(midArc) * dvp->getScale(); } // obsolete. see above void arcPoints::mapToPage(const DrawViewPart* dvp) { gp_Trsf xOXYZ; gp_Ax3 OXYZ; xOXYZ.SetTransformation(OXYZ, gp_Ax3(dvp->getRotatedCS())); gp_Vec gvCenter = Base::convertTo(center).Transformed(xOXYZ); center = Base::convertTo(gvCenter); gp_Vec gvOnCurve1 = Base::convertTo(onCurve.first()).Transformed(xOXYZ); onCurve.first(Base::convertTo(gvOnCurve1)); gp_Vec gvOnCurve2 = Base::convertTo(onCurve.second()).Transformed(xOXYZ); onCurve.second(Base::convertTo(gvOnCurve2)); gp_Vec gvArcEnds1 = Base::convertTo(arcEnds.first()).Transformed(xOXYZ); arcEnds.first(Base::convertTo(gvArcEnds1)); gp_Vec gvArcEnds2 = Base::convertTo(arcEnds.second()).Transformed(xOXYZ); arcEnds.second(Base::convertTo(gvArcEnds2)); gp_Vec gvMidArc = Base::convertTo(midArc).Transformed(xOXYZ); midArc = Base::convertTo(gvMidArc); } // obsolete. see above void arcPoints::invertY() { center = DU::invertY(center); onCurve.invertY(); arcEnds.invertY(); midArc = DU::invertY(midArc); } //! return scaled and rotated version of this arcPoints. caller is responsible for //! for ensuring this arcPoints is in canonical form before calling this method. arcPoints arcPoints::toDisplayForm(DrawViewPart* dvp) const { arcPoints result; result.onCurve = onCurve.toDisplayForm(dvp); result.arcEnds = arcEnds.toDisplayForm(dvp); result.center = center * dvp->getScale(); result.midArc = midArc * dvp->getScale(); result.radius = radius * dvp->getScale(); auto rotationDeg = dvp->Rotation.getValue(); if (rotationDeg != 0.0) { auto rotationRad = Base::toRadians(rotationDeg); result.center.RotateZ(rotationRad); result.midArc.RotateZ(rotationRad); } return result; } //! return unscaled, unrotated version of this arcPoints. caller is responsible for //! for ensuring this arcPoints is in scaled, rotated form before calling this method. arcPoints arcPoints::toCanonicalForm(DrawViewPart* dvp) const { arcPoints result; result.onCurve = onCurve.toCanonicalForm(dvp); result.arcEnds = arcEnds.toCanonicalForm(dvp); result.center = CosmeticVertex::makeCanonicalPoint(dvp, center); result.midArc = CosmeticVertex::makeCanonicalPoint(dvp, midArc); result.radius = radius / dvp->getScale(); return result; } void arcPoints::dump(const std::string& text) const { Base::Console().message("arcPoints - %s\n", text.c_str()); Base::Console().message("arcPoints - radius: %.3f center: %s\n", radius, DrawUtil::formatVector(center).c_str()); Base::Console().message("arcPoints - isArc: %d arcCW: %d\n", isArc, arcCW); Base::Console().message("arcPoints - onCurve: %s %s\n", DrawUtil::formatVector(onCurve.first()).c_str(), DrawUtil::formatVector(onCurve.second()).c_str()); Base::Console().message("arcPoints - arcEnds: %s %s\n", DrawUtil::formatVector(arcEnds.first()).c_str(), DrawUtil::formatVector(arcEnds.second()).c_str()); Base::Console().message("arcPoints - midArc: %s\n", DrawUtil::formatVector(midArc).c_str()); } areaPoint::areaPoint() : area(0.0), actualArea(0.0), center(Base::Vector3d()) { } areaPoint& areaPoint::operator=(const areaPoint& ap) { area = ap.area; center = ap.center; actualArea = ap.actualArea; return *this; } void areaPoint::move(const Base::Vector3d& offset) { center = center - offset; } void areaPoint::project(const DrawViewPart* dvp) { center = dvp->projectPoint(center) * dvp->getScale(); } void areaPoint::invertY() { center = DU::invertY(center); } void areaPoint::dump(const std::string& text) const { Base::Console().message("areaPoint - %s\n", text.c_str()); Base::Console().message("areaPoint - area: %.3f center: %s\n", area, DrawUtil::formatVector(center).c_str()); }