#include <BRepBuilderAPI_MakeWire.hxx>
#include <TColgp_HArray1OfPnt.hxx>
+#include <TColStd_HArray1OfBoolean.hxx>
+#include <TColgp_Array1OfVec.hxx>
#include <GeomAPI_Interpolate.hxx>
#include <ProjLib.hxx>
//=======================================================================
gp_Pnt CurveCreator_Utils::ConvertClickToPoint( int x, int y, Handle(V3d_View) aView )
{
- return GEOMUtils::ConvertClickToPoint( x, y, aView );
+ // the 3D point, that is a projection of the pixels to the XYZ view plane
+ //return GEOMUtils::ConvertClickToPoint( x, y, aView );
+
+ // we need the projection to the XOY plane
+ // 1. find a point in the plane of the eye and the normal to the plane
+ Standard_Real X, Y, Z;
+ Quantity_Parameter Vx, Vy, Vz;
+ aView->ConvertWithProj( x, y, X, Y, Z, Vx, Vy, Vz );
+
+ // 2. build a ray from the point by the normal to the XOY plane and intersect it
+ // The ray equation is the following : p(x,y,z) = p0(x,y,z) + t*V(x,y,z)
+ // X,Y,Z - defines p0(x,y,z), Vx,Vy,Vz - defines V(x,y,z)
+ // p(x,y,z) - is a searched point, t - should to be calculated by the condition of XOY plane
+ // The system of equations is the following:
+ // p(x) = p0(x)+t*V(x)
+ // p(y) = p0(y)+t*V(y)
+ // p(z) = p0(z)+t*V(z)
+ // p(z) = 0
+
+ Standard_Real aXp, aYp, aZp;
+ //It is not possible to use Precision::Confusion(), because it is e-0.8, but V is sometimes e-6
+ Standard_Real aPrec = LOCAL_SELECTION_TOLERANCE;
+ if ( fabs( Vz ) > aPrec ) {
+ Standard_Real aT = -Z/Vz;
+ aXp = X + aT*Vx;
+ aYp = Y + aT*Vy;
+ aZp = Z + aT*Vz;
+ }
+ else { // Vz = 0 - the eyed plane is orthogonal to Z plane - XOZ, or YOZ
+ aXp = aYp = aZp = 0;
+ if ( fabs( Vy ) < aPrec ) // Vy = 0 - the YOZ plane
+ aYp = Y;
+ else if ( fabs( Vx ) < aPrec ) // Vx = 0 - the XOZ plane
+ aXp = X;
+ }
+ /*std::cout << "ConvertClickToPoint: " << std::endl
+ << "XYZ1 = (" << X << ", " << Y << ", " << Z << "); " << std::endl
+ << "Vxyz = (" << Vx << ", " << Vy << ", " << Vz << "); " << std::endl
+ << "Resp = (" << aXp << ", " << aYp << ", " << aZp << "); " << std::endl;*/
+
+ gp_Pnt ResultPoint( aXp, aYp, aZp );
+ return ResultPoint;
}
void CurveCreator_Utils::constructShape( const CurveCreator_ICurve* theCurve,
CurveCreator::SectionType aSectType = theCurve->getSectionType( theISection );
int aPointSize = theCurve->getNbPoints( theISection );
+ if ( aPointSize == 0 )
+ continue;
+
bool aSectIsClosed = theCurve->isClosed( theISection );
bool isPolyline = aSectType == CurveCreator::Polyline;
+
int iPoint = 0;
gp_Pnt aPrevPoint, aPoint;
- if ( aPointSize == 1 ) {
+ // filters the curve points to skip equal points
+ std::vector<gp_Pnt> aPoints;
+ CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+ aPoints.push_back( aPoint );
+ aPrevPoint = aPoint;
+ iPoint++;
+ for( ; iPoint < aPointSize; iPoint++ ) {
CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+ if ( !isEqualPoints( aPrevPoint, aPoint ) )
+ aPoints.push_back( aPoint );
+ aPrevPoint = aPoint;
+ }
+ int aNbPoints = aPoints.size();
+
+ if ( aNbPoints == 1 ) {
+ aPoint = aPoints.front();
TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
aBuilder.Add( aComp, aVertex );
}
- else if ( aPointSize > 1 ) {
- Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt (1, aPointSize);
- int aHIndex = 1;
+ else if ( aNbPoints > 1 ) {
+ Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt(1, aNbPoints);
+ TColgp_Array1OfVec aTangents(1, aNbPoints);
+ Handle(TColStd_HArray1OfBoolean) aTangentFlags = new TColStd_HArray1OfBoolean(1, aNbPoints);
+ gp_Vec aNullVec(0, 0, 0);
TopoDS_Edge aPointEdge;
TopoDS_Vertex aVertex;
- CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+
+ std::vector<gp_Pnt>::const_iterator aPointIt = aPoints.begin(), aPointLast = aPoints.end();
+ aPoint = *aPointIt;
+
+ int aHIndex = 1;
aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
aBuilder.Add( aComp, aVertex );
- aHCurvePoints->SetValue(aHIndex++, aPoint);
+ if ( !isPolyline ) {
+ aHCurvePoints->SetValue( aHIndex, aPoint );
+ aTangents.SetValue( aHIndex, aNullVec );
+ aTangentFlags->SetValue( aHIndex, Standard_False );
+ aHIndex++;
+ }
+
aPrevPoint = aPoint;
- iPoint++;
- for( ; iPoint < aPointSize; iPoint++ ) {
- CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+ aPointIt++;
+ for( ; aPointIt != aPointLast; aPointIt++ ) {
+ aPoint = *aPointIt;
aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
aBuilder.Add( aComp, aVertex );
- aHCurvePoints->SetValue(aHIndex++, aPoint);
if ( isPolyline ) {
- aPointEdge = BRepBuilderAPI_MakeEdge( aPrevPoint, aPoint ).Edge();
+ TopoDS_Edge aPointEdge = BRepBuilderAPI_MakeEdge( aPrevPoint, aPoint ).Edge();
aBuilder.Add( aComp, aPointEdge );
}
+ else {
+ aHCurvePoints->SetValue( aHIndex, aPoint );
+ aTangents.SetValue( aHIndex, aNullVec );
+ aTangentFlags->SetValue( aHIndex, Standard_False );
+ aHIndex++;
+ }
aPrevPoint = aPoint;
}
- if( aSectIsClosed && ( aPointSize > 2 ) ) {
- CurveCreator_UtilsICurve::getPoint( theCurve, theISection, 0, aPoint );
+ if( aSectIsClosed && ( aNbPoints > 2 ) ) {
+ aPoint = aPoints.front();
aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
aBuilder.Add( aComp, aVertex );
if ( isPolyline ) {
// compute BSpline
Handle(Geom_BSplineCurve) aBSplineCurve;
GeomAPI_Interpolate aGBC(aHCurvePoints, aSectIsClosed, gp::Resolution());
+ // correct the spline degree to be as 3 for non-periodic spline if number of points
+ // less than 3. It is need to have a knot in each spline point. This knots are used
+ // to found a neighbour points when a new point is inserted between two existing.
+ if (!aSectIsClosed ) {
+ if (aHCurvePoints->Length() == 3)
+ aGBC.Load(aTangents, aTangentFlags);
+ }
+
aGBC.Perform();
if ( aGBC.IsDone() )
aBSplineCurve = aGBC.Curve();
theShape = aComp;
}
-class ComparePnt
+class CompareSectionToPoint
{
public:
- ComparePnt( const gp_Pnt& thePoint ) : myPoint( thePoint) {};
- ~ComparePnt() {}
+ CompareSectionToPoint( const int theISection = -1, const int theIPoint = -1 )
+ : mySectionId( theISection ), myPointId( theIPoint ) {};
+ ~CompareSectionToPoint() {}
- bool operator < ( const ComparePnt& theOtherPoint ) const
+ bool operator < ( const CompareSectionToPoint& theOther ) const
{
- bool isLess = myPoint.X() < theOtherPoint.myPoint.X();
- if ( !isLess && myPoint.X() == theOtherPoint.myPoint.X() ) {
- isLess = myPoint.Y() < theOtherPoint.myPoint.Y();
- if ( !isLess && myPoint.Y() == theOtherPoint.myPoint.Y() )
- isLess = myPoint.Z() < theOtherPoint.myPoint.Z();
- }
+ bool isLess = mySectionId < theOther.mySectionId;
+ if ( !isLess && mySectionId == theOther.mySectionId )
+ isLess = myPointId < theOther.myPointId;
return isLess;
}
+
private:
- gp_Pnt myPoint;
+ int mySectionId;
+ int myPointId;
};
+
void CurveCreator_Utils::getSelectedPoints( Handle(AIS_InteractiveContext) theContext,
const CurveCreator_ICurve* theCurve,
CurveCreator_ICurve::SectionToPointList& thePoints )
std::list<float> aSelectedPoints;
gp_Pnt aPnt;
- std::map<ComparePnt, int> aPntMap;
+ std::map<CompareSectionToPoint, int> aPointsMap;
CurveCreator_ICurve::SectionToPointList aPoints;
for ( theContext->InitSelected(); theContext->MoreSelected(); theContext->NextSelected() ) {
if ( aVertex.IsNull() )
continue;
aPnt = BRep_Tool::Pnt( aVertex );
- if ( aPntMap.find( aPnt ) != aPntMap.end() )
- continue;
- aPntMap[aPnt] = 0;
CurveCreator_UtilsICurve::findSectionsToPoints( theCurve, aPnt.X(), aPnt.Y(), aPoints );
CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aPoints.begin(),
aLast = aPoints.end();
- for ( ; anIt != aLast; anIt++ )
+ CompareSectionToPoint aPoint;
+ for ( ; anIt != aLast; anIt++ ) {
+ aPoint = CompareSectionToPoint( (*anIt).first, (*anIt).second );
+ if ( aPointsMap.find( aPoint ) != aPointsMap.end() )
+ continue;
+ aPointsMap[aPoint] = 0;
+
thePoints.push_back( *anIt );
+ }
}
}
return aXDelta < theTolerance && anYDelta < theTolerance;
}
+
+bool CurveCreator_Utils::isEqualPoints( const gp_Pnt& thePoint, const gp_Pnt& theOtherPoint )
+{
+ return theOtherPoint.IsEqual( thePoint, LOCAL_SELECTION_TOLERANCE );
+}
