[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_BSplineCurve.hxx>
#include <Geom_BSplineSurface.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 _WIN32
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();
  }

  NCollection_Vector<gp_Pnt> aPnts1, aPnts2;
  NCollection_Vector<Standard_Real> aPrms[4];
  if (C1 && C2)
  {
    GeomAPI_ExtremaCurveCurve Ex(GC1, GC2, U1f, U1l, U2f, U2l);
    if (!Ex.Extrema().IsParallel())
    {
      for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
      {
        gp_Pnt aP1, aP2;
        Ex.Points(aJ, aP1, aP2);
        aPnts1.Append(aP1);
        aPnts2.Append(aP2);

        Standard_Real aU1, aU2;
        Ex.Parameters(aJ, aU1, aU2);
        aPrms[0].Append(aU1);
        aPrms[2].Append(aU2);
      }
    }
    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);
    for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
    {
      gp_Pnt aP1, aP2;
      Ex.Points(aJ, aP1, aP2);
      aPnts1.Append(aP1);
      aPnts2.Append(aP2);

      Standard_Real aU1, aU2, aV2;
      Ex.Parameters(aJ, aU1, aU2, aV2);
      aPrms[0].Append(aU1);
      aPrms[2].Append(aU2);
      aPrms[3].Append(aV2);
    }
  }
  else if (S1 && C2)
  {
    GeomAPI_ExtremaCurveSurface Ex(GC2, GS1, U2f, U2l, U1f, U1l, V1f, V1l);
    for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
    {
      gp_Pnt aP2, aP1;
      Ex.Points(aJ, aP2, aP1);
      aPnts1.Append(aP1);
      aPnts2.Append(aP2);

      Standard_Real aU1, aV1, aU2;
      Ex.Parameters(aJ, aU2, aU1, aV1);
      aPrms[0].Append(aU1);
      aPrms[1].Append(aV1);
      aPrms[2].Append(aU2);
    }
  }
  else if (S1 && S2)
  {
    GeomAPI_ExtremaSurfaceSurface Ex(
      GS1, GS2, U1f, U1l, V1f, V1l, U2f, U2l, V2f, V2l);
    for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
    {
      gp_Pnt aP1, aP2;
      Ex.Points(aJ, aP1, aP2);
      aPnts1.Append(aP1);
      aPnts2.Append(aP2);

      Standard_Real aU1, aV1, aU2, aV2;
      Ex.Parameters(aJ, aU1, aV1, aU2, aV2);
      aPrms[0].Append(aU1);
      aPrms[1].Append(aV1);
      aPrms[2].Append(aU2);
      aPrms[3].Append(aV2);
    }
  }

  char aName[100];
  char* aName2 = aName; // portage WNT

  // Output points.
  const Standard_Integer aPntCount = aPnts1.Size();
  if (aPntCount == 0)
  {
    di << "No solutions!\n";
  }
  for (Standard_Integer aJ = 1; aJ <= aPntCount; aJ++)
  {
    gp_Pnt aP1 = aPnts1(aJ - 1), aP2 = aPnts2(aJ - 1);

    if (aP1.Distance(aP2) < 1.e-16)
    {
      di << "Extrema " << aJ << " is point : " <<
        aP1.X() << " " << aP1.Y() << " " << aP1.Z() << "\n";
      continue;
    }

    Handle(Geom_Line) aL = new Geom_Line(aP1, gp_Vec(aP1, aP2));
    Handle(Geom_TrimmedCurve) aCT = 
      new Geom_TrimmedCurve(aL, 0., aP1.Distance(aP2));
    Sprintf(aName, "%s%d", "ext_", aJ);
    DrawTrSurf::Set(aName2, aCT);
    di << aName << " ";
  }

  if (n >= 4)
  {
    // Output points.
    for (Standard_Integer aJ = 1; aJ <= aPntCount; aJ++)
    {
      gp_Pnt aP1 = aPnts1(aJ - 1), aP2 = aPnts2(aJ - 1);
      Sprintf(aName, "%s%d%s", "ext_", aJ, "_2");
      DrawTrSurf::Set(aName2, aP1);
      di << aName << " ";
      Sprintf(aName, "%s%d%s", "ext_", aJ, "_3");
      DrawTrSurf::Set(aName2, aP2);
      di << aName << " ";
    }

    // Output parameters.
    for (Standard_Integer aJ = 0; aJ < 4; ++aJ)
    {
      for (Standard_Integer aPrmCount = aPrms[aJ].Size(), aK = 0;
        aK < aPrmCount; ++aK)
      {
        Standard_Real aP = aPrms[aJ](aK);
        Sprintf(aName, "%s%d%s%d", "prm_", aJ + 1, "_", aK + 1);
        Draw::Set(aName2, aP);
        di << aName << " ";
      }
    }
  }

  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 [extended_output = 0|1]",__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
543a9964	17	#include <Geom_BSplineCurve.hxx>
543a9964	18	#include <Geom_BSplineSurface.hxx>
7fd59977	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>
57c28b61	42	#ifdef _WIN32
7fd59977	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)
ecc4f148	52	{
32ca7a51	53	if ( n < 5)
ecc4f148	54	{
569aff1e	55	cout << " Use proj curve/surf x y z [extrema algo: g(grad)/t(tree)]" << endl;
569aff1e	56	return 1;
ecc4f148	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())
ecc4f148	71	{
7fd59977	72	GS = DrawTrSurf::GetSurface(a[1]);
ecc4f148	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++)
ecc4f148	84	{
7fd59977	85	gp_Pnt P1 = proj.Point(i);
32ca7a51	86	if ( P.Distance(P1) > Precision::Confusion())
ecc4f148	87	{
32ca7a51	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));
ecc4f148	91	Sprintf(name,"%s%d","ext_",i);
32ca7a51	92	char* temp = name; // portage WNT
	93	DrawTrSurf::Set(temp, CT);
	94	di << name << " ";
ecc4f148	95	}
32ca7a51	96	else
ecc4f148	97	{
ecc4f148	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";
7fd59977	106	}
7fd59977	107	}
ecc4f148	108	}
32ca7a51	109	else
ecc4f148	110	{
7fd59977	111	GeomAPI_ProjectPointOnCurve proj(P,GC,GC->FirstParameter(),
ecc4f148	112	GC->LastParameter());
32ca7a51	113
32ca7a51	114	if(proj.NbPoints() == 0)
ecc4f148	115	{
32ca7a51	116	cout << "No project point was found." << endl;
32ca7a51	117	return 0;
ecc4f148	118	}
32ca7a51	119
32ca7a51	120	for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
ecc4f148	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())
ecc4f148	126	{
32ca7a51	127	Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
32ca7a51	128	Handle(Geom_TrimmedCurve) CT =
ecc4f148	129	new Geom_TrimmedCurve(L, 0., P.Distance(P1));
ecc4f148	130	Sprintf(name,"%s%d","ext_",i);
32ca7a51	131	char* temp = name; // portage WNT
	132	DrawTrSurf::Set(temp, CT);
	133	di << name << " ";
ecc4f148	134	}
32ca7a51	135	else
ecc4f148	136	{
ecc4f148	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";
7fd59977	144	}
7fd59977	145	}
ecc4f148	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	{
c858bb10	323	if (n < 3)
	324	{
	325	return 1;
	326	}
7fd59977	327
	328	Handle(Geom_Curve) GC1, GC2;
	329	Handle(Geom_Surface) GS1, GS2;
	330
	331	Standard_Boolean C1 = Standard_False;
	332	Standard_Boolean C2 = Standard_False;
	333	Standard_Boolean S1 = Standard_False;
	334	Standard_Boolean S2 = Standard_False;
	335
c858bb10	336	Standard_Real U1f, U1l, U2f, U2l, V1f = 0., V1l = 0., V2f = 0., V2l = 0.;
7fd59977	337
	338	GC1 = DrawTrSurf::GetCurve(a[1]);
	339	if ( GC1.IsNull()) {
	340	GS1 = DrawTrSurf::GetSurface(a[1]);
	341	if ( GS1.IsNull())
	342	return 1;
	343	S1 = Standard_True;
	344	GS1->Bounds(U1f,U1l,V1f,V1l);
	345	}
	346	else {
	347	C1 = Standard_True;
	348	U1f = GC1->FirstParameter();
	349	U1l = GC1->LastParameter();
	350	}
	351
	352	GC2 = DrawTrSurf::GetCurve(a[2]);
	353	if ( GC2.IsNull()) {
	354	GS2 = DrawTrSurf::GetSurface(a[2]);
	355	if ( GS2.IsNull())
	356	return 1;
	357	S2 = Standard_True;
	358	GS2->Bounds(U2f,U2l,V2f,V2l);
	359	}
	360	else {
	361	C2 = Standard_True;
	362	U2f = GC2->FirstParameter();
	363	U2l = GC2->LastParameter();
	364	}
	365
c858bb10	366	NCollection_Vector<gp_Pnt> aPnts1, aPnts2;
	367	NCollection_Vector<Standard_Real> aPrms[4];
	368	if (C1 && C2)
	369	{
	370	GeomAPI_ExtremaCurveCurve Ex(GC1, GC2, U1f, U1l, U2f, U2l);
	371	if (!Ex.Extrema().IsParallel())
32ca7a51	372	{
c858bb10	373	for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
32ca7a51	374	{
c858bb10	375	gp_Pnt aP1, aP2;
	376	Ex.Points(aJ, aP1, aP2);
	377	aPnts1.Append(aP1);
	378	aPnts2.Append(aP2);
	379
	380	Standard_Real aU1, aU2;
	381	Ex.Parameters(aJ, aU1, aU2);
	382	aPrms[0].Append(aU1);
	383	aPrms[2].Append(aU2);
7fd59977	384	}
c858bb10	385	}
32ca7a51	386	else
c858bb10	387	{
7fd59977	388	di << "Infinite number of extremas, distance = " << Ex.LowerDistance() << "\n";
7fd59977	389	}
c858bb10	390	}
	391	else if (C1 && S2)
	392	{
	393	GeomAPI_ExtremaCurveSurface Ex(GC1, GS2, U1f, U1l, U2f, U2l, V2f, V2l);
	394	for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
	395	{
	396	gp_Pnt aP1, aP2;
	397	Ex.Points(aJ, aP1, aP2);
	398	aPnts1.Append(aP1);
	399	aPnts2.Append(aP2);
	400
	401	Standard_Real aU1, aU2, aV2;
	402	Ex.Parameters(aJ, aU1, aU2, aV2);
	403	aPrms[0].Append(aU1);
	404	aPrms[2].Append(aU2);
	405	aPrms[3].Append(aV2);
	406	}
	407	}
	408	else if (S1 && C2)
	409	{
	410	GeomAPI_ExtremaCurveSurface Ex(GC2, GS1, U2f, U2l, U1f, U1l, V1f, V1l);
	411	for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
32ca7a51	412	{
c858bb10	413	gp_Pnt aP2, aP1;
	414	Ex.Points(aJ, aP2, aP1);
	415	aPnts1.Append(aP1);
	416	aPnts2.Append(aP2);
	417
	418	Standard_Real aU1, aV1, aU2;
	419	Ex.Parameters(aJ, aU2, aU1, aV1);
	420	aPrms[0].Append(aU1);
	421	aPrms[1].Append(aV1);
	422	aPrms[2].Append(aU2);
7fd59977	423	}
c858bb10	424	}
	425	else if (S1 && S2)
	426	{
	427	GeomAPI_ExtremaSurfaceSurface Ex(
	428	GS1, GS2, U1f, U1l, V1f, V1l, U2f, U2l, V2f, V2l);
	429	for (Standard_Integer aJ = 1; aJ <= Ex.NbExtrema(); ++aJ)
32ca7a51	430	{
c858bb10	431	gp_Pnt aP1, aP2;
	432	Ex.Points(aJ, aP1, aP2);
	433	aPnts1.Append(aP1);
	434	aPnts2.Append(aP2);
	435
	436	Standard_Real aU1, aV1, aU2, aV2;
	437	Ex.Parameters(aJ, aU1, aV1, aU2, aV2);
	438	aPrms[0].Append(aU1);
	439	aPrms[1].Append(aV1);
	440	aPrms[2].Append(aU2);
	441	aPrms[3].Append(aV2);
	442	}
	443	}
32ca7a51	444
c858bb10	445	char aName[100];
	446	char* aName2 = aName; // portage WNT
	447
	448	// Output points.
	449	const Standard_Integer aPntCount = aPnts1.Size();
	450	if (aPntCount == 0)
	451	{
	452	di << "No solutions!\n";
	453	}
	454	for (Standard_Integer aJ = 1; aJ <= aPntCount; aJ++)
	455	{
	456	gp_Pnt aP1 = aPnts1(aJ - 1), aP2 = aPnts2(aJ - 1);
	457
	458	if (aP1.Distance(aP2) < 1.e-16)
	459	{
	460	di << "Extrema " << aJ << " is point : " <<
	461	aP1.X() << " " << aP1.Y() << " " << aP1.Z() << "\n";
	462	continue;
7fd59977	463	}
c858bb10	464
	465	Handle(Geom_Line) aL = new Geom_Line(aP1, gp_Vec(aP1, aP2));
	466	Handle(Geom_TrimmedCurve) aCT =
	467	new Geom_TrimmedCurve(aL, 0., aP1.Distance(aP2));
	468	Sprintf(aName, "%s%d", "ext_", aJ);
	469	DrawTrSurf::Set(aName2, aCT);
	470	di << aName << " ";
	471	}
	472
	473	if (n >= 4)
	474	{
	475	// Output points.
	476	for (Standard_Integer aJ = 1; aJ <= aPntCount; aJ++)
32ca7a51	477	{
c858bb10	478	gp_Pnt aP1 = aPnts1(aJ - 1), aP2 = aPnts2(aJ - 1);
	479	Sprintf(aName, "%s%d%s", "ext_", aJ, "_2");
	480	DrawTrSurf::Set(aName2, aP1);
	481	di << aName << " ";
	482	Sprintf(aName, "%s%d%s", "ext_", aJ, "_3");
	483	DrawTrSurf::Set(aName2, aP2);
	484	di << aName << " ";
	485	}
32ca7a51	486
c858bb10	487	// Output parameters.
	488	for (Standard_Integer aJ = 0; aJ < 4; ++aJ)
	489	{
	490	for (Standard_Integer aPrmCount = aPrms[aJ].Size(), aK = 0;
	491	aK < aPrmCount; ++aK)
32ca7a51	492	{
c858bb10	493	Standard_Real aP = aPrms[aJ](aK);
	494	Sprintf(aName, "%s%d%s%d", "prm_", aJ + 1, "_", aK + 1);
	495	Draw::Set(aName2, aP);
	496	di << aName << " ";
32ca7a51	497	}
7fd59977	498	}
c858bb10	499	}
7fd59977	500
7fd59977	501	return 0;
c858bb10	502	}
7fd59977	503
	504	//=======================================================================
	505	//function : totalextcc
	506	//purpose :
	507	//=======================================================================
	508
	509	static Standard_Integer totalextcc(Draw_Interpretor& di, Standard_Integer n, const char** a)
	510	{
	511	if ( n<3) return 1;
	512
	513	Handle(Geom_Curve) GC1, GC2;
	514
	515
	516	Standard_Real U1f,U1l,U2f,U2l;
	517
	518	GC1 = DrawTrSurf::GetCurve(a[1]);
	519	if ( GC1.IsNull()) {
	520	return 1;
	521	}
	522	else {
	523	U1f = GC1->FirstParameter();
	524	U1l = GC1->LastParameter();
	525	}
	526
	527	GC2 = DrawTrSurf::GetCurve(a[2]);
	528	if ( GC2.IsNull()) {
	529	return 1;
	530	}
	531	else {
	532	U2f = GC2->FirstParameter();
	533	U2l = GC2->LastParameter();
	534	}
	535
	536	char name[100];
	537	GeomAPI_ExtremaCurveCurve Ex(GC1,GC2,U1f,U1l,U2f,U2l);
	538	gp_Pnt P1,P2;
	539	if(Ex.TotalNearestPoints(P1,P2)) {
	540	if (P1.Distance(P2) < 1.e-16) {
	541	di << "Extrema is point : " << P1.X() << " " << P1.Y() << " " << P1.Z() << "\n";
	542	}
	543	else {
	544	di << "Extrema is segment of line" << "\n";
	545	Handle(Geom_Line) L = new Geom_Line(P1,gp_Vec(P1,P2));
	546	Handle(Geom_TrimmedCurve) CT =
	547	new Geom_TrimmedCurve(L, 0., P1.Distance(P2));
91322f44	548	Sprintf(name,"%s%d","ext_",1);
7fd59977	549	char* temp = name; // portage WNT
	550	DrawTrSurf::Set(temp, CT);
	551	di << name << " ";
	552	}
	553
	554	Standard_Real u1, u2;
	555	Ex.TotalLowerDistanceParameters(u1, u2);
	556
	557	di << "Parameters on curves : " << u1 << " " << u2 << "\n";
	558
	559	}
	560	else {
	561	di << "Curves are infinite and parallel" << "\n";
	562	}
	563
	564	di << "Minimal distance : " << Ex.TotalLowerDistance() << "\n";
	565
	566	return 0;
	567
	568	}
	569
	570
	571	void GeometryTest::APICommands(Draw_Interpretor& theCommands)
	572	{
	573	static Standard_Boolean done = Standard_False;
	574	if (done) return;
	575
	576	done = Standard_True;
7fd59977	577
569aff1e	578	theCommands.Add("proj", "proj curve/surf x y z [extrema algo: g(grad)/t(tree)]",__FILE__, proj);
7fd59977	579
7fd59977	580	theCommands.Add("appro", "appro result nbpoint [curve]",__FILE__, appro);
	581	theCommands.Add("surfapp","surfapp result nbupoint nbvpoint x y z ....",
	582	__FILE__,
	583	surfapp);
	584	theCommands.Add("grilapp",
	585	"grilapp result nbupoint nbvpoint X0 dX Y0 dY z11 z12 .. z1nu .... ",
	586	__FILE__,grilapp);
	587
c858bb10	588	theCommands.Add("extrema", "extrema curve/surface curve/surface [extended_output = 0\|1]",__FILE__,extrema);
7fd59977	589	theCommands.Add("totalextcc", "totalextcc curve curve",__FILE__,totalextcc);
7fd59977	590	}