// Created on: 1993-08-12 // Created by: Bruno DUMORTIER // Copyright (c) 1993-1999 Matra Datavision // Copyright (c) 1999-2014 OPEN CASCADE SAS // // This file is part of Open CASCADE Technology software library. // // This library is free software; you can redistribute it and/or modify it under // the terms of the GNU Lesser General Public License version 2.1 as published // by the Free Software Foundation, with special exception defined in the file // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT // distribution for complete text of the license and disclaimer of any warranty. // // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. // Modified by xab, Tue Mar 11 18:31:18 1997 // Modified by PMN 14/04/97 : Passage a Geomlite // Modified by JPI 01/08/97 : ajout de la commande approxcurve #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef _WIN32 Standard_IMPORT Draw_Viewer dout; #endif //======================================================================= //function : anacurve //purpose : //======================================================================= static Standard_Integer anacurve (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 5) return 1; Handle(Geom_Geometry) result; Handle(Geom2d_Curve) result2d; if (!strcmp(a[0],"line")) { if (n == 6) result2d = new Geom2d_Line(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))); else if (n == 8) result = new Geom_Line(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))); else return 1; } else if (!strcmp(a[0],"circle")) { if (n == 5) result2d = new Geom2d_Circle(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(1,0)), Draw::Atof(a[4])); else if (n == 6) result = new Geom_Circle(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(0,0,1)), Draw::Atof(a[5])); else if (n == 7) result2d = new Geom2d_Circle(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))), Draw::Atof(a[6])); else if (n == 9) result = new Geom_Circle(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))), Draw::Atof(a[8])); else if (n == 12) result = new Geom_Circle(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])), gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))), Draw::Atof(a[11])); else return 1; } else if (!strcmp(a[0],"parabola")) { if (n == 5) result2d = new Geom2d_Parabola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(1,0)), Draw::Atof(a[4])); else if (n == 6) result = new Geom_Parabola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(0,0,1)), Draw::Atof(a[5])); else if (n == 7) result2d = new Geom2d_Parabola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))), Draw::Atof(a[6])); else if (n == 9) result = new Geom_Parabola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))), Draw::Atof(a[8])); else if (n == 12) result = new Geom_Parabola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])), gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))), Draw::Atof(a[11])); else return 1; } else if (!strcmp(a[0],"ellipse")) { if (n == 6) result2d = new Geom2d_Ellipse(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(1,0)), Draw::Atof(a[4]),Draw::Atof(a[5])); else if (n == 7) result = new Geom_Ellipse(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(0,0,1)), Draw::Atof(a[5]),Draw::Atof(a[6])); else if (n == 8) result2d = new Geom2d_Ellipse(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))), Draw::Atof(a[6]), Draw::Atof(a[7])); else if (n == 10) result = new Geom_Ellipse(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))), Draw::Atof(a[8]), Draw::Atof(a[9])); else if (n == 13) result = new Geom_Ellipse(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])), gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))), Draw::Atof(a[11]), Draw::Atof(a[12])); else return 1; } else if (!strcmp(a[0],"hyperbola")) { if (n == 6) result2d = new Geom2d_Hyperbola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(1,0)), Draw::Atof(a[4]),Draw::Atof(a[5])); else if (n == 7) result = new Geom_Hyperbola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(0,0,1)), Draw::Atof(a[5]),Draw::Atof(a[6])); else if (n == 8) result2d = new Geom2d_Hyperbola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])), gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))), Draw::Atof(a[6]), Draw::Atof(a[7])); else if (n == 10) result = new Geom_Hyperbola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))), Draw::Atof(a[8]), Draw::Atof(a[9])); else if (n == 13) result = new Geom_Hyperbola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])), gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])), gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))), Draw::Atof(a[11]), Draw::Atof(a[12])); else return 1; } if (!result.IsNull()) DrawTrSurf::Set(a[1],result); else if (!result2d.IsNull()) DrawTrSurf::Set(a[1],result2d); else return 1; return 0; } //======================================================================= //function : polecurve //purpose : //======================================================================= static Standard_Integer polecurve (Draw_Interpretor& , Standard_Integer n, const char** a) { Standard_Integer k,i; if (n < 3) return 1; if (!strcmp(a[0],"beziercurve")) { Standard_Integer np = Draw::Atoi(a[2]); if (np == 0) return 1; i = (n - 3) / (np); if (i < 3 || i > 4) return 1; Standard_Boolean hasw = i == 4; TColgp_Array1OfPnt poles(1,np); TColStd_Array1OfReal weights(1,np); k = 3; for (i = 1; i <= np; i++) { poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]),Draw::Atof(a[k+2])); k += 3; if (hasw) { weights(i) = Draw::Atof(a[k]); k++; } } Handle(Geom_BezierCurve) result; if (hasw) result = new Geom_BezierCurve(poles,weights); else result = new Geom_BezierCurve(poles); DrawTrSurf::Set(a[1],result); } else if (!strcmp((*a[0] == 'p') ? a[0]+1 : a[0],"bsplinecurve")) { Standard_Integer deg = Draw::Atoi(a[2]); Standard_Integer nbk = Draw::Atoi(a[3]); TColStd_Array1OfReal knots(1, nbk); TColStd_Array1OfInteger mults(1, nbk); k = 4; Standard_Integer Sigma = 0; for (i = 1; i<=nbk; i++) { knots( i) = Draw::Atof(a[k]); k++; mults( i) = Draw::Atoi(a[k]); Sigma += mults(i); k++; } Standard_Boolean periodic = *a[0] == 'p'; Standard_Integer np; if (periodic) np = Sigma - mults(nbk); else np = Sigma - deg -1; TColgp_Array1OfPnt poles (1, np); TColStd_Array1OfReal weights(1, np); for (i = 1; i <= np; i++) { poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]),Draw::Atof(a[k+2])); k += 3; weights(i) = Draw::Atof(a[k]); k++; } Handle(Geom_BSplineCurve) result = new Geom_BSplineCurve(poles, weights, knots, mults, deg, periodic); DrawTrSurf::Set(a[1],result); } return 0; } //======================================================================= //function : polecurve2d //purpose : //======================================================================= static Standard_Integer polecurve2d (Draw_Interpretor& , Standard_Integer n, const char** a) { Standard_Integer k,i; if (n < 3) return 1; if (!strcmp(a[0],"2dbeziercurve")) { Standard_Integer np = Draw::Atoi(a[2]); if (np == 0) return 1; i = (n - 2) / (np); if (i < 2 || i > 3) return 1; Standard_Boolean hasw = i == 3; TColgp_Array1OfPnt2d poles(1,np); TColStd_Array1OfReal weights(1,np); k = 3; for (i = 1; i <= np; i++) { poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1])); k += 2; if (hasw) { weights(i) = Draw::Atof(a[k]); k++; } } Handle(Geom2d_BezierCurve) result; if (hasw) result = new Geom2d_BezierCurve(poles,weights); else result = new Geom2d_BezierCurve(poles); DrawTrSurf::Set(a[1],result); } else if (!strcmp((*(a[0]+2) == 'p') ? a[0]+3 : a[0]+2,"bsplinecurve")) { Standard_Integer deg = Draw::Atoi(a[2]); Standard_Integer nbk = Draw::Atoi(a[3]); TColStd_Array1OfReal knots(1, nbk); TColStd_Array1OfInteger mults(1, nbk); k = 4; Standard_Integer Sigma = 0; for (i = 1; i<=nbk; i++) { knots( i) = Draw::Atof(a[k]); k++; mults( i) = Draw::Atoi(a[k]); Sigma += mults(i); k++; } Standard_Boolean periodic = *(a[0]+2) == 'p'; Standard_Integer np; if (periodic) np = Sigma - mults(nbk); else np = Sigma - deg -1; TColgp_Array1OfPnt2d poles (1, np); TColStd_Array1OfReal weights(1, np); for (i = 1; i <= np; i++) { poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1])); k += 2; weights(i) = Draw::Atof(a[k]); k++; } Handle(Geom2d_BSplineCurve) result = new Geom2d_BSplineCurve(poles, weights, knots, mults, deg, periodic); DrawTrSurf::Set(a[1],result); } return 0; } //======================================================================= //function : reverse //purpose : //======================================================================= static Standard_Integer reverse (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 2) return 1; Standard_Integer i; for (i = 1; i < n; i++) { Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[i]); if (!GC.IsNull()) { GC->Reverse(); Draw::Repaint(); } Handle(Geom2d_Curve) GC2d = DrawTrSurf::GetCurve2d(a[i]); if (!GC2d.IsNull()) { GC2d->Reverse(); Draw::Repaint(); } } return 0; } //======================================================================= //function : cmovepole //purpose : //======================================================================= static Standard_Integer cmovepole (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 5) return 1; Standard_Real dx = Draw::Atof(a[3]); Standard_Real dy = Draw::Atof(a[4]); Standard_Real dz=0; if (n >= 6) dz = Draw::Atof(a[5]); Standard_Integer Index = Draw::Atoi(a[2]); Handle(Geom_BezierCurve) G1 = DrawTrSurf::GetBezierCurve(a[1]); if (!G1.IsNull()) { gp_Pnt P = G1->Pole(Index); P.SetCoord(P.X()+dx, P.Y()+dy, P.Z()+dz); G1->SetPole(Index,P); Draw::Repaint(); return 0; } Handle(Geom_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve(a[1]); if (!G2.IsNull()) { gp_Pnt P = G2->Pole(Index); P.SetCoord(P.X()+dx, P.Y()+dy, P.Z()+dz); G2->SetPole(Index,P); Draw::Repaint(); return 0; } Handle(Geom2d_BezierCurve) G3 = DrawTrSurf::GetBezierCurve2d(a[1]); if (!G3.IsNull()) { gp_Pnt2d P = G3->Pole(Index); P.SetCoord(P.X()+dx, P.Y()+dy); G3->SetPole(Index,P); Draw::Repaint(); return 0; } Handle(Geom2d_BSplineCurve) G4 = DrawTrSurf::GetBSplineCurve2d(a[1]); if (!G4.IsNull()) { gp_Pnt2d P = G4->Pole(Index); P.SetCoord(P.X()+dx, P.Y()+dy); G4->SetPole(Index,P); Draw::Repaint(); return 0; } return 0; } //======================================================================= //function : cmovetangent //purpose : //======================================================================= static Standard_Integer cmovetangent (Draw_Interpretor& di, Standard_Integer n, const char** a) { Standard_Integer dimension, condition, error_status ; Standard_Real u, x, y, z, tolerance, tx, ty, tz ; u = Draw::Atof(a[2]); x = Draw::Atof(a[3]); y = Draw::Atof(a[4]); z = 0.0e0, tolerance = 1.0e-5 ; dimension = 3 ; if (n <= 8) { dimension = 2 ; if (n < 7) { return 1 ; } } else { dimension = 3 ; if (n < 9) { return 1 ; } } condition = 0 ; error_status = 0 ; if (dimension == 3) { Handle(Geom_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve(a[1]); if (!G2.IsNull()) { z = Draw::Atof(a[5]) ; tx = Draw::Atof(a[6]) ; ty = Draw::Atof(a[7]) ; tz = Draw::Atof(a[8]) ; if (n == 10) { condition = Max(Draw::Atoi(a[9]), -1) ; condition = Min(condition, G2->Degree()-1) ; } gp_Pnt p; gp_Vec tangent ; p.SetCoord(x,y,z); tangent.SetCoord(tx,ty,tz) ; G2->MovePointAndTangent(u, p, tangent, tolerance, condition, condition, error_status) ; if (! error_status) { Draw::Repaint(); } else { di << "Not enought degree of freedom increase degree please\n"; } return 0; } } else { Handle(Geom2d_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve2d(a[1]); if (!G2.IsNull()) { tx = Draw::Atof(a[5]) ; ty = Draw::Atof(a[6]) ; if (n == 8) { condition = Max(Draw::Atoi(a[7]), -1) ; condition = Min(condition, G2->Degree()-1) ; } gp_Pnt2d p; gp_Vec2d tangent ; p.SetCoord(x,y); tangent.SetCoord(tx,ty) ; G2->MovePointAndTangent(u, p, tangent, tolerance, condition, condition, error_status) ; if (! error_status) { Draw::Repaint(); } else { di << "Not enought degree of freedom increase degree please\n"; } return 0; } } return 0; } //======================================================================= //function : cmovepoint //purpose : //======================================================================= static Standard_Integer cmovepoint (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 5) return 1; Standard_Real dx = Draw::Atof(a[3]); Standard_Real dy = Draw::Atof(a[4]); Standard_Real dz=0; if (n >= 6 && n != 7) dz = Draw::Atof(a[5]); Standard_Real u = Draw::Atof(a[2]); Standard_Integer index1 = 0; Standard_Integer index2 = 0; Standard_Integer fmodif, lmodif; if (n == 7) { index1 = Draw::Atoi(a[5]); index2 = Draw::Atoi(a[6]); } else if (n == 8) { index1 = Draw::Atoi(a[6]); index2 = Draw::Atoi(a[7]); } Handle(Geom_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve(a[1]); if (!G2.IsNull()) { if (index1 == 0) { index1 = 2; index2 = G2->NbPoles()-1; } gp_Pnt p; G2->D0(u, p); p.SetCoord(p.X()+dx, p.Y()+dy, p.Z()+dz); G2->MovePoint(u, p, index1, index2, fmodif, lmodif); Draw::Repaint(); return 0; } Handle(Geom2d_BSplineCurve) G4 = DrawTrSurf::GetBSplineCurve2d(a[1]); if (!G4.IsNull()) { if (index1 == 0) { index1 = 2; index2 = G4->NbPoles()-1; } gp_Pnt2d p; G4->D0(u, p); p.SetCoord(p.X()+dx, p.Y()+dy); G4->MovePoint(u, p, index1, index2, fmodif, lmodif); Draw::Repaint(); return 0; } return 0; } //======================================================================= //function : cinsertknot //purpose : //======================================================================= static Standard_Integer cinsertknot (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 4) return 1; Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); if (GBs.IsNull() && GBs2d.IsNull()) return 1; if (n <= 4) { Standard_Real knot = Draw::Atof(a[2]); Standard_Integer mult = 1; if (n == 4) mult = Draw::Atoi(a[3]); if (!GBs.IsNull()) GBs->InsertKnot(knot,mult,Precision::PConfusion()); else GBs2d->InsertKnot(knot,mult,Precision::PConfusion()); } else { // multiple insertion if (n % 2 != 0) return 1; Standard_Integer i,nbk = (n-2) / 2; TColStd_Array1OfReal knots(1,nbk); TColStd_Array1OfInteger mults(1,nbk); for (i = 2; i < n; i += 2) { knots(i/2) = Draw::Atof(a[i]); mults(i/2) = Draw::Atoi(a[i+1]); } if (!GBs.IsNull()) GBs->InsertKnots(knots,mults,Precision::PConfusion()); else GBs2d->InsertKnots(knots,mults,Precision::PConfusion()); } Draw::Repaint(); return 0; } //======================================================================= //function : csetknot //purpose : //======================================================================= static Standard_Integer csetknot (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 4) return 1; Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); if (GBs.IsNull() && GBs2d.IsNull()) return 1; Standard_Integer index = Draw::Atoi(a[2]); Standard_Real knot = Draw::Atof(a[3]); if ( n == 4) { if (!GBs.IsNull()) GBs->SetKnot(index,knot); else GBs2d->SetKnot(index,knot); } else { Standard_Integer mult = Draw::Atoi(a[4]); if (!GBs.IsNull()) GBs->SetKnot(index,knot,mult); else GBs2d->SetKnot(index,knot,mult); } Draw::Repaint(); return 0; } //======================================================================= //function : cremknot //purpose : //======================================================================= static Standard_Integer cremknot (Draw_Interpretor& di, Standard_Integer n, const char** a) { if (n < 3) return 1; Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); if (GBs.IsNull() && GBs2d.IsNull()) return 1; Standard_Integer index = Draw::Atoi(a[2]); Standard_Integer mult = 0; if (n >= 4) mult = Draw::Atoi(a[3]); Standard_Real tol = RealLast(); if (n >= 5) tol = Draw::Atof(a[4]); if (!GBs.IsNull()) { if (!GBs->RemoveKnot(index,mult,tol)) di << "Remove knots failed\n"; } else { if (!GBs2d->RemoveKnot(index,mult,tol)) di << "Remove knots failed\n"; } Draw::Repaint(); return 0; } //======================================================================= //function : increasedegree //purpose : //======================================================================= static Standard_Integer increasedegree (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 3) return 1; Standard_Integer Deg = Draw::Atoi(a[2]); Handle(Geom_BezierCurve) GBz = DrawTrSurf::GetBezierCurve(a[1]); Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BezierCurve) GBz2d = DrawTrSurf::GetBezierCurve2d(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); if (!GBz.IsNull()) GBz->Increase(Deg); else if (!GBs.IsNull()) GBs->IncreaseDegree(Deg); else if (!GBz2d.IsNull()) GBz2d->Increase(Deg); else if (!GBs2d.IsNull()) GBs2d->IncreaseDegree(Deg); else return 1; Draw::Repaint(); return 0; } //======================================================================= //function : removepole //purpose : //======================================================================= static Standard_Integer removepole (Draw_Interpretor& di, Standard_Integer n, const char** a) { if (n < 3) return 1; Standard_Integer Index = Draw::Atoi(a[2]); Handle(Geom_BezierCurve) GBZ = DrawTrSurf::GetBezierCurve(a[1]); Handle(Geom2d_BezierCurve) GBZ2d = DrawTrSurf::GetBezierCurve2d(a[1]); if (!GBZ.IsNull()) { GBZ->RemovePole(Index); } else if (!GBZ2d.IsNull()) { GBZ2d->RemovePole(Index); } else { di << "rempole needs a bezier curve"; return 1; } Draw::Repaint(); return 0; } //======================================================================= //function : insertpole //purpose : //======================================================================= static Standard_Integer insertpole (Draw_Interpretor& di, Standard_Integer n, const char** a) { if (n < 6) return 1; Standard_Integer Index = Draw::Atoi(a[2]); Handle(Geom_BezierCurve) GBZ = DrawTrSurf::GetBezierCurve(a[1]); Handle(Geom2d_BezierCurve) GBZ2d = DrawTrSurf::GetBezierCurve2d(a[1]); if (!GBZ.IsNull()) { gp_Pnt P (Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5])); if ( n == 7) GBZ->InsertPoleAfter(Index,P,Draw::Atof(a[6])); else GBZ->InsertPoleAfter(Index,P); } else if (!GBZ2d.IsNull()) { gp_Pnt2d P (Draw::Atof(a[3]),Draw::Atof(a[4])); if ( n == 6) GBZ2d->InsertPoleAfter(Index,P,Draw::Atof(a[5])); else GBZ2d->InsertPoleAfter(Index,P); } else { di << "insertpole needs a bezier curve"; return 1; } Draw::Repaint(); return 0; } //======================================================================= //function : cfindp //purpose : //======================================================================= static Standard_Integer cfindp (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 6) return 1; Standard_Integer Index = 0; Standard_Integer view = Draw::Atoi(a[2]); Standard_Real x = Draw::Atof(a[3]); Standard_Real y = Draw::Atof(a[4]); Draw_Display d = dout.MakeDisplay(view); Handle(Draw_Drawable3D) D = Draw::Get(a[1]); Handle(DrawTrSurf_BezierCurve) DBz = Handle(DrawTrSurf_BezierCurve)::DownCast(D); if( !DBz.IsNull()) DBz->FindPole( x, y, d, 5, Index); else { Handle(DrawTrSurf_BSplineCurve) DBs = Handle(DrawTrSurf_BSplineCurve)::DownCast(D); if (!DBs.IsNull()) DBs->FindPole( x, y, d, 5, Index); else { Handle(DrawTrSurf_BezierCurve2d) DBz2d = Handle(DrawTrSurf_BezierCurve2d)::DownCast(D); if( !DBz2d.IsNull()) DBz2d->FindPole( x, y, d, 5, Index); else { Handle(DrawTrSurf_BSplineCurve2d) DBs2d = Handle(DrawTrSurf_BSplineCurve2d)::DownCast(D); if (!DBs2d.IsNull()) DBs2d->FindPole( x, y, d, 5, Index); else return 1; } } } Draw::Set(a[5],Index); return 0; } //======================================================================= //function : csetperiodic //purpose : //======================================================================= static Standard_Integer csetperiodic (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 2) return 1; Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); if (GBs.IsNull() && GBs2d.IsNull()) return 1; if (!strcmp(a[0],"setperiodic")) { if (!GBs.IsNull()) GBs->SetPeriodic(); else GBs2d->SetPeriodic(); } else if (!strcmp(a[0],"setnotperiodic")) { if (!GBs.IsNull()) GBs->SetNotPeriodic(); else GBs2d->SetNotPeriodic(); } Draw::Repaint(); return 0; } //======================================================================= //function : value //purpose : //======================================================================= static Standard_Integer value (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 4) return 1; Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[1]); if (GC.IsNull()) return 1; Standard_Real U = Draw::Atof(a[2]); Standard_Boolean DrawPoint = ( n%3 == 1); if ( DrawPoint) n--; gp_Pnt P; if (n > 6) { if (n < 9) return 1; gp_Vec D1; if (n > 9) { if (n < 12) return 1; gp_Vec D2; GC->D2(U,P,D1,D2); Draw::Set(a[9] ,D2.X()); Draw::Set(a[10],D2.Y()); Draw::Set(a[11],D2.Z()); } else GC->D1(U,P,D1); Draw::Set(a[6],D1.X()); Draw::Set(a[7],D1.Y()); Draw::Set(a[8],D1.Z()); } else GC->D0(U,P); if ( n > 3) { Draw::Set(a[3],P.X()); Draw::Set(a[4],P.Y()); Draw::Set(a[5],P.Z()); } if ( DrawPoint) { DrawTrSurf::Set(a[n],P); } return 0; } //======================================================================= //function : value2d //purpose : //======================================================================= static Standard_Integer value2d (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 4) return 1; Handle(Geom2d_Curve) GC = DrawTrSurf::GetCurve2d(a[1]); if (GC.IsNull()) return 1; Standard_Real U = Draw::Atof(a[2]); Standard_Boolean DrawPoint = ( n%2 == 0); if ( DrawPoint ) n--; gp_Pnt2d P; if (n > 5) { if (n < 7) return 1; gp_Vec2d D1; if (n > 7) { if (n < 9) return 1; gp_Vec2d D2; GC->D2(U,P,D1,D2); Draw::Set(a[7] ,D2.X()); Draw::Set(a[8],D2.Y()); } else GC->D1(U,P,D1); Draw::Set(a[5],D1.X()); Draw::Set(a[6],D1.Y()); } else GC->D0(U,P); if ( n > 3 ) { Draw::Set(a[3],P.X()); Draw::Set(a[4],P.Y()); } if ( DrawPoint ) { DrawTrSurf::Set(a[n], P); } return 0; } //======================================================================= //function : segment //purpose : //======================================================================= static Standard_Integer segment (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 4) return 1; Handle(Geom_BezierCurve) GBz = DrawTrSurf::GetBezierCurve(a[1]); Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BezierCurve) GBz2d = DrawTrSurf::GetBezierCurve2d(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); Standard_Real f = Draw::Atof(a[2]), l = Draw::Atof(a[3]); if (!GBz.IsNull()) GBz->Segment(f,l); else if (!GBs.IsNull()) GBs->Segment(f,l); else if (!GBz2d.IsNull()) GBz2d->Segment(f,l); else if (!GBs2d.IsNull()) GBs2d->Segment(f,l); else return 1; Draw::Repaint(); return 0; } //======================================================================= //function : setorigin //purpose : //======================================================================= static Standard_Integer setorigin (Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 3) return 1; Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]); Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]); if (!GBs.IsNull()) GBs->SetOrigin(Draw::Atoi(a[2])); if (!GBs2d.IsNull()) GBs2d->SetOrigin(Draw::Atoi(a[2])); else return 1; Draw::Repaint(); return 0; } //======================================================================= //function : point //purpose : //======================================================================= static Standard_Integer point(Draw_Interpretor& , Standard_Integer n, const char** a) { if (n < 4) return 1; if (n >= 5) { gp_Pnt P(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])); DrawTrSurf::Set(a[1],P); } else { gp_Pnt2d P(Draw::Atof(a[2]),Draw::Atof(a[3])); DrawTrSurf::Set(a[1],P); } return 0; } //======================================================================= //function : coord //purpose : //======================================================================= static Standard_Integer coord(Draw_Interpretor&, Standard_Integer n, const char** a) { if ( n == 4) { gp_Pnt2d P; if ( !DrawTrSurf::GetPoint2d(a[1],P)) return 1; Draw::Set(a[2],P.X()); Draw::Set(a[3],P.Y()); } else if ( n == 5) { gp_Pnt P; if ( !DrawTrSurf::GetPoint(a[1],P)) return 1; Draw::Set(a[2],P.X()); Draw::Set(a[3],P.Y()); Draw::Set(a[4],P.Z()); } else return 1; return 0; } //======================================================================= //function : //purpose : //======================================================================= static Standard_Integer minmaxcurandinf(Draw_Interpretor& di, Standard_Integer argc, const char** argv) { if (argc < 2) return 1; Handle(Geom2d_Curve) C1 = DrawTrSurf::GetCurve2d(argv[1]); if (C1.IsNull()) return 1; Draw_Color Couleur; Geom2dLProp_CurAndInf2d Sommets; Sommets.PerformCurExt (C1); if (Sommets.IsDone() && !Sommets.IsEmpty()) { for (Standard_Integer i = 1; i <= Sommets.NbPoints(); i++){ Couleur = Draw_vert; if (Sommets.Type(i) == LProp_MinCur) { Couleur = Draw_orange; di << " Maximum of curvature at U ="<Value(Sommets.Parameter(i)); Handle(Draw_Marker2D) dr = new Draw_Marker2D(P,Draw_Plus,Couleur); dout << dr; } dout.Flush(); } Geom2dLProp_CurAndInf2d Sommets2; Sommets2.PerformInf (C1); if (Sommets2.IsDone() && !Sommets2.IsEmpty()) { for (Standard_Integer i = 1; i <= Sommets2.NbPoints(); i++){ gp_Pnt2d P = C1->Value(Sommets2.Parameter(i)); Handle(Draw_Marker2D) dr = new Draw_Marker2D(P,Draw_Plus,Draw_bleu); dout << dr; di << " Inflexion at U ="<ShowCurvature(); } else { C2d->ShowCurvature(); } Draw::Repaint(); return 0; } //======================================================================= //function : clcurvature //purpose : efface le peigne de courbure //======================================================================= static Standard_Integer clcurvature(Draw_Interpretor&, Standard_Integer argc, const char** argv) { if (argc < 2) return 1; Handle(DrawTrSurf_Curve2d) C2d = Handle(DrawTrSurf_Curve2d) ::DownCast(Draw::Get(argv[1])); Handle(DrawTrSurf_Curve) C3d = Handle(DrawTrSurf_Curve) ::DownCast(Draw::Get(argv[1])); if (C2d.IsNull()) { if (C3d.IsNull()) return 1; C3d->ClearCurvature(); } else { C2d->ClearCurvature(); } Draw::Repaint(); return 0; } //======================================================================= //function : radiusmax //purpose : definit le rayon de courbure maximum a afficher //======================================================================= static Standard_Integer radiusmax(Draw_Interpretor&, Standard_Integer argc, const char** argv) { if (argc < 3) return 1; Standard_Real Radius = Draw::Atof(argv[2]); Handle(DrawTrSurf_Curve2d) C2d = Handle(DrawTrSurf_Curve2d) ::DownCast(Draw::Get(argv[1])); Handle(DrawTrSurf_Curve) C3d = Handle(DrawTrSurf_Curve) ::DownCast(Draw::Get(argv[1])); if (C2d.IsNull()) { if (C3d.IsNull()) return 1; C3d->SetRadiusMax(Radius); } else { C2d->SetRadiusMax(Radius); } Draw::Repaint(); return 0; } //======================================================================= //function : radiusratio //purpose : definit le ratio du rayon de courbure a afficher //======================================================================= static Standard_Integer radiusratio(Draw_Interpretor&, Standard_Integer argc, const char** argv) { if (argc < 3) return 1; Standard_Real Ratio = Draw::Atof(argv[2]); Handle(DrawTrSurf_Curve2d) C2d = Handle(DrawTrSurf_Curve2d) ::DownCast(Draw::Get(argv[1])); Handle(DrawTrSurf_Curve) C3d = Handle(DrawTrSurf_Curve) ::DownCast(Draw::Get(argv[1])); if (C2d.IsNull()) { if (C3d.IsNull()) return 1; C3d->SetRadiusRatio(Ratio); } else { C2d->SetRadiusRatio(Ratio); } Draw::Repaint(); return 0; } //======================================================================= //function : //purpose : //======================================================================= static Standard_Integer localprop(Draw_Interpretor& di, Standard_Integer argc, const char** argv) { if (argc < 3) return 1; Standard_Real U = Draw::Atof(argv[2]); Handle(Geom2d_Curve) C2d = DrawTrSurf::GetCurve2d(argv[1]); Handle(Geom_Curve) C3d; if (C2d.IsNull()) { C3d = DrawTrSurf::GetCurve(argv[1]); if (C3d.IsNull()) return 1; GeomLProp_CLProps Prop (C3d,2,Precision::Confusion()); Prop.SetParameter(U); Handle(Draw_Marker3D)drp = new Draw_Marker3D(Prop.Value(), Draw_Plus, Draw_vert ); dout << drp; if (Prop.IsTangentDefined()) { Standard_Real K = Prop.Curvature(); di <<" Curvature : "< Precision::Confusion()) { Standard_Real R = 1/Abs(K); gp_Pnt Center; Prop.CentreOfCurvature(Center); gp_Dir Tang; gp_Dir Nor; Prop.Tangent(Tang); Prop.Normal(Nor); gp_Dir AxC = Nor^Tang; gp_Ax2 Axe(Center,AxC,Nor); Handle(Geom_Circle) Cir3d = new Geom_Circle(Axe,R); Handle(DrawTrSurf_Curve) dr; dr = new DrawTrSurf_Curve(Cir3d); dout << dr; dout.Flush(); } } else di <<"Tangent undefined.\n"; } else { Geom2dLProp_CLProps2d Prop (C2d,2,Precision::Confusion()); Prop.SetParameter(U); Handle(Draw_Marker2D) drp = new Draw_Marker2D(Prop.Value(), Draw_Plus, Draw_vert); dout << drp; if (Prop.IsTangentDefined()) { Standard_Real K = Prop.Curvature(); gp_Pnt2d Center; di <<" Curvature : "< Precision::Confusion()) { Standard_Real R = 1/Abs(K); Prop.CentreOfCurvature(Center); gp_Ax2d Axe(Center,gp::DX2d()); Handle(Geom2d_Circle) Cir2d = new Geom2d_Circle(Axe,R); Handle(DrawTrSurf_Curve2d) dr; dr = new DrawTrSurf_Curve2d(Cir2d,Draw_rouge,30,Standard_False); dout << dr; dout.Flush(); } } else di <<"Tangent undefined.\n"; } return 0; } //======================================================================= //function : rawcont //purpose : //======================================================================= static Standard_Integer rawcont(Draw_Interpretor& di, Standard_Integer n, const char** a) { if (n < 5) return 1; Handle(Geom_Curve) GC1; GC1 = DrawTrSurf::GetCurve(a[1]); Handle(Geom_Curve) GC2; GC2 = DrawTrSurf::GetCurve(a[2]); Standard_Real param1 = Draw::Atof(a[3]) ; Standard_Real param2 = Draw::Atof(a[4]) ; if (GC1.IsNull() || GC2.IsNull()) return 1; gp_Pnt a_point1, a_point2 ; GC1->D0(param1, a_point1) ; GC2->D0(param2, a_point2) ; if (a_point2.SquareDistance(a_point1) < Precision::Confusion()) { GeomAbs_Shape cont = GeomLProp::Continuity(GC1, GC2, param1, param2, Standard_True, Standard_True, Precision::Confusion(), Precision::Angular()) ; switch (cont) { case GeomAbs_C0: di << " C0 Continuity \n" ; break ; case GeomAbs_G1: di << " G1 Continuity \n" ; break ; case GeomAbs_C1 : di << " C1 Continuity \n" ; break ; case GeomAbs_G2 : di << " G2 Continuity \n" ; break ; case GeomAbs_C2 : di << " C2 Continuity \n" ; break ; case GeomAbs_C3 : di << " C3 Continuity \n" ; break ; case GeomAbs_CN : di << " CN Continuity \n" ; break ; default: break ; } } else { di << " not C0 continuity \n" ; } return 0 ; } //======================================================================= //function : approxcurveonsurf //purpose : //======================================================================= static Standard_Integer approxcurveonsurf(Draw_Interpretor& di, Standard_Integer n, const char** a) { Standard_Real Tol = 1.e-7; // Tolerance (default 0.1mm) GeomAbs_Shape Continuity = GeomAbs_C1; // Continuity order : 0, 1 or 2 (default 1) Standard_Integer MaxDeg = 14; // Maximum degree Standard_Integer MaxSeg = 16; /*1*/ // Maximum number of segments if ( n>8 || n<4) return 1; if (n>4) Tol = Max(Draw::Atof(a[4]),1.e-10); if (n>5) { if (Draw::Atoi(a[5]) == 0) Continuity = GeomAbs_C0; if (Draw::Atoi(a[5]) == 2) Continuity = GeomAbs_C2; } if (n>6) { MaxDeg = Draw::Atoi(a[6]); if (MaxDeg<1 || MaxDeg>14) MaxDeg = 14; } if (n>7) MaxSeg = Draw::Atoi(a[7]); Handle(Geom2d_Curve) curve2d = DrawTrSurf::GetCurve2d(a[2]); Handle(Geom_Surface) Surf = DrawTrSurf::GetSurface(a[3]); Handle(Geom2dAdaptor_HCurve) A2d = new (Geom2dAdaptor_HCurve)(curve2d); Handle(GeomAdaptor_HSurface) AS = new (GeomAdaptor_HSurface)(Surf); Approx_CurveOnSurface App(A2d, AS, A2d->FirstParameter(), A2d->LastParameter(), Tol, Continuity, MaxDeg, MaxSeg, Standard_True, Standard_False); if(App.HasResult()) { Handle(Geom_BSplineCurve) BSCurve = App.Curve3d(); DrawTrSurf::Set(a[1], BSCurve); return 0; } di << "Approximation failed !\n"; return 1; } //======================================================================= //function : approxcurve //purpose : //======================================================================= static Standard_Integer approxcurve(Draw_Interpretor& di, Standard_Integer n, const char** a) { Standard_Real Tol = 1.e-7; // Tolerance (default 0.1mm) GeomAbs_Shape Continuity = GeomAbs_C1; // Continuity order : 0, 1 or 2 (default 1) Standard_Integer MaxDeg = 14; // Maximum degree Standard_Integer MaxSeg = 16; // Maximum number of segments Standard_Integer Case, shift; // Case == 1 : 3d approximation without reparametrization // Case == 2 : 2d approximation without reparametrization // Case == 3 : 3d approximation with reparametrization // Case == 4 : curve_on_surface approximation with reparametrization // Case == 5 : 2 curves_on_surfaces approximation with reparametrization Handle(Geom_Curve) curve; Handle(Geom2d_Curve) curve2d, curve2d2; Handle(Geom_Surface) surface, surface2; if(n < 2) return 1; if (!strcmp(a[1],"-L")) { // aproximation with curvilinear abscissa reparametrization if (n > 11 || n < 4) return 1; Tol = 1.e-4; curve = DrawTrSurf::GetCurve(a[3]); if (!curve.IsNull()) { shift = 4; Case = 3; } else { // approx curve_on_surface if (n < 5) return 1; curve2d = DrawTrSurf::GetCurve2d(a[3]); surface = DrawTrSurf::GetSurface(a[4]); if (curve2d.IsNull() || surface.IsNull()) { return 1; } if (n >= 7) { curve2d2 = DrawTrSurf::GetCurve2d(a[5]); surface2 = DrawTrSurf::GetSurface(a[6]); if (curve2d2.IsNull() || surface2.IsNull()) { shift = 5; Case = 4; } else { // approx 2 curves_on_surfaces shift = 7; Case = 5; } } else { shift = 5; Case = 4; } } } else { // aproximation without reparamitrization if ( n>7 || n<3) return 1; shift = 3; curve = DrawTrSurf::GetCurve(a[2]); if (curve.IsNull()) { curve2d = DrawTrSurf::GetCurve2d(a[2]); if (curve2d.IsNull()) { return 1; } Case = 2; } else Case = 1; } if (n>shift) Tol = Max(Draw::Atof(a[shift]),1.e-10); if (n>shift+1) { if (Draw::Atoi(a[shift+1]) == 0) Continuity = GeomAbs_C0; if (Draw::Atoi(a[shift+1]) == 2) Continuity = GeomAbs_C2; } if (n>shift+2) { MaxDeg = Draw::Atoi(a[shift+2]); if (MaxDeg<1 || MaxDeg>14) MaxDeg = 14; } if (n>shift+3) MaxSeg = Draw::Atoi(a[shift+3]); if (Case == 1) { GeomConvert_ApproxCurve appr(curve, Tol, Continuity, MaxSeg, MaxDeg); if(appr.HasResult()) { //appr.Dump(cout); Standard_SStream aSStream; appr.Dump(aSStream); di << aSStream; Handle(Geom_BSplineCurve) BSCurve = appr.Curve(); DrawTrSurf::Set(a[1], BSCurve); } } else if (Case == 2) { Geom2dConvert_ApproxCurve appr(curve2d, Tol, Continuity, MaxSeg, MaxDeg); if(appr.HasResult()) { //appr.Dump(cout); Standard_SStream aSStream; appr.Dump(aSStream); di << aSStream; Handle(Geom2d_BSplineCurve) BSCurve = appr.Curve(); DrawTrSurf::Set(a[1], BSCurve); } } else if (Case == 3) { Handle(Adaptor3d_HCurve) HACur = new GeomAdaptor_HCurve(curve); Approx_CurvilinearParameter appr(HACur, Tol, Continuity, MaxDeg, MaxSeg); if(appr.HasResult()) { //appr.Dump(cout); Standard_SStream aSStream; appr.Dump(aSStream); di << aSStream; Handle(Geom_BSplineCurve) BSCurve = appr.Curve3d(); DrawTrSurf::Set(a[2], BSCurve); } } else if (Case == 4) { Handle(Adaptor2d_HCurve2d) HACur2d = new Geom2dAdaptor_HCurve(curve2d); Handle(Adaptor3d_HSurface) HASur = new GeomAdaptor_HSurface(surface); Approx_CurvilinearParameter appr(HACur2d, HASur, Tol, Continuity, MaxDeg, MaxSeg); if(appr.HasResult()) { //appr.Dump(cout); Standard_SStream aSStream; appr.Dump(aSStream); di << aSStream; Handle(Geom_BSplineCurve) BSCurve = appr.Curve3d(); DrawTrSurf::Set(a[2], BSCurve); } } else if (Case == 5) { Handle(Adaptor2d_HCurve2d) HACur2d = new Geom2dAdaptor_HCurve(curve2d); Handle(Adaptor3d_HSurface) HASur = new GeomAdaptor_HSurface(surface); Handle(Adaptor2d_HCurve2d) HACur2d2 = new Geom2dAdaptor_HCurve(curve2d2); Handle(Adaptor3d_HSurface) HASur2 = new GeomAdaptor_HSurface(surface2); Approx_CurvilinearParameter appr(HACur2d, HASur, HACur2d2, HASur2, Tol, Continuity, MaxDeg, MaxSeg); if(appr.HasResult()) { //appr.Dump(cout); Standard_SStream aSStream; appr.Dump(aSStream); di << aSStream; Handle(Geom_BSplineCurve) BSCurve = appr.Curve3d(); DrawTrSurf::Set(a[2], BSCurve); } } return 0; } //======================================================================= //function : newbspline //purpose : reduce the multiplicity of the knots to their minimum // compared to the degree of the curve //======================================================================= static Standard_Integer splitc1(Draw_Interpretor& di, Standard_Integer n, const char** c) {Standard_Real tolerance=1.0e-5, angular_tolerance = 1.0e-4 ; Standard_Integer optiontab,i; char name[100]; if (n<3) return 1; optiontab=Draw::Atoi(c[2]); if (n >= 4 ) tolerance=Draw::Atof(c[3]); if (n >= 5) { angular_tolerance = Draw::Atof(c[4]) ; } Handle(Geom_Curve) ACurve = Handle(Geom_Curve)::DownCast(DrawTrSurf::Get(c[1])) ; Standard_Real f = ACurve->FirstParameter(); Standard_Real l = ACurve->LastParameter(); if ( Precision::IsInfinite(f) || Precision::IsInfinite(l)) { di << " Error: Infinite curves\n"; return 1; } Handle(Geom_BSplineCurve) BS = GeomConvert::CurveToBSplineCurve(ACurve); if ( BS.IsNull()) return 1; if (optiontab){ Handle(TColGeom_HArray1OfBSplineCurve) tabBS; GeomConvert::C0BSplineToArrayOfC1BSplineCurve(BS, tabBS, angular_tolerance, tolerance); for (i=0;i<=(tabBS->Length()-1);i++){ Sprintf(name,"%s_%d",c[1],i+1); Standard_CString new_name = name ; DrawTrSurf::Set(new_name, tabBS->Value(i)); di.AppendElement(name); } } else{ GeomConvert::C0BSplineToC1BSplineCurve(BS, tolerance, angular_tolerance) ; DrawTrSurf::Set(c[1],BS); } return 0; } //======================================================================= //function : splitc12d //purpose : reduce the multiplicity of the knots to their minimum // compared to the degree of the curve //======================================================================= static Standard_Integer splitc12d(Draw_Interpretor& di, Standard_Integer n, const char** c) {Standard_Real tolerance=1.0e-5, angular_tolerance = 1.0e-4 ; Standard_Integer optiontab,i; char name[100]; if (n<3) return 1; optiontab=Draw::Atoi(c[2]); if (n==4) tolerance=Draw::Atof(c[3]); if (n==5) angular_tolerance = Draw::Atof(c[4]) ; Handle(Geom2d_Curve) ACurve = DrawTrSurf::GetCurve2d(c[1]); Standard_Real f = ACurve->FirstParameter(); Standard_Real l = ACurve->LastParameter(); if ( Precision::IsInfinite(f) || Precision::IsInfinite(l)) { di << " Error: Infinite curves\n"; return 1; } Handle(Geom2d_BSplineCurve) BS = Geom2dConvert::CurveToBSplineCurve(ACurve); if ( BS.IsNull()) return 1; if (optiontab){ Handle(TColGeom2d_HArray1OfBSplineCurve) tabBS; Geom2dConvert::C0BSplineToArrayOfC1BSplineCurve(BS, tabBS, angular_tolerance, tolerance); for (i=0;i<=(tabBS->Length()-1);i++){ Sprintf(name,"%s_%d",c[1],i+1); Standard_CString new_name = name ; DrawTrSurf::Set(new_name, tabBS->Value(i)); di.AppendElement(name); } } else{ Geom2dConvert::C0BSplineToC1BSplineCurve(BS,tolerance); DrawTrSurf::Set(c[1],BS); } return 0; } //======================================================================= //function : canceldenom //purpose : set the value of the denominator cancel its first // derivative on the boundaries of the surface if possible //======================================================================= static Standard_Integer canceldenom(Draw_Interpretor& , Standard_Integer n, const char** c) {Standard_Integer uoption,voption; Standard_Boolean udirection=Standard_False; Standard_Boolean vdirection=Standard_False; if (n<4) return 1; uoption=Draw::Atoi(c[2]); voption=Draw::Atoi(c[3]); if (uoption) udirection=Standard_True; if (voption) vdirection=Standard_True; Handle(Geom_BSplineSurface) BSurf = DrawTrSurf::GetBSplineSurface(c[1]); GeomLib::CancelDenominatorDerivative(BSurf,udirection,vdirection); DrawTrSurf::Set(c[1],BSurf); return 0; } //======================================================================= //function : length //purpose : eval curve's length //======================================================================= static Standard_Integer length(Draw_Interpretor& di, Standard_Integer n, const char** a) { if (n<2) return 1; Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[1]); Handle(Geom2d_Curve) GC2d = DrawTrSurf::GetCurve2d(a[1]); Standard_Real Tol = Precision::Confusion(), L; if (n==3) Tol = Draw::Atof(a[2]); if (!GC.IsNull()) { GeomAdaptor_Curve AC(GC); L = GCPnts_AbscissaPoint::Length(AC, Tol); } else if (!GC2d.IsNull()) { Geom2dAdaptor_Curve AC(GC2d); L = GCPnts_AbscissaPoint::Length(AC, Tol); } else { di << a[1] << "is not a curve\n"; return 1; } di << "The length " << a[1] << " is " << L << "\n"; return 0; } //======================================================================= //function : CurveCommands //purpose : //======================================================================= void GeomliteTest::CurveCommands(Draw_Interpretor& theCommands) { static Standard_Boolean loaded = Standard_False; if (loaded) return; loaded = Standard_True; DrawTrSurf::BasicCommands(theCommands); const char* g; // analytic curves g = "GEOMETRY curves creation"; theCommands.Add("point", "point name x y [z]", __FILE__, point ,g); theCommands.Add("line", "line name pos dir", __FILE__, anacurve,g); theCommands.Add("circle", "circle name x y [z [dx dy dz]] [ux uy [uz]] radius", __FILE__, anacurve,g); theCommands.Add("ellipse", "ellipse name x y [z [dx dy dz]] [ux uy [uz]] major minor", __FILE__, anacurve,g); theCommands.Add("parabola", "parabola name x y [z [dx dy dz]] [ux uy [uz]] focal", __FILE__, anacurve,g); theCommands.Add("hyperbola", "hyperbola name x y [z [dx dy dz]] [ux uy [uz]] major minor", __FILE__, anacurve,g); theCommands.Add("beziercurve", "beziercurve name nbpole pole, [weight]", __FILE__, polecurve,g); theCommands.Add("bsplinecurve", "bsplinecurve name degree nbknots knot, umult pole, weight", __FILE__, polecurve,g); theCommands.Add("pbsplinecurve", "pbsplinecurve name degree nbknots knot, umult pole, weight (periodic)", __FILE__, polecurve,g); theCommands.Add("2dbeziercurve", "2dbeziercurve name nbpole pole, [weight]", __FILE__, polecurve2d,g); theCommands.Add("2dbsplinecurve", "2dbsplinecurve name degree nbknots knot, umult pole, weight", __FILE__, polecurve2d,g); theCommands.Add("2dpbsplinecurve", "2dpbsplinecurve name degree nbknots knot, umult pole, weight (periodic)", __FILE__, polecurve2d,g); g = "GEOMETRY Curves and Surfaces modification"; theCommands.Add("reverse", "reverse name ... ", __FILE__, reverse,g); theCommands.Add("cmovep", "cmovep name index dx dy dz", __FILE__, cmovepole,g); theCommands.Add("cmovepoint", "cmovepoint name u dx dy [dz index1 index2]", __FILE__, cmovepoint,g); theCommands.Add("cmovetangent", "cmovetangent name u x y [z] tx ty [tz constraint = 0]", __FILE__, cmovetangent,g) ; theCommands.Add("insertknot", "insertknot name knot [mult = 1] [knot mult ...]", __FILE__, cinsertknot,g); theCommands.Add("setknot", "setknot name index knot [mult]", __FILE__, csetknot,g); theCommands.Add("remknot", "remknot name index [mult] [tol]", __FILE__, cremknot,g); theCommands.Add("incdeg", "incdeg name degree", __FILE__, increasedegree,g); theCommands.Add("rempole", "rempole name index", __FILE__, removepole,g); theCommands.Add("insertpole", "insertpole name index x y [z] [weight]", __FILE__, insertpole,g); theCommands.Add("cfindp", "cfindp name view x y index", __FILE__, cfindp,g); theCommands.Add("setperiodic", "setperiodic name ...", __FILE__, csetperiodic,g); theCommands.Add("setnotperiodic", "setnotperiodic name", __FILE__, csetperiodic,g); theCommands.Add("segment", "segment name Ufirst Ulast", __FILE__, segment , g); theCommands.Add("setorigin", "setorigin name knotindex", __FILE__, setorigin , g); g = "GEOMETRY curves and surfaces analysis"; theCommands.Add("cvalue", "cvalue curvename U X Y Z [D1X D1Y D1Z D2X D2Y D2Z]", __FILE__, value,g); theCommands.Add("2dcvalue", "2dcvalue curvename U X Y [D1X D1Y D2X D2Y]", __FILE__, value2d,g); theCommands.Add("coord", "coord P x y [z]: set in x y [z] the coordinates of P", __FILE__, coord,g); theCommands.Add("minmaxcurandinf", "minmaxcurandinf curve", __FILE__, minmaxcurandinf,g); theCommands.Add("shcurvature", "shcurvature curvename", __FILE__, shcurvature,g); theCommands.Add("clcurvature", "clcurvature curvename", __FILE__, clcurvature,g); theCommands.Add("radiusmax", "radiusmax curvename radius", __FILE__, radiusmax,g); theCommands.Add("radiusratio", "radiusratio curvename ratio", __FILE__, radiusratio,g); theCommands.Add("localprop", "localprop curvename U", __FILE__, localprop,g); theCommands.Add("rawcont", "rawcont curve1 curve2 u1 u2", __FILE__, rawcont,g) ; theCommands.Add("approxcurve", "approxcurve [-L] name curve1 [Surf1] [curve2d2 Surf2] [Tol [cont [maxdeg [maxseg]]]] ", __FILE__, approxcurve,g); theCommands.Add("approxcurveonsurf", "approxcurveonsurf name curve2d surface [Tol [cont [maxdeg [maxseg]]]] ", __FILE__, approxcurveonsurf,g); theCommands.Add("length", "length curve [Tol]", __FILE__, length, g); theCommands.Add("splitc1", "splitc1 bspline resultinarray(0/1) [tol] [angtol] ", __FILE__, splitc1,g); theCommands.Add("splitc12d", "splitc12d bspline2d resultinarray(0/1) [tol] [angtol] ", __FILE__, splitc12d,g); theCommands.Add("canceldenom", "canceldenom BSpline-Surface UDirection(0/1) VDirection(0/1)", __FILE__, canceldenom,g); }