[occt.git] / src / MeshTest / MeshTest_PluginCommands.cxx

// Created on: 2008-04-11
// Created by: Peter KURNEV
// Copyright (c) 2008-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.


#include <MeshTest.ixx>
#include <Draw_Interpretor.hxx>
#include <TColStd_MapOfAsciiString.hxx>
#include <BRepMesh_DiscretFactory.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_MapIteratorOfMapOfAsciiString.hxx>
#include <BRepMesh_FactoryError.hxx>
#include <BRepMesh_DiscretRoot.hxx>
#include <BRepMesh_IncrementalMesh.hxx>
#include <Bnd_Box.hxx>
#include <BRepMesh_PDiscretRoot.hxx>
#include <DBRep.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopExp.hxx>
#include <Poly_Triangulation.hxx>
#include <gp_Vec.hxx>
#include <GProp_GProps.hxx>
#include <BRepGProp.hxx>
#include <DrawTrSurf.hxx>
#include <BRep_Tool.hxx>
#include <TopoDS.hxx>
#include <MeshTest_CheckTopology.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <Poly_Polygon3D.hxx>
#include <Poly_Polygon2D.hxx>
#include <Standard.hxx>

static Standard_Integer mpnames           (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mpsetdefaultname  (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mpgetdefaultname  (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mpsetfunctionname (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mpgetfunctionname (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mperror           (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mpincmesh         (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer mpparallel        (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer triarea           (Draw_Interpretor& , Standard_Integer , const char** );
static Standard_Integer tricheck          (Draw_Interpretor& , Standard_Integer , const char** );

//=======================================================================
//function : PluginCommands
//purpose  : 
//=======================================================================
void MeshTest::PluginCommands(Draw_Interpretor& theCommands)
{
  static Standard_Boolean done = Standard_False;
  if (done) {
    return;
  }
  done = Standard_True;
  //
  const char* g = "Mesh Commands";
  // Commands
  theCommands.Add("mpnames"          , "use mpnames"          , __FILE__, mpnames    , g);
  theCommands.Add("mpsetdefaultname" , "use mpsetdefaultname" , __FILE__, mpsetdefaultname     , g);
  theCommands.Add("mpgetdefaultname" , "use mpgetdefaultname" , __FILE__, mpgetdefaultname     , g);
  theCommands.Add("mpsetfunctionname", "use mpsetfunctionname", __FILE__, mpsetfunctionname     , g);
  theCommands.Add("mpgetfunctionname", "use mpgetfunctionname", __FILE__, mpgetfunctionname     , g);
  theCommands.Add("mperror"          , "use mperror"          , __FILE__, mperror     , g);
  theCommands.Add("mpincmesh"        , "use mpincmesh"        , __FILE__, mpincmesh      , g);
  theCommands.Add("mpparallel"       , "mpparallel [toTurnOn] : show / set multi-threading flag for incremental mesh",
    __FILE__, mpparallel, g);
  theCommands.Add("triarea","shape [eps]  (computes triangles and surface area)",__FILE__, triarea, g);
  theCommands.Add("tricheck", "shape   (checks triangulation of shape)", __FILE__, tricheck, g);
  
}

//=======================================================================
//function : mpnames
//purpose  : 
//=======================================================================
static Standard_Integer mpnames (Draw_Interpretor& , Standard_Integer n, const char** )
{
  Standard_Integer aNb;
  TColStd_MapIteratorOfMapOfAsciiString aIt;
  //
  if (n!=1) {
    printf(" use mpnames\n");
    return 0;
  }
  //
  const TColStd_MapOfAsciiString& aMN=BRepMesh_DiscretFactory::Get().Names();
  aNb=aMN.Extent();
  if (!aNb) {
    printf(" *no names found\n");
    return 0;
  }
  //
  printf(" *available names:\n");
  aIt.Initialize(aMN);
  for (; aIt.More(); aIt.Next()) {
    const TCollection_AsciiString& aName=aIt.Key();
    printf("  %s\n", aName.ToCString());
  }
  //
  return 0;
}
//=======================================================================
//function : mpsetdefaultname
//purpose  : 
//=======================================================================
static Standard_Integer mpsetdefaultname (Draw_Interpretor& , Standard_Integer n, const char**a )
{
  TCollection_AsciiString aName;
  //
  if (n!=2) {
    printf(" use mpsetdefaultname name\n");
    return 0;
  }
  //
  aName=a[1];
  //
  if (BRepMesh_DiscretFactory::Get().SetDefaultName (aName))
    printf(" *ready\n");
  else
    printf(" *fault\n");
  //
  return 0;
}
//=======================================================================
//function : mpgetdefaultname
//purpose  : 
//=======================================================================
static Standard_Integer mpgetdefaultname (Draw_Interpretor& , Standard_Integer n, const char** )
{
  if (n!=1) {
    printf(" use mpgetdefaultname\n");
    return 0;
  }
  //
  const TCollection_AsciiString& aName=BRepMesh_DiscretFactory::Get().DefaultName();
  printf(" *default name: %s\n", aName.ToCString());
  //
  return 0;
}
//=======================================================================
//function : mpsetfunctionname
//purpose  : 
//=======================================================================
static Standard_Integer mpsetfunctionname (Draw_Interpretor& , Standard_Integer n, const char**a )
{
  TCollection_AsciiString aName;
  //
  if (n!=2) {
    printf(" use mpsetfunctionname name\n");
    return 0;
  }
  //
  aName=a[1];
  //
  if (BRepMesh_DiscretFactory::Get().SetFunctionName (aName))
    printf(" *ready\n");
  else
    printf(" *fault\n");
  //
  return 0;
}
//=======================================================================
//function : mpgetdefaultname
//purpose  : 
//=======================================================================
static Standard_Integer mpgetfunctionname (Draw_Interpretor& , Standard_Integer n, const char** )
{
  if (n!=1) {
    printf(" use mpgetfunctionname\n");
    return 0;
  }
  //
  const TCollection_AsciiString& aName=BRepMesh_DiscretFactory::Get().FunctionName();
  printf(" *function name: %s\n", aName.ToCString());
  //
  return 0;
}
//=======================================================================
//function : mperror
//purpose  : 
//=======================================================================
static Standard_Integer mperror (Draw_Interpretor& , Standard_Integer n, const char** )
{
  BRepMesh_FactoryError aErr;
  //
  if (n!=1) {
    printf(" use mperror\n");
    return 0;
  }
  //
  aErr=BRepMesh_DiscretFactory::Get().ErrorStatus();
  printf(" *ErrorStatus: %d\n", (int)aErr);
  //
  return 0;
}

//=======================================================================
//function :mpincmesh
//purpose  : 
//=======================================================================
static Standard_Integer mpincmesh (Draw_Interpretor& , Standard_Integer n, const char** a)
{
  Standard_Real aDeflection, aAngle;
  TopoDS_Shape aS;
  //
  if (n<3) {
    printf(" use mpincmesh s deflection [angle]\n");
    return 0;
  }
  //
  aS=DBRep::Get(a[1]);
  if (aS.IsNull()) {
    printf(" null shapes is not allowed here\n");
    return 0;
  }
  //
  aDeflection=atof(a[2]);
  aAngle=0.5;
  if (n>3) {
    aAngle=atof(a[3]);
  }
  //
  Handle(BRepMesh_DiscretRoot) aMeshAlgo = BRepMesh_DiscretFactory::Get().Discret (aS,
                                                                                   aDeflection,
                                                                                   aAngle);
  //
  BRepMesh_FactoryError aErr = BRepMesh_DiscretFactory::Get().ErrorStatus();
  if (aErr != BRepMesh_FE_NOERROR)
  {
    printf(" *Factory::Get().ErrorStatus()=%d\n", (int)aErr);
  }
  //
  if (aMeshAlgo.IsNull())
  {
    printf(" *Can not create the algo\n");
    return 0;
  }
  //
  aMeshAlgo->Perform();
  if (!aMeshAlgo->IsDone())
  {
    printf(" *Not done\n");
  }
  //
  return 0;
}

//#######################################################################
static Standard_Integer triarea (Draw_Interpretor& di, int n, const char ** a)
{

  if (n < 2) return 1;

  TopoDS_Shape shape = DBRep::Get(a[1]);
  if (shape.IsNull()) return 1;
  Standard_Real anEps = -1.;
  if (n > 2)
    anEps = atof(a[2]);

  TopTools_IndexedMapOfShape aMapF;
  TopExp::MapShapes (shape, TopAbs_FACE, aMapF);

  // detect if a shape has triangulation
  Standard_Boolean hasPoly = Standard_False;
  int i;
  for (i=1; i <= aMapF.Extent(); i++) {
    const TopoDS_Face& aFace = TopoDS::Face(aMapF(i));
    TopLoc_Location aLoc;
    Handle(Poly_Triangulation) aPoly = BRep_Tool::Triangulation(aFace,aLoc);
    if (!aPoly.IsNull()) {
      hasPoly = Standard_True;
      break;
    }
  }

  // compute area by triangles
  double aTriArea=0;
  if (hasPoly) {
    for (i=1; i <= aMapF.Extent(); i++) {
      const TopoDS_Face& aFace = TopoDS::Face(aMapF(i));
      TopLoc_Location aLoc;
      Handle(Poly_Triangulation) aPoly = BRep_Tool::Triangulation(aFace,aLoc);
      if (aPoly.IsNull()) {
        cout << "face "<<i<<" has no triangulation"<<endl;
        continue;
      }
      const Poly_Array1OfTriangle& triangles = aPoly->Triangles();
      const TColgp_Array1OfPnt& nodes = aPoly->Nodes();
      for (int j=triangles.Lower(); j <= triangles.Upper(); j++) {
        const Poly_Triangle& tri = triangles(j);
        int n1, n2, n3;
        tri.Get (n1, n2, n3);
        const gp_Pnt& p1 = nodes(n1);
        const gp_Pnt& p2 = nodes(n2);
        const gp_Pnt& p3 = nodes(n3);
        gp_Vec v1(p1, p2);
        gp_Vec v2(p1, p3);
        double ar = v1.CrossMagnitude(v2);
        aTriArea += ar;
      }
    }
    aTriArea /= 2;
  }

  // compute area by geometry
  GProp_GProps props;
  if (anEps <= 0.)
    BRepGProp::SurfaceProperties(shape, props);
  else
    BRepGProp::SurfaceProperties(shape, props, anEps);
  double aGeomArea = props.Mass();

  di << aTriArea << " " << aGeomArea << "\n";
  return 0;
}

//#######################################################################
static Standard_Integer tricheck (Draw_Interpretor& di, int n, const char ** a)
{
  if (n < 2) return 1;

  TopoDS_Shape shape = DBRep::Get(a[1]);
  if (shape.IsNull()) return 1;

  TopTools_IndexedMapOfShape aMapF;
  TopExp::MapShapes (shape, TopAbs_FACE, aMapF);
  Standard_CString name = ".";

  // execute check
  MeshTest_CheckTopology aCheck(shape);
  aCheck.Perform(di);

  // dump info on free links inside the triangulation
  Standard_Integer nbFree = 0;
  Standard_Integer nbFac = aCheck.NbFacesWithFL(), i, k;
  if (nbFac > 0) {
    for (k=1; k <= nbFac; k++) {
      Standard_Integer nbEdge = aCheck.NbFreeLinks(k);
      Standard_Integer iF = aCheck.GetFaceNumWithFL(k);
      nbFree += nbEdge;
      di << "free links of face " << iF << "\n";
      const TopoDS_Face& aFace = TopoDS::Face(aMapF.FindKey(iF));
      TopLoc_Location aLoc;
      Handle(Poly_Triangulation) aT = BRep_Tool::Triangulation(aFace, aLoc);
      const TColgp_Array1OfPnt& aPoints = aT->Nodes();
      const TColgp_Array1OfPnt2d& aPoints2d = aT->UVNodes();
      const gp_Trsf& trsf = aLoc.Transformation();
      TColgp_Array1OfPnt pnts(1,2);
      TColgp_Array1OfPnt2d pnts2d(1,2);
      for (i=1; i <= nbEdge; i++) {
        Standard_Integer n1, n2;
        aCheck.GetFreeLink(k, i, n1, n2);
        di << "{" << n1 << " " << n2 << "} ";
        pnts(1) = aPoints(n1).Transformed(trsf);
        pnts(2) = aPoints(n2).Transformed(trsf);
        Handle(Poly_Polygon3D) poly = new Poly_Polygon3D (pnts);
        DrawTrSurf::Set (name, poly);
        DrawTrSurf::Set (name, pnts(1));
        DrawTrSurf::Set (name, pnts(2));
        pnts2d(1) = aPoints2d(n1);
        pnts2d(2) = aPoints2d(n2);
        Handle(Poly_Polygon2D) poly2d = new Poly_Polygon2D (pnts2d);
        DrawTrSurf::Set (name, poly2d);
        DrawTrSurf::Set (name, pnts2d(1));
        DrawTrSurf::Set (name, pnts2d(2));
      }
      di << "\n";
    }
  }

  // dump info on cross face errors
  Standard_Integer nbErr = aCheck.NbCrossFaceErrors();
  if (nbErr > 0) {
    di << "cross face errors: {face1, node1, face2, node2, distance}" << "\n";
    for (i=1; i <= nbErr; i++) {
      Standard_Integer iF1, n1, iF2, n2;
      Standard_Real aVal;
      aCheck.GetCrossFaceError(i, iF1, n1, iF2, n2, aVal);
      di << "{" << iF1 << " " << n1 << " " << iF2 << " " << n2 << " " << aVal << "} ";
    }
    di << "\n";
  }

  // dump info on edges
  Standard_Integer nbAsync = aCheck.NbAsyncEdges();
  if (nbAsync > 0) {
    di << "async edges:" << "\n";
    for (i=1; i <= nbAsync; i++) {
      Standard_Integer ie = aCheck.GetAsyncEdgeNum(i);
      di << ie << " ";
    }
    di << "\n";
  }

  // dump info on free nodes
  Standard_Integer nbFreeNodes = aCheck.NbFreeNodes();
  if (nbFreeNodes > 0) {
    di << "free nodes (in pairs: face / node): " << "\n";
    for (i=1; i <= nbFreeNodes; i++) {
      Standard_Integer iface, inode;
      aCheck.GetFreeNodeNum(i, iface, inode);
      di << "{" << iface << " " << inode << "} ";
    }
    di << "\n";
  }

  // output errors summary to DRAW
  if ( nbFree > 0 || nbErr > 0 || nbAsync > 0 || nbFreeNodes > 0 )
    di << "Free_links " << nbFree
       << " Cross_face_errors " << nbErr
       << " Async_edges " << nbAsync 
       << " Free_nodes " << nbFreeNodes << "\n";
  return 0;
}

//=======================================================================
//function : mpparallel
//purpose  :
//=======================================================================
static int mpparallel (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
  if (argc == 2)
  {
    Standard_Boolean isParallelOn = atoi (argv[1]) == 1;
    BRepMesh_IncrementalMesh::SetParallelDefault (isParallelOn);
    if (isParallelOn)
      Standard::SetReentrant(Standard_True);
  }
  std::cout << "Incremental Mesh, multi-threading "
            << (BRepMesh_IncrementalMesh::IsParallelDefault() ? "ON\n" : "OFF\n");
  return 0;
}
Commit	Line	Data
b311480e	1	// Created on: 2008-04-11
	2	// Created by: Peter KURNEV
	3	// Copyright (c) 2008-2012 OPEN CASCADE SAS
	4	//
	5	// The content of this file is subject to the Open CASCADE Technology Public
	6	// License Version 6.5 (the "License"). You may not use the content of this file
	7	// except in compliance with the License. Please obtain a copy of the License
	8	// at http://www.opencascade.org and read it completely before using this file.
	9	//
	10	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	11	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	12	//
	13	// The Original Code and all software distributed under the License is
	14	// distributed on an "AS IS" basis, without warranty of any kind, and the
	15	// Initial Developer hereby disclaims all such warranties, including without
	16	// limitation, any warranties of merchantability, fitness for a particular
	17	// purpose or non-infringement. Please see the License for the specific terms
	18	// and conditions governing the rights and limitations under the License.
	19
7fd59977	20
	21	#include <MeshTest.ixx>
	22	#include <Draw_Interpretor.hxx>
	23	#include <TColStd_MapOfAsciiString.hxx>
	24	#include <BRepMesh_DiscretFactory.hxx>
	25	#include <TCollection_AsciiString.hxx>
	26	#include <TColStd_MapIteratorOfMapOfAsciiString.hxx>
	27	#include <BRepMesh_FactoryError.hxx>
	28	#include <BRepMesh_DiscretRoot.hxx>
0b97567d	29	#include <BRepMesh_IncrementalMesh.hxx>
7fd59977	30	#include <Bnd_Box.hxx>
	31	#include <BRepMesh_PDiscretRoot.hxx>
	32	#include <DBRep.hxx>
	33	#include <TopTools_IndexedMapOfShape.hxx>
	34	#include <TopExp.hxx>
	35	#include <Poly_Triangulation.hxx>
	36	#include <gp_Vec.hxx>
	37	#include <GProp_GProps.hxx>
	38	#include <BRepGProp.hxx>
	39	#include <DrawTrSurf.hxx>
	40	#include <BRep_Tool.hxx>
	41	#include <TopoDS.hxx>
	42	#include <MeshTest_CheckTopology.hxx>
	43	#include <TColgp_Array1OfPnt2d.hxx>
	44	#include <Poly_Polygon3D.hxx>
	45	#include <Poly_Polygon2D.hxx>
ca0db031	46	#include <Standard.hxx>
7fd59977	47
	48	static Standard_Integer mpnames (Draw_Interpretor& , Standard_Integer , const char** );
	49	static Standard_Integer mpsetdefaultname (Draw_Interpretor& , Standard_Integer , const char** );
	50	static Standard_Integer mpgetdefaultname (Draw_Interpretor& , Standard_Integer , const char** );
	51	static Standard_Integer mpsetfunctionname (Draw_Interpretor& , Standard_Integer , const char** );
	52	static Standard_Integer mpgetfunctionname (Draw_Interpretor& , Standard_Integer , const char** );
	53	static Standard_Integer mperror (Draw_Interpretor& , Standard_Integer , const char** );
	54	static Standard_Integer mpincmesh (Draw_Interpretor& , Standard_Integer , const char** );
0b97567d	55	static Standard_Integer mpparallel (Draw_Interpretor& , Standard_Integer , const char** );
7fd59977	56	static Standard_Integer triarea (Draw_Interpretor& , Standard_Integer , const char** );
e1bcbb52	57	static Standard_Integer tricheck (Draw_Interpretor& , Standard_Integer , const char** );
7fd59977	58
	59	//=======================================================================
	60	//function : PluginCommands
	61	//purpose :
	62	//=======================================================================
	63	void MeshTest::PluginCommands(Draw_Interpretor& theCommands)
	64	{
	65	static Standard_Boolean done = Standard_False;
	66	if (done) {
	67	return;
	68	}
	69	done = Standard_True;
	70	//
	71	const char* g = "Mesh Commands";
	72	// Commands
	73	theCommands.Add("mpnames" , "use mpnames" , __FILE__, mpnames , g);
	74	theCommands.Add("mpsetdefaultname" , "use mpsetdefaultname" , __FILE__, mpsetdefaultname , g);
	75	theCommands.Add("mpgetdefaultname" , "use mpgetdefaultname" , __FILE__, mpgetdefaultname , g);
	76	theCommands.Add("mpsetfunctionname", "use mpsetfunctionname", __FILE__, mpsetfunctionname , g);
	77	theCommands.Add("mpgetfunctionname", "use mpgetfunctionname", __FILE__, mpgetfunctionname , g);
	78	theCommands.Add("mperror" , "use mperror" , __FILE__, mperror , g);
	79	theCommands.Add("mpincmesh" , "use mpincmesh" , __FILE__, mpincmesh , g);
0b97567d K	80	theCommands.Add("mpparallel" , "mpparallel [toTurnOn] : show / set multi-threading flag for incremental mesh",
0b97567d K	81	__FILE__, mpparallel, g);
7fd59977	82	theCommands.Add("triarea","shape [eps] (computes triangles and surface area)",__FILE__, triarea, g);
e1bcbb52	83	theCommands.Add("tricheck", "shape (checks triangulation of shape)", __FILE__, tricheck, g);
7fd59977	84
	85	}
	86
	87	//=======================================================================
	88	//function : mpnames
	89	//purpose :
	90	//=======================================================================
	91	static Standard_Integer mpnames (Draw_Interpretor& , Standard_Integer n, const char** )
	92	{
	93	Standard_Integer aNb;
	94	TColStd_MapIteratorOfMapOfAsciiString aIt;
	95	//
	96	if (n!=1) {
	97	printf(" use mpnames\n");
	98	return 0;
	99	}
	100	//
	101	const TColStd_MapOfAsciiString& aMN=BRepMesh_DiscretFactory::Get().Names();
	102	aNb=aMN.Extent();
	103	if (!aNb) {
	104	printf(" *no names found\n");
	105	return 0;
	106	}
	107	//
	108	printf(" *available names:\n");
	109	aIt.Initialize(aMN);
	110	for (; aIt.More(); aIt.Next()) {
	111	const TCollection_AsciiString& aName=aIt.Key();
	112	printf(" %s\n", aName.ToCString());
	113	}
	114	//
	115	return 0;
	116	}
	117	//=======================================================================
	118	//function : mpsetdefaultname
	119	//purpose :
	120	//=======================================================================
	121	static Standard_Integer mpsetdefaultname (Draw_Interpretor& , Standard_Integer n, const char**a )
	122	{
	123	TCollection_AsciiString aName;
	124	//
	125	if (n!=2) {
	126	printf(" use mpsetdefaultname name\n");
	127	return 0;
	128	}
	129	//
	130	aName=a[1];
	131	//
0b97567d K	132	if (BRepMesh_DiscretFactory::Get().SetDefaultName (aName))
	133	printf(" *ready\n");
	134	else
	135	printf(" *fault\n");
7fd59977	136	//
	137	return 0;
	138	}
	139	//=======================================================================
	140	//function : mpgetdefaultname
	141	//purpose :
	142	//=======================================================================
	143	static Standard_Integer mpgetdefaultname (Draw_Interpretor& , Standard_Integer n, const char** )
	144	{
	145	if (n!=1) {
	146	printf(" use mpgetdefaultname\n");
	147	return 0;
	148	}
	149	//
	150	const TCollection_AsciiString& aName=BRepMesh_DiscretFactory::Get().DefaultName();
	151	printf(" *default name: %s\n", aName.ToCString());
	152	//
	153	return 0;
	154	}
	155	//=======================================================================
	156	//function : mpsetfunctionname
	157	//purpose :
	158	//=======================================================================
	159	static Standard_Integer mpsetfunctionname (Draw_Interpretor& , Standard_Integer n, const char**a )
	160	{
	161	TCollection_AsciiString aName;
	162	//
	163	if (n!=2) {
	164	printf(" use mpsetfunctionname name\n");
	165	return 0;
	166	}
	167	//
	168	aName=a[1];
	169	//
0b97567d K	170	if (BRepMesh_DiscretFactory::Get().SetFunctionName (aName))
	171	printf(" *ready\n");
	172	else
	173	printf(" *fault\n");
7fd59977	174	//
	175	return 0;
	176	}
	177	//=======================================================================
	178	//function : mpgetdefaultname
	179	//purpose :
	180	//=======================================================================
	181	static Standard_Integer mpgetfunctionname (Draw_Interpretor& , Standard_Integer n, const char** )
	182	{
	183	if (n!=1) {
	184	printf(" use mpgetfunctionname\n");
	185	return 0;
	186	}
	187	//
	188	const TCollection_AsciiString& aName=BRepMesh_DiscretFactory::Get().FunctionName();
	189	printf(" *function name: %s\n", aName.ToCString());
	190	//
	191	return 0;
	192	}
	193	//=======================================================================
	194	//function : mperror
	195	//purpose :
	196	//=======================================================================
	197	static Standard_Integer mperror (Draw_Interpretor& , Standard_Integer n, const char** )
	198	{
	199	BRepMesh_FactoryError aErr;
	200	//
	201	if (n!=1) {
	202	printf(" use mperror\n");
	203	return 0;
	204	}
	205	//
	206	aErr=BRepMesh_DiscretFactory::Get().ErrorStatus();
	207	printf(" *ErrorStatus: %d\n", (int)aErr);
	208	//
	209	return 0;
	210	}
	211
	212	//=======================================================================
	213	//function :mpincmesh
	214	//purpose :
	215	//=======================================================================
	216	static Standard_Integer mpincmesh (Draw_Interpretor& , Standard_Integer n, const char** a)
	217	{
7fd59977	218	Standard_Real aDeflection, aAngle;
7fd59977	219	TopoDS_Shape aS;
7fd59977	220	//
	221	if (n<3) {
	222	printf(" use mpincmesh s deflection [angle]\n");
	223	return 0;
	224	}
	225	//
	226	aS=DBRep::Get(a[1]);
	227	if (aS.IsNull()) {
	228	printf(" null shapes is not allowed here\n");
	229	return 0;
	230	}
	231	//
	232	aDeflection=atof(a[2]);
	233	aAngle=0.5;
	234	if (n>3) {
	235	aAngle=atof(a[3]);
	236	}
	237	//
0b97567d K	238	Handle(BRepMesh_DiscretRoot) aMeshAlgo = BRepMesh_DiscretFactory::Get().Discret (aS,
	239	aDeflection,
	240	aAngle);
7fd59977	241	//
0b97567d K	242	BRepMesh_FactoryError aErr = BRepMesh_DiscretFactory::Get().ErrorStatus();
	243	if (aErr != BRepMesh_FE_NOERROR)
	244	{
7fd59977	245	printf(" *Factory::Get().ErrorStatus()=%d\n", (int)aErr);
	246	}
	247	//
0b97567d K	248	if (aMeshAlgo.IsNull())
0b97567d K	249	{
7fd59977	250	printf(" *Can not create the algo\n");
	251	return 0;
	252	}
	253	//
0b97567d K	254	aMeshAlgo->Perform();
	255	if (!aMeshAlgo->IsDone())
	256	{
7fd59977	257	printf(" *Not done\n");
	258	}
	259	//
	260	return 0;
	261	}
	262
	263	//#######################################################################
	264	static Standard_Integer triarea (Draw_Interpretor& di, int n, const char ** a)
	265	{
	266
	267	if (n < 2) return 1;
	268
	269	TopoDS_Shape shape = DBRep::Get(a[1]);
	270	if (shape.IsNull()) return 1;
	271	Standard_Real anEps = -1.;
	272	if (n > 2)
	273	anEps = atof(a[2]);
	274
	275	TopTools_IndexedMapOfShape aMapF;
	276	TopExp::MapShapes (shape, TopAbs_FACE, aMapF);
	277
	278	// detect if a shape has triangulation
	279	Standard_Boolean hasPoly = Standard_False;
	280	int i;
	281	for (i=1; i <= aMapF.Extent(); i++) {
	282	const TopoDS_Face& aFace = TopoDS::Face(aMapF(i));
	283	TopLoc_Location aLoc;
	284	Handle(Poly_Triangulation) aPoly = BRep_Tool::Triangulation(aFace,aLoc);
	285	if (!aPoly.IsNull()) {
	286	hasPoly = Standard_True;
	287	break;
	288	}
	289	}
	290
	291	// compute area by triangles
	292	double aTriArea=0;
	293	if (hasPoly) {
	294	for (i=1; i <= aMapF.Extent(); i++) {
	295	const TopoDS_Face& aFace = TopoDS::Face(aMapF(i));
	296	TopLoc_Location aLoc;
	297	Handle(Poly_Triangulation) aPoly = BRep_Tool::Triangulation(aFace,aLoc);
	298	if (aPoly.IsNull()) {
e1bcbb52 O	299	cout << "face "<<i<<" has no triangulation"<<endl;
e1bcbb52 O	300	continue;
7fd59977	301	}
	302	const Poly_Array1OfTriangle& triangles = aPoly->Triangles();
	303	const TColgp_Array1OfPnt& nodes = aPoly->Nodes();
	304	for (int j=triangles.Lower(); j <= triangles.Upper(); j++) {
e1bcbb52 O	305	const Poly_Triangle& tri = triangles(j);
	306	int n1, n2, n3;
	307	tri.Get (n1, n2, n3);
	308	const gp_Pnt& p1 = nodes(n1);
	309	const gp_Pnt& p2 = nodes(n2);
	310	const gp_Pnt& p3 = nodes(n3);
	311	gp_Vec v1(p1, p2);
	312	gp_Vec v2(p1, p3);
	313	double ar = v1.CrossMagnitude(v2);
	314	aTriArea += ar;
7fd59977	315	}
	316	}
	317	aTriArea /= 2;
	318	}
	319
	320	// compute area by geometry
	321	GProp_GProps props;
	322	if (anEps <= 0.)
	323	BRepGProp::SurfaceProperties(shape, props);
	324	else
	325	BRepGProp::SurfaceProperties(shape, props, anEps);
	326	double aGeomArea = props.Mass();
	327
d2c43192	328	di << aTriArea << " " << aGeomArea << "\n";
7fd59977	329	return 0;
	330	}
	331
	332	//#######################################################################
e1bcbb52	333	static Standard_Integer tricheck (Draw_Interpretor& di, int n, const char ** a)
7fd59977	334	{
	335	if (n < 2) return 1;
	336
	337	TopoDS_Shape shape = DBRep::Get(a[1]);
	338	if (shape.IsNull()) return 1;
	339
	340	TopTools_IndexedMapOfShape aMapF;
	341	TopExp::MapShapes (shape, TopAbs_FACE, aMapF);
	342	Standard_CString name = ".";
	343
446e11f3	344	// execute check
7fd59977	345	MeshTest_CheckTopology aCheck(shape);
d2c43192	346	aCheck.Perform(di);
446e11f3 A	347
446e11f3 A	348	// dump info on free links inside the triangulation
7fd59977	349	Standard_Integer nbFree = 0;
	350	Standard_Integer nbFac = aCheck.NbFacesWithFL(), i, k;
	351	if (nbFac > 0) {
	352	for (k=1; k <= nbFac; k++) {
	353	Standard_Integer nbEdge = aCheck.NbFreeLinks(k);
	354	Standard_Integer iF = aCheck.GetFaceNumWithFL(k);
	355	nbFree += nbEdge;
d2c43192	356	di << "free links of face " << iF << "\n";
7fd59977	357	const TopoDS_Face& aFace = TopoDS::Face(aMapF.FindKey(iF));
	358	TopLoc_Location aLoc;
	359	Handle(Poly_Triangulation) aT = BRep_Tool::Triangulation(aFace, aLoc);
	360	const TColgp_Array1OfPnt& aPoints = aT->Nodes();
	361	const TColgp_Array1OfPnt2d& aPoints2d = aT->UVNodes();
	362	const gp_Trsf& trsf = aLoc.Transformation();
	363	TColgp_Array1OfPnt pnts(1,2);
	364	TColgp_Array1OfPnt2d pnts2d(1,2);
	365	for (i=1; i <= nbEdge; i++) {
e1bcbb52 O	366	Standard_Integer n1, n2;
e1bcbb52 O	367	aCheck.GetFreeLink(k, i, n1, n2);
d2c43192	368	di << "{" << n1 << " " << n2 << "} ";
e1bcbb52 O	369	pnts(1) = aPoints(n1).Transformed(trsf);
	370	pnts(2) = aPoints(n2).Transformed(trsf);
	371	Handle(Poly_Polygon3D) poly = new Poly_Polygon3D (pnts);
	372	DrawTrSurf::Set (name, poly);
	373	DrawTrSurf::Set (name, pnts(1));
	374	DrawTrSurf::Set (name, pnts(2));
	375	pnts2d(1) = aPoints2d(n1);
	376	pnts2d(2) = aPoints2d(n2);
	377	Handle(Poly_Polygon2D) poly2d = new Poly_Polygon2D (pnts2d);
	378	DrawTrSurf::Set (name, poly2d);
	379	DrawTrSurf::Set (name, pnts2d(1));
	380	DrawTrSurf::Set (name, pnts2d(2));
7fd59977	381	}
d2c43192	382	di << "\n";
7fd59977	383	}
	384	}
	385
446e11f3	386	// dump info on cross face errors
7fd59977	387	Standard_Integer nbErr = aCheck.NbCrossFaceErrors();
7fd59977	388	if (nbErr > 0) {
d2c43192	389	di << "cross face errors: {face1, node1, face2, node2, distance}" << "\n";
7fd59977	390	for (i=1; i <= nbErr; i++) {
	391	Standard_Integer iF1, n1, iF2, n2;
	392	Standard_Real aVal;
	393	aCheck.GetCrossFaceError(i, iF1, n1, iF2, n2, aVal);
d2c43192	394	di << "{" << iF1 << " " << n1 << " " << iF2 << " " << n2 << " " << aVal << "} ";
7fd59977	395	}
d2c43192	396	di << "\n";
7fd59977	397	}
7fd59977	398
446e11f3	399	// dump info on edges
7fd59977	400	Standard_Integer nbAsync = aCheck.NbAsyncEdges();
7fd59977	401	if (nbAsync > 0) {
d2c43192	402	di << "async edges:" << "\n";
7fd59977	403	for (i=1; i <= nbAsync; i++) {
7fd59977	404	Standard_Integer ie = aCheck.GetAsyncEdgeNum(i);
d2c43192	405	di << ie << " ";
7fd59977	406	}
d2c43192	407	di << "\n";
7fd59977	408	}
7fd59977	409
446e11f3 A	410	// dump info on free nodes
	411	Standard_Integer nbFreeNodes = aCheck.NbFreeNodes();
	412	if (nbFreeNodes > 0) {
d2c43192	413	di << "free nodes (in pairs: face / node): " << "\n";
446e11f3 A	414	for (i=1; i <= nbFreeNodes; i++) {
	415	Standard_Integer iface, inode;
	416	aCheck.GetFreeNodeNum(i, iface, inode);
d2c43192	417	di << "{" << iface << " " << inode << "} ";
446e11f3	418	}
d2c43192	419	di << "\n";
446e11f3 A	420	}
	421
	422	// output errors summary to DRAW
	423	if ( nbFree > 0 \|\| nbErr > 0 \|\| nbAsync > 0 \|\| nbFreeNodes > 0 )
	424	di << "Free_links " << nbFree
	425	<< " Cross_face_errors " << nbErr
	426	<< " Async_edges " << nbAsync
d2c43192	427	<< " Free_nodes " << nbFreeNodes << "\n";
7fd59977	428	return 0;
7fd59977	429	}
0b97567d K	430
	431	//=======================================================================
	432	//function : mpparallel
	433	//purpose :
	434	//=======================================================================
	435	static int mpparallel (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
	436	{
	437	if (argc == 2)
	438	{
	439	Standard_Boolean isParallelOn = atoi (argv[1]) == 1;
	440	BRepMesh_IncrementalMesh::SetParallelDefault (isParallelOn);
ca0db031 K	441	if (isParallelOn)
ca0db031 K	442	Standard::SetReentrant(Standard_True);
0b97567d K	443	}
	444	std::cout << "Incremental Mesh, multi-threading "
	445	<< (BRepMesh_IncrementalMesh::IsParallelDefault() ? "ON\n" : "OFF\n");
	446	return 0;
	447	}