[occt.git] / src / GeometryTest / GeometryTest_APICommands.cxx

// Created on: 1995-01-17
// Created by: Remi LEQUETTE
// Copyright (c) 1995-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.

#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <Draw.hxx>
#include <Draw_Interpretor.hxx>
#include <DrawTrSurf.hxx>
#include <Draw_Appli.hxx>
#include <GeometryTest.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <GeomAPI_ExtremaCurveCurve.hxx>
#include <GeomAPI_ExtremaCurveSurface.hxx>
#include <GeomAPI_ExtremaSurfaceSurface.hxx>
#include <GeomAPI_PointsToBSpline.hxx>
#include <GeomAPI_PointsToBSplineSurface.hxx>
#include <Geom_Line.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Draw_Segment3D.hxx>
#include <Draw_Marker3D.hxx>
#include <Draw_Color.hxx>
#include <Draw_MarkerShape.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <Precision.hxx>
#include <stdio.h>
#ifdef WNT
Standard_IMPORT Draw_Viewer dout;
#endif

//=======================================================================
//function : proj
//purpose  : 
//=======================================================================

static Standard_Integer proj (Draw_Interpretor& di, Standard_Integer n, const char** a)
  {
  if ( n < 5)
    {
    cout << " Use proj curve/surf x y z [extrema algo: g(grad)/t(tree)]" << endl;
    return 1;
    }

  gp_Pnt P(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]));

  char name[100];

  Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[1]);
  Handle(Geom_Surface) GS;
  Extrema_ExtAlgo aProjAlgo = Extrema_ExtAlgo_Grad;

  if (n == 6 && a[5][0] == 't')
    aProjAlgo = Extrema_ExtAlgo_Tree;

  if (GC.IsNull())
    {
    GS = DrawTrSurf::GetSurface(a[1]);
    
    if (GS.IsNull())
      return 1;

    Standard_Real U1, U2, V1, V2;
    GS->Bounds(U1,U2,V1,V2);

    GeomAPI_ProjectPointOnSurf proj(P,GS,U1,U2,V1,V2,aProjAlgo);

    Standard_Real UU,VV;
    for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
      {
      gp_Pnt P1 = proj.Point(i);
      if ( P.Distance(P1) > Precision::Confusion())
        {
        Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
        Handle(Geom_TrimmedCurve) CT = 
          new Geom_TrimmedCurve(L, 0., P.Distance(P1));
	Sprintf(name,"%s%d","ext_",i);
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, CT);
        di << name << " ";
        }
      else
        {
	Sprintf(name,"%s%d","ext_",i);
        di << name << " ";
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, P1);
        proj.Parameters(i,UU,VV);
        di << " Le point est sur la surface." << "\n";
        di << " Ses parametres sont:  UU = " << UU << "\n";
        di << "                       VV = " << VV << "\n";
        }
      }
    }
  else
    {
    GeomAPI_ProjectPointOnCurve proj(P,GC,GC->FirstParameter(),
                                                GC->LastParameter());

    if(proj.NbPoints() == 0)
      {
      cout << "No project point was found." << endl;
      return 0;
      }

    for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
      {
      gp_Pnt P1 = proj.Point(i);
      Standard_Real UU = proj.Parameter(i);
      di << " parameter " << i << " = " << UU << "\n";
      if ( P.Distance(P1) > Precision::Confusion())
        {
        Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
        Handle(Geom_TrimmedCurve) CT = 
                      new Geom_TrimmedCurve(L, 0., P.Distance(P1));
	Sprintf(name,"%s%d","ext_",i);
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, CT);
        di << name << " ";
        }
      else
        {
	Sprintf(name,"%s%d","ext_",i);
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, P1);
        di << name << " ";
        UU = proj.Parameter(i);
        di << " Le point est sur la courbe." << "\n";
        di << " Son parametre est U = " << UU << "\n";
        }
      }
    }

  return 0;
}

//=======================================================================
//function : appro
//purpose  : 
//=======================================================================

static Standard_Integer appro(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
  if ( n<3) return 1;

  Handle(Geom_Curve) GC;
  Standard_Integer Nb = Draw::Atoi(a[2]);

  TColgp_Array1OfPnt Points(1, Nb);

  Handle(Draw_Marker3D) mark;

  if ( n == 4) {
    GC = DrawTrSurf::GetCurve(a[3]);
    if ( GC.IsNull()) 
      return 1;

    Standard_Real U, U1, U2;
    U1 = GC->FirstParameter();
    U2 = GC->LastParameter();
    Standard_Real Delta = ( U2 - U1) / (Nb-1);
    for ( Standard_Integer i = 1 ; i <= Nb; i++) {
      U = U1 + (i-1) * Delta;
      Points(i) = GC->Value(U);
      mark = new Draw_Marker3D( Points(i), Draw_X, Draw_vert); 
      dout << mark;
    }
  }
  else {
    Standard_Integer id,XX,YY,b;
    dout.Select(id,XX,YY,b);
    Standard_Real zoom = dout.Zoom(id);

    Points(1) = gp_Pnt( ((Standard_Real)XX)/zoom, 
		        ((Standard_Real)YY)/zoom, 
		        0.);
    
    mark = new Draw_Marker3D( Points(1), Draw_X, Draw_vert); 
    
    dout << mark;
    
    for (Standard_Integer i = 2; i<=Nb; i++) {
      dout.Select(id,XX,YY,b);
      Points(i) = gp_Pnt( ((Standard_Real)XX)/zoom, 
			 ((Standard_Real)YY)/zoom, 
			 0.);
      mark = new Draw_Marker3D( Points(i), Draw_X, Draw_vert); 
      dout << mark;
    }
  }    
  dout.Flush();
  Standard_Integer Dmin = 3;
  Standard_Integer Dmax = 8;
  Standard_Real Tol3d = 1.e-3;
  
  Handle(Geom_BSplineCurve) TheCurve;
  GeomAPI_PointsToBSpline aPointToBSpline(Points,Dmin,Dmax,GeomAbs_C2,Tol3d);
  TheCurve = aPointToBSpline.Curve();

  
  DrawTrSurf::Set(a[1], TheCurve);
  di << a[1];

  return 0;

}


//=======================================================================
//function : grilapp
//purpose  : 
//=======================================================================

static Standard_Integer grilapp(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
  if ( n < 12) return 1;

  Standard_Integer i,j;
  Standard_Integer Nu = Draw::Atoi(a[2]);
  Standard_Integer Nv = Draw::Atoi(a[3]);
  TColStd_Array2OfReal ZPoints (1, Nu, 1, Nv);

  Standard_Real X0 = Draw::Atof(a[4]);
  Standard_Real dX = Draw::Atof(a[5]);
  Standard_Real Y0 = Draw::Atof(a[6]);
  Standard_Real dY = Draw::Atof(a[7]);

  Standard_Integer Count = 8;
  for ( j = 1; j <= Nv; j++) {
    for ( i = 1; i <= Nu; i++) {
      if ( Count > n) return 1;
      ZPoints(i,j) = Draw::Atof(a[Count]);
      Count++;
    }
  }
  
  Handle(Geom_BSplineSurface) S 
    = GeomAPI_PointsToBSplineSurface(ZPoints,X0,dX,Y0,dY);
  DrawTrSurf::Set(a[1],S);

  di << a[1];
  
  return 0;
}

//=======================================================================
//function : surfapp
//purpose  : 
//=======================================================================

static Standard_Integer surfapp(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
  if ( n < 5 ) return 1;

  Standard_Integer i,j;
  Standard_Integer Nu = Draw::Atoi(a[2]);
  Standard_Integer Nv = Draw::Atoi(a[3]);
  TColgp_Array2OfPnt Points (1, Nu, 1, Nv);

  if ( n == 5) {
    Handle(Geom_Surface) Surf = DrawTrSurf::GetSurface(a[4]);
    if ( Surf.IsNull()) return 1;

    Standard_Real U, V, U1, V1, U2, V2;
    Surf->Bounds( U1, U2, V1, V2);
    for ( j = 1; j <= Nv; j++) {
      V = V1 + (j-1) * (V2-V1) / (Nv-1);
      for ( i = 1; i <= Nu; i++) {
	U = U1 + (i-1) * (U2-U1) / (Nu-1);
	Points(i,j) = Surf->Value(U,V);
      }
    } 
  }
  else if ( n >= 16) {
    Standard_Integer Count = 4;
    for ( j = 1; j <= Nv; j++) {
      for ( i = 1; i <= Nu; i++) {
	if ( Count > n) return 1;
	Points(i,j) = gp_Pnt(Draw::Atof(a[Count]),Draw::Atof(a[Count+1]),Draw::Atof(a[Count+2]));
	Count += 3;
      }
    }
  }
  char name[100];
  Standard_Integer Count = 1;
  for ( j = 1; j <= Nv; j++) {
    for ( i = 1; i <= Nu; i++) {
      Sprintf(name,"point_%d",Count++);
      char* temp = name; // portage WNT
      DrawTrSurf::Set(temp,Points(i,j));
    }
  } 

  Handle(Geom_BSplineSurface) S = GeomAPI_PointsToBSplineSurface(Points);
  DrawTrSurf::Set(a[1],S);
  di << a[1];

  return 0;
}


//=======================================================================
//function : extrema
//purpose  : 
//=======================================================================

static Standard_Integer extrema(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
  if ( n<3) return 1;

  Handle(Geom_Curve)   GC1, GC2;
  Handle(Geom_Surface) GS1, GS2;

  Standard_Boolean C1 = Standard_False;
  Standard_Boolean C2 = Standard_False;
  Standard_Boolean S1 = Standard_False;
  Standard_Boolean S2 = Standard_False;

  Standard_Real U1f,U1l,U2f,U2l,V1f = 0.,V1l = 0.,V2f = 0.,V2l = 0.;

  GC1 = DrawTrSurf::GetCurve(a[1]);
  if ( GC1.IsNull()) {
    GS1 = DrawTrSurf::GetSurface(a[1]);
    if ( GS1.IsNull())
      return 1;
    S1 = Standard_True;
    GS1->Bounds(U1f,U1l,V1f,V1l);
  }
  else {
    C1 = Standard_True;
    U1f = GC1->FirstParameter();
    U1l = GC1->LastParameter();
  }

  GC2 = DrawTrSurf::GetCurve(a[2]);
  if ( GC2.IsNull()) {
    GS2 = DrawTrSurf::GetSurface(a[2]);
    if ( GS2.IsNull())
      return 1;
    S2 = Standard_True;
    GS2->Bounds(U2f,U2l,V2f,V2l);
  }
  else {
    C2 = Standard_True;
    U2f = GC2->FirstParameter();
    U2l = GC2->LastParameter();
  }

  char name[100];
  if ( C1 && C2)
    {
    GeomAPI_ExtremaCurveCurve Ex(GC1,GC2,U1f,U1l,U2f,U2l);

    if(!Ex.Extrema().IsParallel())
      {
      const Standard_Integer aNExtr = Ex.NbExtrema();
      if(aNExtr == 0)
        {
        di << "No solutions!\n";
        }
      else
        {
        for ( Standard_Integer i = 1; i <= aNExtr; i++)
          {
          gp_Pnt P1,P2;
          Ex.Points(i,P1,P2);
          Standard_Real U1,V1;
          Ex.Parameters(i,U1,V1);
          if (P1.Distance(P2) < 1.e-16)
            {
            di << "Extrema " << i << " is point : " << P1.X() << " " << P1.Y() << " " << P1.Z() << "\n";
            continue;
            }

          Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
          Handle(Geom_TrimmedCurve) CT = 
            new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
          Sprintf(name,"%s%d","ext_",i);
          char* temp = name; // portage WNT
          DrawTrSurf::Set(temp, CT);
#ifdef DEB          
          di << name << "(U=" << U1 << ";V=" << V1 << ")" << "\n";
#else
          di << name << " ";
#endif
          }
        }
      }
    else
      {
      di << "Infinite number of extremas, distance = " << Ex.LowerDistance() << "\n";
      }
    }
  else if ( C1 & S2)
    {
    GeomAPI_ExtremaCurveSurface Ex(GC1,GS2,U1f,U1l,U2f,U2l,V2f,V2l);

    const Standard_Integer aNExtr = Ex.NbExtrema();
    if(aNExtr == 0)
      {
      di << "No solutions!\n";
      }
    else
      {
      for ( Standard_Integer i = 1; i <= aNExtr; i++)
        {
        gp_Pnt P1,P2;
        Ex.Points(i,P1,P2);
        if (P1.Distance(P2) < 1.e-16) continue;
        Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
        Handle(Geom_TrimmedCurve) CT = 
          new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
        Sprintf(name,"%s%d","ext_",i);
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, CT);
        di << name << " ";
        }
      }
    }
  else if ( S1 & C2)
    {
    GeomAPI_ExtremaCurveSurface Ex(GC2,GS1,U2f,U2l,U1f,U1l,V1f,V1l);

    const Standard_Integer aNExtr = Ex.NbExtrema();
    if(aNExtr == 0)
      {
      di << "No solutions!\n";
      }
    else
      {
      for ( Standard_Integer i = 1; i <= aNExtr; i++)
        {
        gp_Pnt P1,P2;
        Ex.Points(i,P1,P2);
        if (P1.Distance(P2) < 1.e-16) continue;
        Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
        Handle(Geom_TrimmedCurve) CT = 
          new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
        Sprintf(name,"%s%d","ext_",i);
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, CT);
        di << name << " ";
        }
      }
    }
  else if ( S1 & S2)
    {
    GeomAPI_ExtremaSurfaceSurface Ex(GS1,GS2,U1f,U1l,V1f,V1l,U2f,U2l,V2f,V2l);

    const Standard_Integer aNExtr = Ex.NbExtrema();
    if(aNExtr == 0)
      {
      di << "No solutions!\n";
      }
    else
      {
      for ( Standard_Integer i = 1; i <= aNExtr; i++)
        {
        gp_Pnt P1,P2;
        Ex.Points(i,P1,P2);
        if (P1.Distance(P2) < 1.e-16)
          continue;

        Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
        Handle(Geom_TrimmedCurve) CT = 
          new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
        Sprintf(name,"%s%d","ext_",i);
        char* temp = name; // portage WNT
        DrawTrSurf::Set(temp, CT);
        di << name << " ";
        }
      }
    }

  return 0;
  }

//=======================================================================
//function : totalextcc
//purpose  : 
//=======================================================================

static Standard_Integer totalextcc(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
  if ( n<3) return 1;

  Handle(Geom_Curve)   GC1, GC2;


  Standard_Real U1f,U1l,U2f,U2l;

  GC1 = DrawTrSurf::GetCurve(a[1]);
  if ( GC1.IsNull()) {
      return 1;
  }
  else {
    U1f = GC1->FirstParameter();
    U1l = GC1->LastParameter();
  }

  GC2 = DrawTrSurf::GetCurve(a[2]);
  if ( GC2.IsNull()) {
      return 1;
  }
  else {
    U2f = GC2->FirstParameter();
    U2l = GC2->LastParameter();
  }

  char name[100];
    GeomAPI_ExtremaCurveCurve Ex(GC1,GC2,U1f,U1l,U2f,U2l);
  gp_Pnt P1,P2;
  if(Ex.TotalNearestPoints(P1,P2)) {
    if (P1.Distance(P2) < 1.e-16) {
      di << "Extrema is point : " << P1.X() << " " << P1.Y() << " " << P1.Z() << "\n";
    }
    else {
      di << "Extrema is segment of line" << "\n"; 
      Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
      Handle(Geom_TrimmedCurve) CT = 
	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
      Sprintf(name,"%s%d","ext_",1);
      char* temp = name; // portage WNT
      DrawTrSurf::Set(temp, CT);
      di << name << " ";
    }

    Standard_Real u1, u2;
    Ex.TotalLowerDistanceParameters(u1, u2);

    di << "Parameters on curves : " << u1 << " " << u2 << "\n";

  }
  else {
    di << "Curves are infinite and parallel" << "\n";
  }
  
  di << "Minimal distance : " << Ex.TotalLowerDistance() << "\n";

  return 0;

}


void GeometryTest::APICommands(Draw_Interpretor& theCommands)
{
  static Standard_Boolean done = Standard_False;
  if (done) return;

  done = Standard_True;

  theCommands.Add("proj", "proj curve/surf x y z [extrema algo: g(grad)/t(tree)]",__FILE__, proj);

  theCommands.Add("appro", "appro result nbpoint [curve]",__FILE__, appro);
  theCommands.Add("surfapp","surfapp result nbupoint nbvpoint x y z ....",
		  __FILE__,
		  surfapp);
  theCommands.Add("grilapp",
       "grilapp result nbupoint nbvpoint X0 dX Y0 dY z11 z12 .. z1nu ....  ",
        __FILE__,grilapp);

  theCommands.Add("extrema", "extrema curve/surface curve/surface",__FILE__,extrema);
  theCommands.Add("totalextcc", "totalextcc curve curve",__FILE__,totalextcc);
}
Commit	Line	Data
b311480e	1	// Created on: 1995-01-17
	2	// Created by: Remi LEQUETTE
	3	// Copyright (c) 1995-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
	17	#include <Geom_Curve.hxx>
	18	#include <Geom_Surface.hxx>
	19	#include <Draw.hxx>
	20	#include <Draw_Interpretor.hxx>
	21	#include <DrawTrSurf.hxx>
	22	#include <Draw_Appli.hxx>
	23	#include <GeometryTest.hxx>
	24	#include <GeomAPI_ProjectPointOnCurve.hxx>
	25	#include <GeomAPI_ProjectPointOnSurf.hxx>
	26	#include <GeomAPI_ExtremaCurveCurve.hxx>
	27	#include <GeomAPI_ExtremaCurveSurface.hxx>
	28	#include <GeomAPI_ExtremaSurfaceSurface.hxx>
	29	#include <GeomAPI_PointsToBSpline.hxx>
	30	#include <GeomAPI_PointsToBSplineSurface.hxx>
	31	#include <Geom_Line.hxx>
	32	#include <Geom_TrimmedCurve.hxx>
	33	#include <Draw_Segment3D.hxx>
	34	#include <Draw_Marker3D.hxx>
	35	#include <Draw_Color.hxx>
	36	#include <Draw_MarkerShape.hxx>
	37	#include <TColgp_Array1OfPnt.hxx>
	38	#include <TColgp_Array2OfPnt.hxx>
	39	#include <TColStd_Array2OfReal.hxx>
	40	#include <Precision.hxx>
	41	#include <stdio.h>
	42	#ifdef WNT
	43	Standard_IMPORT Draw_Viewer dout;
	44	#endif
	45
	46	//=======================================================================
	47	//function : proj
	48	//purpose :
	49	//=======================================================================
	50
	51	static Standard_Integer proj (Draw_Interpretor& di, Standard_Integer n, const char** a)
569aff1e	52	{
32ca7a51	53	if ( n < 5)
32ca7a51	54	{
569aff1e	55	cout << " Use proj curve/surf x y z [extrema algo: g(grad)/t(tree)]" << endl;
569aff1e	56	return 1;
32ca7a51	57	}
7fd59977	58
91322f44	59	gp_Pnt P(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]));
7fd59977	60
	61	char name[100];
	62
	63	Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[1]);
	64	Handle(Geom_Surface) GS;
569aff1e	65	Extrema_ExtAlgo aProjAlgo = Extrema_ExtAlgo_Grad;
32ca7a51	66
569aff1e	67	if (n == 6 && a[5][0] == 't')
569aff1e	68	aProjAlgo = Extrema_ExtAlgo_Tree;
7fd59977	69
32ca7a51	70	if (GC.IsNull())
32ca7a51	71	{
7fd59977	72	GS = DrawTrSurf::GetSurface(a[1]);
32ca7a51	73
7fd59977	74	if (GS.IsNull())
7fd59977	75	return 1;
32ca7a51	76
7fd59977	77	Standard_Real U1, U2, V1, V2;
	78	GS->Bounds(U1,U2,V1,V2);
	79
569aff1e	80	GeomAPI_ProjectPointOnSurf proj(P,GS,U1,U2,V1,V2,aProjAlgo);
32ca7a51	81
7fd59977	82	Standard_Real UU,VV;
32ca7a51	83	for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
32ca7a51	84	{
7fd59977	85	gp_Pnt P1 = proj.Point(i);
32ca7a51	86	if ( P.Distance(P1) > Precision::Confusion())
	87	{
	88	Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
	89	Handle(Geom_TrimmedCurve) CT =
	90	new Geom_TrimmedCurve(L, 0., P.Distance(P1));
91322f44	91	Sprintf(name,"%s%d","ext_",i);
32ca7a51	92	char* temp = name; // portage WNT
	93	DrawTrSurf::Set(temp, CT);
	94	di << name << " ";
	95	}
	96	else
	97	{
91322f44	98	Sprintf(name,"%s%d","ext_",i);
32ca7a51	99	di << name << " ";
	100	char* temp = name; // portage WNT
	101	DrawTrSurf::Set(temp, P1);
	102	proj.Parameters(i,UU,VV);
	103	di << " Le point est sur la surface." << "\n";
	104	di << " Ses parametres sont: UU = " << UU << "\n";
	105	di << " VV = " << VV << "\n";
	106	}
7fd59977	107	}
7fd59977	108	}
32ca7a51	109	else
32ca7a51	110	{
7fd59977	111	GeomAPI_ProjectPointOnCurve proj(P,GC,GC->FirstParameter(),
32ca7a51	112	GC->LastParameter());
	113
	114	if(proj.NbPoints() == 0)
	115	{
	116	cout << "No project point was found." << endl;
	117	return 0;
	118	}
	119
	120	for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
	121	{
7fd59977	122	gp_Pnt P1 = proj.Point(i);
	123	Standard_Real UU = proj.Parameter(i);
	124	di << " parameter " << i << " = " << UU << "\n";
32ca7a51	125	if ( P.Distance(P1) > Precision::Confusion())
	126	{
	127	Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
	128	Handle(Geom_TrimmedCurve) CT =
	129	new Geom_TrimmedCurve(L, 0., P.Distance(P1));
91322f44	130	Sprintf(name,"%s%d","ext_",i);
32ca7a51	131	char* temp = name; // portage WNT
	132	DrawTrSurf::Set(temp, CT);
	133	di << name << " ";
	134	}
	135	else
	136	{
91322f44	137	Sprintf(name,"%s%d","ext_",i);
32ca7a51	138	char* temp = name; // portage WNT
	139	DrawTrSurf::Set(temp, P1);
	140	di << name << " ";
	141	UU = proj.Parameter(i);
	142	di << " Le point est sur la courbe." << "\n";
	143	di << " Son parametre est U = " << UU << "\n";
	144	}
7fd59977	145	}
7fd59977	146	}
32ca7a51	147
7fd59977	148	return 0;
	149	}
	150
	151	//=======================================================================
	152	//function : appro
	153	//purpose :
	154	//=======================================================================
	155
	156	static Standard_Integer appro(Draw_Interpretor& di, Standard_Integer n, const char** a)
	157	{
	158	if ( n<3) return 1;
	159
	160	Handle(Geom_Curve) GC;
91322f44	161	Standard_Integer Nb = Draw::Atoi(a[2]);
7fd59977	162
	163	TColgp_Array1OfPnt Points(1, Nb);
	164
	165	Handle(Draw_Marker3D) mark;
	166
	167	if ( n == 4) {
	168	GC = DrawTrSurf::GetCurve(a[3]);
	169	if ( GC.IsNull())
	170	return 1;
	171
	172	Standard_Real U, U1, U2;
	173	U1 = GC->FirstParameter();
	174	U2 = GC->LastParameter();
	175	Standard_Real Delta = ( U2 - U1) / (Nb-1);
	176	for ( Standard_Integer i = 1 ; i <= Nb; i++) {
	177	U = U1 + (i-1) * Delta;
	178	Points(i) = GC->Value(U);
	179	mark = new Draw_Marker3D( Points(i), Draw_X, Draw_vert);
	180	dout << mark;
	181	}
	182	}
	183	else {
	184	Standard_Integer id,XX,YY,b;
	185	dout.Select(id,XX,YY,b);
	186	Standard_Real zoom = dout.Zoom(id);
	187
	188	Points(1) = gp_Pnt( ((Standard_Real)XX)/zoom,
	189	((Standard_Real)YY)/zoom,
	190	0.);
	191
	192	mark = new Draw_Marker3D( Points(1), Draw_X, Draw_vert);
	193
	194	dout << mark;
	195
	196	for (Standard_Integer i = 2; i<=Nb; i++) {
	197	dout.Select(id,XX,YY,b);
	198	Points(i) = gp_Pnt( ((Standard_Real)XX)/zoom,
	199	((Standard_Real)YY)/zoom,
	200	0.);
	201	mark = new Draw_Marker3D( Points(i), Draw_X, Draw_vert);
	202	dout << mark;
	203	}
	204	}
	205	dout.Flush();
	206	Standard_Integer Dmin = 3;
	207	Standard_Integer Dmax = 8;
	208	Standard_Real Tol3d = 1.e-3;
	209
	210	Handle(Geom_BSplineCurve) TheCurve;
	211	GeomAPI_PointsToBSpline aPointToBSpline(Points,Dmin,Dmax,GeomAbs_C2,Tol3d);
	212	TheCurve = aPointToBSpline.Curve();
	213
	214
	215	DrawTrSurf::Set(a[1], TheCurve);
	216	di << a[1];
	217
	218	return 0;
	219
	220	}
	221
	222
	223	//=======================================================================
	224	//function : grilapp
	225	//purpose :
226	//=======================================================================
227
228	static Standard_Integer grilapp(Draw_Interpretor& di, Standard_Integer n, const char** a)
229	{
230	if ( n < 12) return 1;
231
232	Standard_Integer i,j;
91322f44	233	Standard_Integer Nu = Draw::Atoi(a[2]);
91322f44	234	Standard_Integer Nv = Draw::Atoi(a[3]);
7fd59977	235	TColStd_Array2OfReal ZPoints (1, Nu, 1, Nv);
7fd59977	236
91322f44	237	Standard_Real X0 = Draw::Atof(a[4]);
	238	Standard_Real dX = Draw::Atof(a[5]);
	239	Standard_Real Y0 = Draw::Atof(a[6]);
	240	Standard_Real dY = Draw::Atof(a[7]);
7fd59977	241
	242	Standard_Integer Count = 8;
	243	for ( j = 1; j <= Nv; j++) {
	244	for ( i = 1; i <= Nu; i++) {
	245	if ( Count > n) return 1;
91322f44	246	ZPoints(i,j) = Draw::Atof(a[Count]);
7fd59977	247	Count++;
	248	}
	249	}
	250
	251	Handle(Geom_BSplineSurface) S
	252	= GeomAPI_PointsToBSplineSurface(ZPoints,X0,dX,Y0,dY);
	253	DrawTrSurf::Set(a[1],S);
	254
	255	di << a[1];
	256
	257	return 0;
	258	}
	259
	260	//=======================================================================
	261	//function : surfapp
	262	//purpose :
	263	//=======================================================================
	264
	265	static Standard_Integer surfapp(Draw_Interpretor& di, Standard_Integer n, const char** a)
	266	{
	267	if ( n < 5 ) return 1;
	268
	269	Standard_Integer i,j;
91322f44	270	Standard_Integer Nu = Draw::Atoi(a[2]);
91322f44	271	Standard_Integer Nv = Draw::Atoi(a[3]);
7fd59977	272	TColgp_Array2OfPnt Points (1, Nu, 1, Nv);
	273
	274	if ( n == 5) {
	275	Handle(Geom_Surface) Surf = DrawTrSurf::GetSurface(a[4]);
	276	if ( Surf.IsNull()) return 1;
	277
	278	Standard_Real U, V, U1, V1, U2, V2;
	279	Surf->Bounds( U1, U2, V1, V2);
	280	for ( j = 1; j <= Nv; j++) {
	281	V = V1 + (j-1) * (V2-V1) / (Nv-1);
	282	for ( i = 1; i <= Nu; i++) {
	283	U = U1 + (i-1) * (U2-U1) / (Nu-1);
	284	Points(i,j) = Surf->Value(U,V);
	285	}
	286	}
	287	}
	288	else if ( n >= 16) {
	289	Standard_Integer Count = 4;
	290	for ( j = 1; j <= Nv; j++) {
	291	for ( i = 1; i <= Nu; i++) {
	292	if ( Count > n) return 1;
91322f44	293	Points(i,j) = gp_Pnt(Draw::Atof(a[Count]),Draw::Atof(a[Count+1]),Draw::Atof(a[Count+2]));
7fd59977	294	Count += 3;
	295	}
	296	}
	297	}
	298	char name[100];
	299	Standard_Integer Count = 1;
	300	for ( j = 1; j <= Nv; j++) {
	301	for ( i = 1; i <= Nu; i++) {
91322f44	302	Sprintf(name,"point_%d",Count++);
7fd59977	303	char* temp = name; // portage WNT
	304	DrawTrSurf::Set(temp,Points(i,j));
	305	}
	306	}
	307
	308	Handle(Geom_BSplineSurface) S = GeomAPI_PointsToBSplineSurface(Points);
	309	DrawTrSurf::Set(a[1],S);
	310	di << a[1];
	311
	312	return 0;
	313	}
	314
	315
	316	//=======================================================================
	317	//function : extrema
	318	//purpose :
	319	//=======================================================================
	320
	321	static Standard_Integer extrema(Draw_Interpretor& di, Standard_Integer n, const char** a)
	322	{
	323	if ( n<3) return 1;
	324
	325	Handle(Geom_Curve) GC1, GC2;
	326	Handle(Geom_Surface) GS1, GS2;
	327
	328	Standard_Boolean C1 = Standard_False;
	329	Standard_Boolean C2 = Standard_False;
	330	Standard_Boolean S1 = Standard_False;
	331	Standard_Boolean S2 = Standard_False;
	332
1d47d8d0	333	Standard_Real U1f,U1l,U2f,U2l,V1f = 0.,V1l = 0.,V2f = 0.,V2l = 0.;
7fd59977	334
	335	GC1 = DrawTrSurf::GetCurve(a[1]);
	336	if ( GC1.IsNull()) {
	337	GS1 = DrawTrSurf::GetSurface(a[1]);
	338	if ( GS1.IsNull())
	339	return 1;
	340	S1 = Standard_True;
	341	GS1->Bounds(U1f,U1l,V1f,V1l);
	342	}
	343	else {
	344	C1 = Standard_True;
	345	U1f = GC1->FirstParameter();
	346	U1l = GC1->LastParameter();
	347	}
	348
	349	GC2 = DrawTrSurf::GetCurve(a[2]);
	350	if ( GC2.IsNull()) {
	351	GS2 = DrawTrSurf::GetSurface(a[2]);
	352	if ( GS2.IsNull())
	353	return 1;
	354	S2 = Standard_True;
	355	GS2->Bounds(U2f,U2l,V2f,V2l);
	356	}
	357	else {
	358	C2 = Standard_True;
	359	U2f = GC2->FirstParameter();
	360	U2l = GC2->LastParameter();
	361	}
	362
	363	char name[100];
32ca7a51	364	if ( C1 && C2)
32ca7a51	365	{
7fd59977	366	GeomAPI_ExtremaCurveCurve Ex(GC1,GC2,U1f,U1l,U2f,U2l);
32ca7a51	367
	368	if(!Ex.Extrema().IsParallel())
	369	{
	370	const Standard_Integer aNExtr = Ex.NbExtrema();
	371	if(aNExtr == 0)
	372	{
	373	di << "No solutions!\n";
	374	}
	375	else
	376	{
	377	for ( Standard_Integer i = 1; i <= aNExtr; i++)
	378	{
	379	gp_Pnt P1,P2;
	380	Ex.Points(i,P1,P2);
	381	Standard_Real U1,V1;
	382	Ex.Parameters(i,U1,V1);
	383	if (P1.Distance(P2) < 1.e-16)
	384	{
	385	di << "Extrema " << i << " is point : " << P1.X() << " " << P1.Y() << " " << P1.Z() << "\n";
	386	continue;
	387	}
	388
	389	Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
	390	Handle(Geom_TrimmedCurve) CT =
	391	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
32ca7a51	392	Sprintf(name,"%s%d","ext_",i);
32ca7a51	393	char* temp = name; // portage WNT
32ca7a51	394	DrawTrSurf::Set(temp, CT);
32b6a53f	395	#ifdef DEB
	396	di << name << "(U=" << U1 << ";V=" << V1 << ")" << "\n";
	397	#else
32ca7a51	398	di << name << " ";
32b6a53f	399	#endif
32ca7a51	400	}
32ca7a51	401	}
7fd59977	402	}
32ca7a51	403	else
32ca7a51	404	{
7fd59977	405	di << "Infinite number of extremas, distance = " << Ex.LowerDistance() << "\n";
32ca7a51	406	}
7fd59977	407	}
32ca7a51	408	else if ( C1 & S2)
32ca7a51	409	{
7fd59977	410	GeomAPI_ExtremaCurveSurface Ex(GC1,GS2,U1f,U1l,U2f,U2l,V2f,V2l);
32ca7a51	411
	412	const Standard_Integer aNExtr = Ex.NbExtrema();
	413	if(aNExtr == 0)
	414	{
	415	di << "No solutions!\n";
	416	}
	417	else
	418	{
	419	for ( Standard_Integer i = 1; i <= aNExtr; i++)
	420	{
	421	gp_Pnt P1,P2;
	422	Ex.Points(i,P1,P2);
	423	if (P1.Distance(P2) < 1.e-16) continue;
	424	Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
	425	Handle(Geom_TrimmedCurve) CT =
	426	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
	427	Sprintf(name,"%s%d","ext_",i);
	428	char* temp = name; // portage WNT
	429	DrawTrSurf::Set(temp, CT);
	430	di << name << " ";
	431	}
	432	}
7fd59977	433	}
32ca7a51	434	else if ( S1 & C2)
32ca7a51	435	{
7fd59977	436	GeomAPI_ExtremaCurveSurface Ex(GC2,GS1,U2f,U2l,U1f,U1l,V1f,V1l);
32ca7a51	437
	438	const Standard_Integer aNExtr = Ex.NbExtrema();
	439	if(aNExtr == 0)
	440	{
	441	di << "No solutions!\n";
	442	}
	443	else
	444	{
	445	for ( Standard_Integer i = 1; i <= aNExtr; i++)
	446	{
	447	gp_Pnt P1,P2;
	448	Ex.Points(i,P1,P2);
	449	if (P1.Distance(P2) < 1.e-16) continue;
	450	Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
	451	Handle(Geom_TrimmedCurve) CT =
	452	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
	453	Sprintf(name,"%s%d","ext_",i);
	454	char* temp = name; // portage WNT
	455	DrawTrSurf::Set(temp, CT);
	456	di << name << " ";
	457	}
	458	}
7fd59977	459	}
32ca7a51	460	else if ( S1 & S2)
32ca7a51	461	{
7fd59977	462	GeomAPI_ExtremaSurfaceSurface Ex(GS1,GS2,U1f,U1l,V1f,V1l,U2f,U2l,V2f,V2l);
32ca7a51	463
	464	const Standard_Integer aNExtr = Ex.NbExtrema();
	465	if(aNExtr == 0)
	466	{
	467	di << "No solutions!\n";
	468	}
	469	else
	470	{
	471	for ( Standard_Integer i = 1; i <= aNExtr; i++)
	472	{
	473	gp_Pnt P1,P2;
	474	Ex.Points(i,P1,P2);
	475	if (P1.Distance(P2) < 1.e-16)
	476	continue;
	477
	478	Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
	479	Handle(Geom_TrimmedCurve) CT =
	480	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
	481	Sprintf(name,"%s%d","ext_",i);
	482	char* temp = name; // portage WNT
	483	DrawTrSurf::Set(temp, CT);
	484	di << name << " ";
	485	}
	486	}
7fd59977	487	}
7fd59977	488
7fd59977	489	return 0;
32ca7a51	490	}
7fd59977	491
	492	//=======================================================================
	493	//function : totalextcc
	494	//purpose :
	495	//=======================================================================
	496
	497	static Standard_Integer totalextcc(Draw_Interpretor& di, Standard_Integer n, const char** a)
	498	{
	499	if ( n<3) return 1;
	500
	501	Handle(Geom_Curve) GC1, GC2;
	502
	503
	504	Standard_Real U1f,U1l,U2f,U2l;
	505
	506	GC1 = DrawTrSurf::GetCurve(a[1]);
	507	if ( GC1.IsNull()) {
	508	return 1;
	509	}
	510	else {
	511	U1f = GC1->FirstParameter();
	512	U1l = GC1->LastParameter();
	513	}
	514
	515	GC2 = DrawTrSurf::GetCurve(a[2]);
	516	if ( GC2.IsNull()) {
	517	return 1;
	518	}
	519	else {
	520	U2f = GC2->FirstParameter();
	521	U2l = GC2->LastParameter();
	522	}
	523
	524	char name[100];
	525	GeomAPI_ExtremaCurveCurve Ex(GC1,GC2,U1f,U1l,U2f,U2l);
	526	gp_Pnt P1,P2;
	527	if(Ex.TotalNearestPoints(P1,P2)) {
	528	if (P1.Distance(P2) < 1.e-16) {
	529	di << "Extrema is point : " << P1.X() << " " << P1.Y() << " " << P1.Z() << "\n";
	530	}
	531	else {
	532	di << "Extrema is segment of line" << "\n";
	533	Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
	534	Handle(Geom_TrimmedCurve) CT =
	535	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
91322f44	536	Sprintf(name,"%s%d","ext_",1);
7fd59977	537	char* temp = name; // portage WNT
	538	DrawTrSurf::Set(temp, CT);
	539	di << name << " ";
	540	}
	541
	542	Standard_Real u1, u2;
	543	Ex.TotalLowerDistanceParameters(u1, u2);
	544
	545	di << "Parameters on curves : " << u1 << " " << u2 << "\n";
	546
	547	}
	548	else {
	549	di << "Curves are infinite and parallel" << "\n";
	550	}
	551
	552	di << "Minimal distance : " << Ex.TotalLowerDistance() << "\n";
	553
	554	return 0;
	555
	556	}
	557
	558
	559	void GeometryTest::APICommands(Draw_Interpretor& theCommands)
	560	{
	561	static Standard_Boolean done = Standard_False;
	562	if (done) return;
	563
	564	done = Standard_True;
7fd59977	565
569aff1e	566	theCommands.Add("proj", "proj curve/surf x y z [extrema algo: g(grad)/t(tree)]",__FILE__, proj);
7fd59977	567
7fd59977	568	theCommands.Add("appro", "appro result nbpoint [curve]",__FILE__, appro);
	569	theCommands.Add("surfapp","surfapp result nbupoint nbvpoint x y z ....",
	570	__FILE__,
	571	surfapp);
	572	theCommands.Add("grilapp",
	573	"grilapp result nbupoint nbvpoint X0 dX Y0 dY z11 z12 .. z1nu .... ",
	574	__FILE__,grilapp);
	575
7fd59977	576	theCommands.Add("extrema", "extrema curve/surface curve/surface",__FILE__,extrema);
	577	theCommands.Add("totalextcc", "totalextcc curve curve",__FILE__,totalextcc);
	578	}