{
std::vector<TopoDS_Shape> aCurvesList;
Split( aCurves[i], thePoint, theTolerance, aCurvesList );
- bool isLocalOK = CreatePolylines( theDoc, thePolyline->GetName(),
- aCurvesList, true, thePolyline->GetWireColor() );
+ bool isLocalOK = CreatePolylines( theDoc, thePolyline, aCurvesList, true );
isOK = isOK && isLocalOK;
}
return isOK;
}
}
- CreatePolylines( theDoc, thePolyline->GetName(), aResult, true, thePolyline->GetWireColor() );
+ CreatePolylines( theDoc, thePolyline, aResult, true );
//CreatePolylinesSplit( theDoc, thePolyline, aResult, true );
return true;
}
//}
bool HYDROData_PolylineOperator::CreatePolylines( const Handle( HYDROData_Document )& theDoc,
- const QString& theNamePrefix,
+ const Handle( HYDROData_PolylineXY )& theOldPolyline,
const std::vector<TopoDS_Shape>& theShapes,
- bool isUseIndices,
- const QColor& theColor )
+ bool isUseIndices )
{
if( theDoc.IsNull() )
return false;
+ if ( theOldPolyline.IsNull() )
+ return false;
+ const QString& theNamePrefix = theOldPolyline->GetName();
+ const QColor& theColor = theOldPolyline->GetWireColor();
+
int n = theShapes.size();
DEBTRACE("theShapes.size() "<< n);
int anIndex = 1;
if( aPolyline.IsNull() )
return false;
- aPolyline->ImportShape(theShapes[i], false, false);
+ aPolyline->ImportShape(theShapes[i], false, theOldPolyline, false);
//aPolyline->SetShape( theShapes[i] );
#include "HYDRO_trace.hxx"
#include <BRepTools.hxx>
#include <sstream>
+#include <cmath>
static const Standard_GUID GUID_IS_UNEDITABLE("e5799736-9030-4051-91a4-2e58321fa153");
NCollection_Sequence<HYDROData_PolylineXY::PointsList>& theSectPoints,
bool IsCanBeClosed,
bool IsInterpolationAllowed,
- double theDeflection )
+ double theDeflection,
+ const Handle( HYDROData_PolylineXY )& theOldPolyline )
{
DEBTRACE("convertEdgesToSections")
Standard_Real aFirst = 0.0, aLast = 0.0;
isNewSection = true;
aPointsList.Clear();
- BRepAdaptor_Curve anAdaptorCurve( theEdge );
- GCPnts_QuasiUniformDeflection aDiscrete( anAdaptorCurve, theDeflection );
+ BRepAdaptor_Curve anAdaptorCurve(theEdge);
+ if (theOldPolyline.IsNull()) // --- no previous polyline: build a set of points from scratch for the spline
+ {
+ GCPnts_QuasiUniformDeflection aDiscrete(anAdaptorCurve, theDeflection);
- int aNbPoints = aDiscrete.NbPoints();
+ int aNbPoints = aDiscrete.NbPoints();
- // Decrease the number of imported poles because of last one
- // pole is the closing point which are the start point
- if ( anIsEdgeClosed ) aNbPoints--;
+ // Decrease the number of imported poles because of last one
+ // pole is the closing point which are the start point
+ if (anIsEdgeClosed)
+ aNbPoints--;
- for ( int i = 1; i <= aNbPoints; ++i )
- {
- const gp_Pnt& aPoint = aDiscrete.Value( i );
+ for (int i = 1; i <= aNbPoints; ++i)
+ {
+ const gp_Pnt& aPoint = aDiscrete.Value(i);
+ HYDROData_PolylineXY::Point aSectPoint(aPoint.X(), aPoint.Y());
+ aPointsList.Append(aSectPoint);
+ }
- HYDROData_PolylineXY::Point aSectPoint( aPoint.X(), aPoint.Y() );
- aPointsList.Append( aSectPoint );
- }
+ gp_Pnt endPts[] = {gp_Pnt(aPointsList.First().X(),aPointsList.First().Y(), 0),
+ gp_Pnt(aPointsList.Last().X(),aPointsList.Last().Y(), 0) };
+ DEBTRACE("curve start: "<< endPts[0].X() << " " << endPts[0].Y());
+ DEBTRACE("curve end: "<< endPts[1].X() << " " << endPts[1].Y());
+ }
+ else // --- split of a previous polyline: try to retrieve old sets of points and add intersection points
+ {
+ const gp_Pnt aEndPs[] = { anAdaptorCurve.Value(anAdaptorCurve.FirstParameter()).XYZ(),
+ anAdaptorCurve.Value(anAdaptorCurve.LastParameter()).XYZ() };
+ double midPar = (anAdaptorCurve.LastParameter() + anAdaptorCurve.FirstParameter())/2;
+ gp_Pnt midPnt;
+ anAdaptorCurve.D0(midPar, midPnt);
+ DEBTRACE("curve first point: " << aEndPs[0].X() << " " << aEndPs[0].Y() << " " << aEndPs[0].Z());
+ DEBTRACE("curve last point: " << aEndPs[1].X() << " " << aEndPs[1].Y() << " " << aEndPs[1].Z());
+ DEBTRACE("curve mid point: " << midPnt.X() << " " << midPnt.Y() << " " << midPnt.Z());
+
+ std::vector<TopoDS_Wire> aCurves;
+ HYDROData_PolylineOperator::GetWires(theOldPolyline, aCurves);
+
+ int nbSections = theOldPolyline->NbSections();
+ DEBTRACE("nbSections: "<< nbSections << ", nbCurves: " << aCurves.size() );
+ for (int isec = 0; isec < nbSections; isec++)
+ {
+ DEBTRACE("section: "<< isec);
+ bool isOldSectionclosed = theOldPolyline->IsClosedSection(isec);
+ TopoDS_Wire aWire = aCurves[isec]; // we suppose sections and wires are in the same order
+ TopExp_Explorer anExp(aWire, TopAbs_EDGE);
+ TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current()); // the first is OK: only one normally with splines
+ BRepAdaptor_Curve adaptorOldCurve(anEdge);
+ double pfirst = adaptorOldCurve.FirstParameter();
+ double plast = adaptorOldCurve.LastParameter();
+ DEBTRACE("previous curve first last : "<< pfirst << " " << plast);
+ double p[3] = {-1, -1};
+ double d0= ProjectPointToCurve(aEndPs[0].XYZ(), adaptorOldCurve,p[0]);
+ double d1= ProjectPointToCurve(aEndPs[1].XYZ(), adaptorOldCurve,p[1]);
+ double d2= ProjectPointToCurve(midPnt.XYZ(), adaptorOldCurve, p[2]);
+ DEBTRACE("d0: "<<d0<<" d1: "<<d1<<" d2: "<<d2<<" p0: "<<p[0]<<" p1: "<<p[1]<<" p2: "<<p[2]);
+ if ((d0 < 1.e-3) and (d1 < 1.e-3) and (d2 < 1.e-3)) // we got the good old curve (and the good section)
+ {
+ double pmin = p[0];
+ double pmax = p[1];
+ bool forward = true;
+ if (! isOldSectionclosed) // no need to check first and last points on an open curve
+ {
+ pmin = p[1];
+ pmax = p[0];
+ forward = false;
+ }
+ else // old section closed: check if we use first or last points...
+ {
+ if((pmin < pmax) and((abs(pmin - pfirst)> 1.e-3) and (abs(pmax - plast) >1.e-3))) // internal points forward
+ forward = true;
+ else if ((pmin > pmax) and((abs(pmin - plast)> 1.e-3) and (abs(pmax - pfirst) >1.e-3))) // internal points reverse
+ {
+ pmin = p[1];
+ pmax = p[0];
+ forward = false;
+ }
+ else if ((abs(pmin - plast) <1.e-3) and (p[2] < pmax)) // forward, replace pmin par pfirst
+ pmin = pfirst;
+ else if ((abs(pmin - plast) <1.e-3) and (p[2] > pmax)) // reverse
+ {
+ pmin = p[1];
+ pmax = p[0];
+ forward = false;
+ }
+ else if ((abs(pmax - pfirst) <1.e-3) and (p[2] < pmin)) // reverse
+ {
+ pmin = p[1];
+ pmax = p[0];
+ forward = false;
+ }
+ else if ((abs(pmax - pfirst) <1.e-3) and (p[2] > pmin)) // forward, replace pmax par plast
+ pmax = plast;
+ }
+ HYDROData_PolylineXY::Point aFirstPoint, aLastPoint;
+ if (forward)
+ {
+ aFirstPoint = HYDROData_PolylineXY::Point(aEndPs[0].X(), aEndPs[0].Y());
+ aLastPoint = HYDROData_PolylineXY::Point(aEndPs[1].X(), aEndPs[1].Y());
+ }
+ else
+ {
+ aFirstPoint = HYDROData_PolylineXY::Point(aEndPs[1].X(), aEndPs[1].Y());
+ aLastPoint = HYDROData_PolylineXY::Point(aEndPs[0].X(), aEndPs[0].Y());
+ }
+ aPointsList.Append(aFirstPoint);
+
+ HYDROData_PolylineXY::PointsList aSectPoints = theOldPolyline->GetPoints(isec, false);
+ int nbPoints = aSectPoints.Length();
+ if (forward)
+ for (int i=1; i<nbPoints; i++)
+ {
+ HYDROData_PolylineXY::Point aPoint = aSectPoints.Value(i);
+ gp_XYZ p(aPoint.X(), aPoint.Y(), 0);
+ double param =-1;
+ double d = ProjectPointToCurve(p, adaptorOldCurve, param);
+ if ((param > pmin) and (param < pmax))
+ {
+ DEBTRACE("param: " << param);
+ aPointsList.Append(aPoint);
+ }
+ }
+ else
+ for (int i=nbPoints -1; i>0; i--)
+ {
+ HYDROData_PolylineXY::Point aPoint = aSectPoints.Value(i);
+ gp_XYZ p(aPoint.X(), aPoint.Y(), 0);
+ double param =-1;
+ double d = ProjectPointToCurve(p, adaptorOldCurve, param);
+ if ((param > pmin) and (param < pmax))
+ {
+ DEBTRACE("param: " << param);
+ aPointsList.Append(aPoint);
+ }
+ }
+
+ aPointsList.Append(aLastPoint);
+ }
+
+ }
+ }
}
if ( aPointsList.IsEmpty() )
bool HYDROData_PolylineXY::ImportShape( const TopoDS_Shape& theShape,
bool IsInterpolationAllowed,
+ const Handle( HYDROData_PolylineXY )& theOldPolyline,
bool IsClosureAllowed,
double theDeviation )
{
TopoDS_Edge anEdge = TopoDS::Edge( theShape );
// anIsCanBeImported = convertEdgeToSection( anEdge, aSectNames, aSectTypes,
// aSectClosures, aSectPoints, true, IsInterpolationAllowed, theDeviation );
- anIsCanBeImported = convertEdgesToSections( anEdge, aSectNames, aSectTypes,
- aSectClosures, aSectPoints, IsClosureAllowed, IsInterpolationAllowed, theDeviation );
+ anIsCanBeImported = convertEdgesToSections( anEdge, aSectNames, aSectTypes, aSectClosures,
+ aSectPoints, IsClosureAllowed, IsInterpolationAllowed,
+ theDeviation, theOldPolyline );
}
else if ( theShape.ShapeType() == TopAbs_WIRE )
{
for ( int i = 1, n = anEdges.Length(); i <= n && anIsCanBeImported; ++i )
{
TopoDS_Edge aWireEdge = TopoDS::Edge( anEdges.Value( i ) );
- anIsCanBeImported = convertEdgesToSections( aWireEdge, aSectNames, aSectTypes,
- aSectClosures, aSectPoints, IsClosureAllowed, IsInterpolationAllowed, theDeviation );
+ anIsCanBeImported = convertEdgesToSections( aWireEdge, aSectNames, aSectTypes, aSectClosures,
+ aSectPoints, IsClosureAllowed, IsInterpolationAllowed,
+ theDeviation, theOldPolyline );
}
}
