210 lines
7.4 KiB
C++
210 lines
7.4 KiB
C++
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
/***************************************************************************
|
|
* Copyright (c) 2017 Werner Mayer <wmayer[at]users.sourceforge.net> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include <limits>
|
|
|
|
#include <BRepAdaptor_Surface.hxx>
|
|
#include <BRepBuilderAPI_MakeFace.hxx>
|
|
#include <BRepLProp_SLProps.hxx>
|
|
#include <GeomAPI_PointsToBSplineSurface.hxx>
|
|
#include <Geom_BSplineSurface.hxx>
|
|
#include <Precision.hxx>
|
|
#include <Standard_Version.hxx>
|
|
#include <TColgp_Array2OfPnt.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopoDS_Face.hxx>
|
|
#include <gp_Pnt.hxx>
|
|
|
|
#include <Base/Tools.h>
|
|
|
|
#include "FeatureExtend.h"
|
|
|
|
|
|
using namespace Surface;
|
|
|
|
const App::PropertyIntegerConstraint::Constraints SampleRange = {2, std::numeric_limits<int>::max(), 1};
|
|
const App::PropertyFloatConstraint::Constraints ToleranceRange = {0.0, 10.0, 0.01};
|
|
const App::PropertyFloatConstraint::Constraints ExtendRange = {-0.5, 10.0, 0.01};
|
|
PROPERTY_SOURCE(Surface::Extend, Part::Spline)
|
|
|
|
Extend::Extend()
|
|
{
|
|
ADD_PROPERTY(Face, (nullptr));
|
|
Face.setScope(App::LinkScope::Global);
|
|
ADD_PROPERTY(Tolerance, (0.1));
|
|
Tolerance.setConstraints(&ToleranceRange);
|
|
|
|
ADD_PROPERTY(ExtendUNeg, (0.05));
|
|
ExtendUNeg.setConstraints(&ExtendRange);
|
|
ADD_PROPERTY(ExtendUPos, (0.05));
|
|
ExtendUPos.setConstraints(&ExtendRange);
|
|
ADD_PROPERTY(ExtendUSymetric, (true));
|
|
|
|
ADD_PROPERTY(ExtendVNeg, (0.05));
|
|
ExtendVNeg.setConstraints(&ExtendRange);
|
|
ADD_PROPERTY(ExtendVPos, (0.05));
|
|
ExtendVPos.setConstraints(&ExtendRange);
|
|
ADD_PROPERTY(ExtendVSymetric, (true));
|
|
|
|
ADD_PROPERTY(SampleU, (32));
|
|
SampleU.setConstraints(&SampleRange);
|
|
ADD_PROPERTY(SampleV, (32));
|
|
SampleV.setConstraints(&SampleRange);
|
|
}
|
|
|
|
short Extend::mustExecute() const
|
|
{
|
|
if (Face.isTouched()) {
|
|
return 1;
|
|
}
|
|
if (ExtendUNeg.isTouched()) {
|
|
return 1;
|
|
}
|
|
if (ExtendUPos.isTouched()) {
|
|
return 1;
|
|
}
|
|
if (ExtendVNeg.isTouched()) {
|
|
return 1;
|
|
}
|
|
if (ExtendVPos.isTouched()) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
App::DocumentObjectExecReturn* Extend::execute()
|
|
{
|
|
App::DocumentObject* part = Face.getValue();
|
|
if (!part || !part->isDerivedFrom<Part::Feature>()) {
|
|
return new App::DocumentObjectExecReturn("No shape linked.");
|
|
}
|
|
const auto& faces = Face.getSubValues();
|
|
if (faces.size() != 1) {
|
|
return new App::DocumentObjectExecReturn("Not exactly one sub-shape linked.");
|
|
}
|
|
|
|
TopoDS_Shape shape = static_cast<Part::Feature*>(part)->Shape.getShape().getSubShape(
|
|
faces[0].c_str()
|
|
);
|
|
if (shape.IsNull() || shape.ShapeType() != TopAbs_FACE) {
|
|
return new App::DocumentObjectExecReturn("Sub-shape is not a face.");
|
|
}
|
|
|
|
const TopoDS_Face& face = TopoDS::Face(shape);
|
|
BRepAdaptor_Surface adapt(face);
|
|
double u1 = adapt.FirstUParameter();
|
|
double u2 = adapt.LastUParameter();
|
|
double v1 = adapt.FirstVParameter();
|
|
double v2 = adapt.LastVParameter();
|
|
|
|
double ur = u2 - u1;
|
|
double vr = v2 - v1;
|
|
double eu1 = u1 - ur * ExtendUNeg.getValue();
|
|
double eu2 = u2 + ur * ExtendUPos.getValue();
|
|
double ev1 = v1 - vr * ExtendVNeg.getValue();
|
|
double ev2 = v2 + vr * ExtendVPos.getValue();
|
|
double eur = eu2 - eu1;
|
|
double evr = ev2 - ev1;
|
|
|
|
long numU = SampleU.getValue();
|
|
long numV = SampleV.getValue();
|
|
TColgp_Array2OfPnt approxPoints(1, numU, 1, numV);
|
|
for (long u = 0; u < numU; u++) {
|
|
double uu = eu1 + u * eur / (numU - 1);
|
|
for (long v = 0; v < numV; v++) {
|
|
double vv = ev1 + v * evr / (numV - 1);
|
|
BRepLProp_SLProps prop(adapt, uu, vv, 0, Precision::Confusion());
|
|
const gp_Pnt& pnt = prop.Value();
|
|
approxPoints(u + 1, v + 1) = pnt;
|
|
}
|
|
}
|
|
|
|
Approx_ParametrizationType ParType = Approx_ChordLength;
|
|
Standard_Integer DegMin = 3;
|
|
Standard_Integer DegMax = 5;
|
|
GeomAbs_Shape Continuity = GeomAbs_C2;
|
|
Standard_Real Tol3d = Tolerance.getValue();
|
|
|
|
GeomAPI_PointsToBSplineSurface approx;
|
|
approx.Init(approxPoints, ParType, DegMin, DegMax, Continuity, Tol3d);
|
|
|
|
Handle(Geom_BSplineSurface) surface(approx.Surface());
|
|
BRepBuilderAPI_MakeFace mkFace(surface, Precision::Confusion());
|
|
|
|
Shape.setValue(mkFace.Face());
|
|
|
|
return StdReturn;
|
|
}
|
|
|
|
void Extend::onChanged(const App::Property* prop)
|
|
{
|
|
// using a mutex and lock to protect a recursive calling when setting the new values
|
|
if (lockOnChangeMutex) {
|
|
return;
|
|
}
|
|
Base::StateLocker lock(lockOnChangeMutex);
|
|
|
|
if (ExtendUSymetric.getValue()) {
|
|
if (prop == &ExtendUNeg || prop == &ExtendUPos) {
|
|
auto changedValue = dynamic_cast<const App::PropertyFloat*>(prop);
|
|
if (changedValue) {
|
|
ExtendUNeg.setValue(changedValue->getValue());
|
|
ExtendUPos.setValue(changedValue->getValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ExtendVSymetric.getValue()) {
|
|
if (prop == &ExtendVNeg || prop == &ExtendVPos) {
|
|
auto changedValue = dynamic_cast<const App::PropertyFloat*>(prop);
|
|
if (changedValue) {
|
|
ExtendVNeg.setValue(changedValue->getValue());
|
|
ExtendVPos.setValue(changedValue->getValue());
|
|
}
|
|
}
|
|
}
|
|
Part::Spline::onChanged(prop);
|
|
}
|
|
|
|
void Extend::handleChangedPropertyName(Base::XMLReader& reader, const char* TypeName, const char* PropName)
|
|
{
|
|
Base::Type type = Base::Type::fromName(TypeName);
|
|
if (App::PropertyFloatConstraint::getClassTypeId() == type && strcmp(PropName, "ExtendU") == 0) {
|
|
App::PropertyFloatConstraint v;
|
|
v.Restore(reader);
|
|
ExtendUNeg.setValue(v.getValue());
|
|
ExtendUPos.setValue(v.getValue());
|
|
}
|
|
else if (App::PropertyFloatConstraint::getClassTypeId() == type
|
|
&& strcmp(PropName, "ExtendV") == 0) {
|
|
App::PropertyFloatConstraint v;
|
|
v.Restore(reader);
|
|
ExtendVNeg.setValue(v.getValue());
|
|
ExtendVPos.setValue(v.getValue());
|
|
}
|
|
else {
|
|
Part::Spline::handleChangedPropertyName(reader, TypeName, PropName);
|
|
}
|
|
}
|