[occt.git] / src / BOPTest / BOPTest_PartitionCommands.cxx

// Created by: Peter KURNEV
// 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 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 <BOPTest.ixx>

#include <stdio.h>
#include <string.h>

#include <NCollection_IncAllocator.hxx>

#include <DBRep.hxx>
#include <Draw.hxx>
#include <Draw_Color.hxx>
#include <DrawTrSurf.hxx>

#include <TopoDS_Shape.hxx>
//
#include <BOPAlgo_Builder.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Operation.hxx>
#include <BOPAlgo_BOP.hxx>
//
#include <BOPTest_DrawableShape.hxx>
#include <BOPTest_Objects.hxx>

//
#ifdef HAVE_TBB
#include <BOPCol_TBB.hxx>
//=======================================================================
//class : BOPTime_Chronometer
//purpose  : 
//=======================================================================
class BOPTime_Chronometer {
 public:
  BOPTime_Chronometer() {
  }
  //
  ~BOPTime_Chronometer() {
  }
  //
  void Start() {
    myT0 = tick_count::now();
  }
  //
  void Stop() {
    myTime=(tick_count::now() - myT0).seconds();
  }
  //
  double Time() const{
    return myTime;
  };
  //
 protected:
  tick_count myT0;
  double myTime;
};
////////////////////////////////////////////////////////////////////////
#else
#include <OSD_Chronometer.hxx>
//=======================================================================
//class    : BOPTime_Chronometer
//purpose  : 
//=======================================================================
class BOPTime_Chronometer {
 public:
  BOPTime_Chronometer() {
  }
  //
  ~BOPTime_Chronometer() {
  }
  //
  void Start() {
    myChronometer.Reset();
    myChronometer.Start();
  }
  //
  void Stop() {
    myChronometer.Stop();
    myChronometer.Show(myTime);
  }
  //
  double Time() const{
    return myTime;
  };
  //
 protected:
  OSD_Chronometer myChronometer;
  double myTime;
};
#endif

static Standard_Integer bfillds  (Draw_Interpretor&, Standard_Integer, const char**); 
static Standard_Integer bbuild   (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bbop     (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bclear   (Draw_Interpretor&, Standard_Integer, const char**);

//=======================================================================
//function : PartitionCommands
//purpose  : 
//=======================================================================
void BOPTest::PartitionCommands(Draw_Interpretor& theCommands)
{
  static Standard_Boolean done = Standard_False;
  if (done) return;
  done = Standard_True;
  // Chapter's name
  const char* g = "Partition commands";
  // Commands  
  theCommands.Add("bfillds"  , "use bfillds [-s -t]" , __FILE__, bfillds, g);
  theCommands.Add("bbuild"   , "use bbuild r [-s -t]", __FILE__, bbuild, g);
  theCommands.Add("bbop"     , "use bbop r op"       , __FILE__, bbop, g);
  theCommands.Add("bclear"   , "use bclear"          , __FILE__, bclear, g);
}

//=======================================================================
//function : bclear
//purpose  : 
//=======================================================================
Standard_Integer bclear(Draw_Interpretor& di, 
                        Standard_Integer n, 
                        const char** ) 
{
  if (n!=1) {
    di << " use bclear\n";
    return 0;
  }
  //
  BOPTest_Objects::Clear(); 
  return 0;
}
//=======================================================================
//function : bfillds
//purpose  : 
//=======================================================================
Standard_Integer bfillds(Draw_Interpretor& di, 
                         Standard_Integer n, 
                         const char** a) 
{ 
  if (n>3) {
    di << " use bfillds [-s -t]\n";
    return 0;
  }
  //
  char buf[32];
  Standard_Boolean bRunParallel, bShowTime;
  Standard_Integer i, aNbS, iErr;
  BOPCol_ListIteratorOfListOfShape aIt;
  BOPCol_ListOfShape aLC;
  BOPTime_Chronometer aChrono;
  
  BOPCol_ListOfShape& aLS=BOPTest_Objects::Shapes();
  aNbS=aLS.Extent();
  if (!aNbS) {
    di << " no objects to process\n";
    return 0;
  }
  //
  bShowTime=Standard_False;
  bRunParallel=Standard_True;
  for (i=1; i<n; ++i) {
    if (!strcmp(a[i], "-s")) {
      bRunParallel=Standard_False;
    }
    else if (!strcmp(a[i], "-t")) {
      bShowTime=Standard_True;
    }
  }
  //
  BOPCol_ListOfShape& aLT=BOPTest_Objects::Tools();
  //
  aIt.Initialize(aLS);
  for (; aIt.More(); aIt.Next()) {
    const TopoDS_Shape& aS=aIt.Value();
    aLC.Append(aS);
  }
  //
  aIt.Initialize(aLT);
  for (; aIt.More(); aIt.Next()) {
    const TopoDS_Shape& aS=aIt.Value();
     aLC.Append(aS);
  }
  //
  BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
  //
  aPF.SetArguments(aLC);
  aPF.SetRunParallel(bRunParallel);
  //
  aChrono.Start();
  //
  aPF.Perform();
  iErr=aPF.ErrorStatus();
  if (iErr) {
    Sprintf(buf, " error: %d\n",  iErr);
    di << buf;
    return 0;
  }
  //
  aChrono.Stop();
  //
  if (bShowTime) {
    Standard_Real aTime;
    //
    aTime=aChrono.Time();
    Sprintf(buf, "  Tps: %7.2lf\n", aTime);
    di << buf;
  }
  //
  return 0;
}
//=======================================================================
//function : bbuild
//purpose  : 
//=======================================================================
Standard_Integer bbuild(Draw_Interpretor& di,
                        Standard_Integer n, 
                        const char** a) 
{ 
  if (n<2) {
    di << " use bbuild r [-s -t]\n";
    return 0;
  }
  //
  BOPDS_PDS pDS=BOPTest_Objects::PDS();
  if (!pDS) {
    di << " prepare PaveFiller first\n";
    return 0;
  }
  //
  char buf[128];
  Standard_Boolean bRunParallel, bShowTime;
  Standard_Integer i, iErr;
  
  BOPTime_Chronometer aChrono;
  BOPCol_ListIteratorOfListOfShape aIt;
  //
  BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
  //
  BOPAlgo_Builder& aBuilder=BOPTest_Objects::Builder();
  aBuilder.Clear();
  //
  BOPCol_ListOfShape& aLSObj=BOPTest_Objects::Shapes();
  aIt.Initialize(aLSObj);
  for (; aIt.More(); aIt.Next()) {
    const TopoDS_Shape& aS=aIt.Value();
    aBuilder.AddArgument(aS);
  }
  //
  BOPCol_ListOfShape& aLSTool=BOPTest_Objects::Tools();
  aIt.Initialize(aLSTool);
  for (; aIt.More(); aIt.Next()) {
    const TopoDS_Shape& aS=aIt.Value();
    aBuilder.AddArgument(aS);
  }
  //
  bShowTime=Standard_False;
  bRunParallel=Standard_True;
  for (i=2; i<n; ++i) {
    if (!strcmp(a[i], "-s")) {
      bRunParallel=Standard_False;
    }
    else if (!strcmp(a[i], "-t")) {
      bShowTime=Standard_True;
    }
  }
  aBuilder.SetRunParallel(bRunParallel);
  //
  //
  aChrono.Start();
  //
  aBuilder.PerformWithFiller(aPF); 
  iErr=aBuilder.ErrorStatus();
  if (iErr) {
    Sprintf(buf, " error: %d\n",  iErr);
    di << buf;
    return 0;
  }
  //
  aChrono.Stop();
  //
  if (bShowTime) {
    Standard_Real aTime;
    //
    aTime=aChrono.Time();
    Sprintf(buf, "  Tps: %7.2lf\n", aTime);
    di << buf;
  }
  //
  const TopoDS_Shape& aR=aBuilder.Shape();
  if (aR.IsNull()) {
    di << " null shape\n";
    return 0;
  }
  //
  DBRep::Set(a[1], aR);
  return 0;
}

//=======================================================================
//function : bbop
//purpose  : 
//=======================================================================
Standard_Integer bbop(Draw_Interpretor& di, 
                      Standard_Integer n, 
                      const char** a) 
{ 
  if (n!=3) {
    di << " use bbop r op\n";
    return 0;
  }
  //
  BOPDS_PDS pDS=BOPTest_Objects::PDS();
  if (!pDS) {
    di << " prepare PaveFiller first\n";
    return 0;
  }
  //
  char buf[32];
  Standard_Integer iErr, iOp;
  BOPAlgo_Operation aOp;
  BOPCol_ListIteratorOfListOfShape aIt;
  //
  iOp=Draw::Atoi(a[2]);
  if (iOp<0 || iOp>4) {
    di << " invalid operation type\n";
  }
  aOp=(BOPAlgo_Operation)iOp;
  //
  BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
  //
  BOPAlgo_BOP& aBOP=BOPTest_Objects::BOP();
  aBOP.Clear();
  //
  BOPCol_ListOfShape& aLSObj=BOPTest_Objects::Shapes();
  aIt.Initialize(aLSObj);
  for (; aIt.More(); aIt.Next()) {
    const TopoDS_Shape& aS=aIt.Value();
    aBOP.AddArgument(aS);
  }
  //
  BOPCol_ListOfShape& aLSTools=BOPTest_Objects::Tools();
  aIt.Initialize(aLSTools);
  for (; aIt.More(); aIt.Next()) {
    const TopoDS_Shape& aS=aIt.Value();
    aBOP.AddTool(aS);
  }
  //
  aBOP.SetOperation(aOp);
  //
  aBOP.PerformWithFiller(aPF);
  iErr=aBOP.ErrorStatus();
  if (iErr) {
    Sprintf(buf, " error: %d\n",  iErr);
    di << buf;
    return 0;
  }
  //
  const TopoDS_Shape& aR=aBOP.Shape();
  if (aR.IsNull()) {
    di << " null shape\n";
    return 0;
  }
  //
  DBRep::Set(a[1], aR);
  return 0;
}
Commit	Line	Data
4e57c75e	1	// Created by: Peter KURNEV
973c2be1	2	// Copyright (c) 1999-2014 OPEN CASCADE SAS
4e57c75e	3	//
973c2be1	4	// This file is part of Open CASCADE Technology software library.
4e57c75e	5	//
a942f2da	6	// This library is free software; you can redistribute it and / or modify it
a942f2da	7	// under the terms of the GNU Lesser General Public version 2.1 as published
973c2be1	8	// by the Free Software Foundation, with special exception defined in the file
	9	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	10	// distribution for complete text of the license and disclaimer of any warranty.
4e57c75e	11	//
973c2be1	12	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	13	// commercial license or contractual agreement.
4e57c75e	14
	15	#include <BOPTest.ixx>
	16
	17	#include <stdio.h>
796a784d	18	#include <string.h>
4e57c75e	19
	20	#include <NCollection_IncAllocator.hxx>
	21
	22	#include <DBRep.hxx>
	23	#include <Draw.hxx>
	24	#include <Draw_Color.hxx>
	25	#include <DrawTrSurf.hxx>
	26
	27	#include <TopoDS_Shape.hxx>
	28	//
	29	#include <BOPAlgo_Builder.hxx>
	30	#include <BOPAlgo_PaveFiller.hxx>
	31	#include <BOPAlgo_Operation.hxx>
	32	#include <BOPAlgo_BOP.hxx>
	33	//
	34	#include <BOPTest_DrawableShape.hxx>
	35	#include <BOPTest_Objects.hxx>
	36
	37	//
796a784d	38	#ifdef HAVE_TBB
	39	#include <BOPCol_TBB.hxx>
	40	//=======================================================================
	41	//class : BOPTime_Chronometer
	42	//purpose :
	43	//=======================================================================
	44	class BOPTime_Chronometer {
	45	public:
	46	BOPTime_Chronometer() {
	47	}
	48	//
	49	~BOPTime_Chronometer() {
	50	}
	51	//
	52	void Start() {
	53	myT0 = tick_count::now();
	54	}
	55	//
	56	void Stop() {
	57	myTime=(tick_count::now() - myT0).seconds();
	58	}
	59	//
	60	double Time() const{
	61	return myTime;
	62	};
	63	//
	64	protected:
	65	tick_count myT0;
	66	double myTime;
	67	};
	68	////////////////////////////////////////////////////////////////////////
	69	#else
	70	#include <OSD_Chronometer.hxx>
	71	//=======================================================================
	72	//class : BOPTime_Chronometer
	73	//purpose :
	74	//=======================================================================
	75	class BOPTime_Chronometer {
	76	public:
	77	BOPTime_Chronometer() {
	78	}
	79	//
	80	~BOPTime_Chronometer() {
	81	}
	82	//
	83	void Start() {
	84	myChronometer.Reset();
	85	myChronometer.Start();
	86	}
	87	//
	88	void Stop() {
	89	myChronometer.Stop();
	90	myChronometer.Show(myTime);
	91	}
	92	//
	93	double Time() const{
	94	return myTime;
	95	};
	96	//
	97	protected:
	98	OSD_Chronometer myChronometer;
	99	double myTime;
	100	};
	101	#endif
102
4e57c75e	103	static Standard_Integer bfillds (Draw_Interpretor&, Standard_Integer, const char**);
	104	static Standard_Integer bbuild (Draw_Interpretor&, Standard_Integer, const char**);
	105	static Standard_Integer bbop (Draw_Interpretor&, Standard_Integer, const char**);
	106	static Standard_Integer bclear (Draw_Interpretor&, Standard_Integer, const char**);
a942f2da	107
4e57c75e	108	//=======================================================================
	109	//function : PartitionCommands
	110	//purpose :
	111	//=======================================================================
a942f2da	112	void BOPTest::PartitionCommands(Draw_Interpretor& theCommands)
4e57c75e	113	{
	114	static Standard_Boolean done = Standard_False;
	115	if (done) return;
	116	done = Standard_True;
	117	// Chapter's name
	118	const char* g = "Partition commands";
	119	// Commands
a942f2da	120	theCommands.Add("bfillds" , "use bfillds [-s -t]" , __FILE__, bfillds, g);
	121	theCommands.Add("bbuild" , "use bbuild r [-s -t]", __FILE__, bbuild, g);
	122	theCommands.Add("bbop" , "use bbop r op" , __FILE__, bbop, g);
	123	theCommands.Add("bclear" , "use bclear" , __FILE__, bclear, g);
4e57c75e	124	}
	125
	126	//=======================================================================
	127	//function : bclear
	128	//purpose :
	129	//=======================================================================
a942f2da	130	Standard_Integer bclear(Draw_Interpretor& di,
	131	Standard_Integer n,
	132	const char** )
4e57c75e	133	{
	134	if (n!=1) {
	135	di << " use bclear\n";
	136	return 0;
	137	}
	138	//
	139	BOPTest_Objects::Clear();
	140	return 0;
	141	}
	142	//=======================================================================
	143	//function : bfillds
	144	//purpose :
	145	//=======================================================================
a942f2da	146	Standard_Integer bfillds(Draw_Interpretor& di,
	147	Standard_Integer n,
	148	const char** a)
4e57c75e	149	{
a942f2da	150	if (n>3) {
a942f2da	151	di << " use bfillds [-s -t]\n";
4e57c75e	152	return 0;
	153	}
	154	//
	155	char buf[32];
a942f2da	156	Standard_Boolean bRunParallel, bShowTime;
a942f2da	157	Standard_Integer i, aNbS, iErr;
4e57c75e	158	BOPCol_ListIteratorOfListOfShape aIt;
4e57c75e	159	BOPCol_ListOfShape aLC;
a942f2da	160	BOPTime_Chronometer aChrono;
4e57c75e	161
	162	BOPCol_ListOfShape& aLS=BOPTest_Objects::Shapes();
	163	aNbS=aLS.Extent();
	164	if (!aNbS) {
	165	di << " no objects to process\n";
	166	return 0;
	167	}
	168	//
a942f2da	169	bShowTime=Standard_False;
	170	bRunParallel=Standard_True;
	171	for (i=1; i<n; ++i) {
	172	if (!strcmp(a[i], "-s")) {
	173	bRunParallel=Standard_False;
	174	}
	175	else if (!strcmp(a[i], "-t")) {
	176	bShowTime=Standard_True;
	177	}
	178	}
	179	//
4e57c75e	180	BOPCol_ListOfShape& aLT=BOPTest_Objects::Tools();
4e57c75e	181	//
	182	aIt.Initialize(aLS);
	183	for (; aIt.More(); aIt.Next()) {
	184	const TopoDS_Shape& aS=aIt.Value();
	185	aLC.Append(aS);
	186	}
	187	//
	188	aIt.Initialize(aLT);
	189	for (; aIt.More(); aIt.Next()) {
	190	const TopoDS_Shape& aS=aIt.Value();
	191	aLC.Append(aS);
	192	}
	193	//
	194	BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
	195	//
	196	aPF.SetArguments(aLC);
a942f2da	197	aPF.SetRunParallel(bRunParallel);
	198	//
	199	aChrono.Start();
4e57c75e	200	//
	201	aPF.Perform();
	202	iErr=aPF.ErrorStatus();
	203	if (iErr) {
	204	Sprintf(buf, " error: %d\n", iErr);
	205	di << buf;
	206	return 0;
	207	}
	208	//
a942f2da	209	aChrono.Stop();
	210	//
	211	if (bShowTime) {
	212	Standard_Real aTime;
	213	//
	214	aTime=aChrono.Time();
	215	Sprintf(buf, " Tps: %7.2lf\n", aTime);
	216	di << buf;
	217	}
	218	//
4e57c75e	219	return 0;
4e57c75e	220	}
4e57c75e	221	//=======================================================================
	222	//function : bbuild
	223	//purpose :
	224	//=======================================================================
a942f2da	225	Standard_Integer bbuild(Draw_Interpretor& di,
	226	Standard_Integer n,
	227	const char** a)
4e57c75e	228	{
796a784d	229	if (n<2) {
796a784d	230	di << " use bbuild r [-s -t]\n";
4e57c75e	231	return 0;
	232	}
	233	//
	234	BOPDS_PDS pDS=BOPTest_Objects::PDS();
	235	if (!pDS) {
	236	di << " prepare PaveFiller first\n";
	237	return 0;
	238	}
	239	//
796a784d	240	char buf[128];
	241	Standard_Boolean bRunParallel, bShowTime;
	242	Standard_Integer i, iErr;
	243
	244	BOPTime_Chronometer aChrono;
4e57c75e	245	BOPCol_ListIteratorOfListOfShape aIt;
	246	//
	247	BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
	248	//
	249	BOPAlgo_Builder& aBuilder=BOPTest_Objects::Builder();
	250	aBuilder.Clear();
	251	//
	252	BOPCol_ListOfShape& aLSObj=BOPTest_Objects::Shapes();
	253	aIt.Initialize(aLSObj);
	254	for (; aIt.More(); aIt.Next()) {
	255	const TopoDS_Shape& aS=aIt.Value();
	256	aBuilder.AddArgument(aS);
	257	}
	258	//
	259	BOPCol_ListOfShape& aLSTool=BOPTest_Objects::Tools();
	260	aIt.Initialize(aLSTool);
	261	for (; aIt.More(); aIt.Next()) {
	262	const TopoDS_Shape& aS=aIt.Value();
	263	aBuilder.AddArgument(aS);
	264	}
	265	//
796a784d	266	bShowTime=Standard_False;
	267	bRunParallel=Standard_True;
	268	for (i=2; i<n; ++i) {
	269	if (!strcmp(a[i], "-s")) {
	270	bRunParallel=Standard_False;
	271	}
	272	else if (!strcmp(a[i], "-t")) {
	273	bShowTime=Standard_True;
	274	}
	275	}
	276	aBuilder.SetRunParallel(bRunParallel);
	277	//
	278	//
	279	aChrono.Start();
	280	//
	281	aBuilder.PerformWithFiller(aPF);
4e57c75e	282	iErr=aBuilder.ErrorStatus();
	283	if (iErr) {
	284	Sprintf(buf, " error: %d\n", iErr);
	285	di << buf;
	286	return 0;
	287	}
	288	//
796a784d	289	aChrono.Stop();
	290	//
	291	if (bShowTime) {
	292	Standard_Real aTime;
	293	//
	294	aTime=aChrono.Time();
	295	Sprintf(buf, " Tps: %7.2lf\n", aTime);
	296	di << buf;
	297	}
	298	//
4e57c75e	299	const TopoDS_Shape& aR=aBuilder.Shape();
	300	if (aR.IsNull()) {
	301	di << " null shape\n";
	302	return 0;
	303	}
	304	//
	305	DBRep::Set(a[1], aR);
	306	return 0;
	307	}
	308
	309	//=======================================================================
	310	//function : bbop
	311	//purpose :
	312	//=======================================================================
a942f2da	313	Standard_Integer bbop(Draw_Interpretor& di,
	314	Standard_Integer n,
	315	const char** a)
4e57c75e	316	{
	317	if (n!=3) {
	318	di << " use bbop r op\n";
	319	return 0;
	320	}
	321	//
	322	BOPDS_PDS pDS=BOPTest_Objects::PDS();
	323	if (!pDS) {
	324	di << " prepare PaveFiller first\n";
	325	return 0;
	326	}
	327	//
	328	char buf[32];
	329	Standard_Integer iErr, iOp;
	330	BOPAlgo_Operation aOp;
	331	BOPCol_ListIteratorOfListOfShape aIt;
	332	//
	333	iOp=Draw::Atoi(a[2]);
	334	if (iOp<0 \|\| iOp>4) {
	335	di << " invalid operation type\n";
	336	}
	337	aOp=(BOPAlgo_Operation)iOp;
	338	//
	339	BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
	340	//
	341	BOPAlgo_BOP& aBOP=BOPTest_Objects::BOP();
	342	aBOP.Clear();
	343	//
	344	BOPCol_ListOfShape& aLSObj=BOPTest_Objects::Shapes();
	345	aIt.Initialize(aLSObj);
	346	for (; aIt.More(); aIt.Next()) {
	347	const TopoDS_Shape& aS=aIt.Value();
	348	aBOP.AddArgument(aS);
	349	}
	350	//
	351	BOPCol_ListOfShape& aLSTools=BOPTest_Objects::Tools();
	352	aIt.Initialize(aLSTools);
	353	for (; aIt.More(); aIt.Next()) {
	354	const TopoDS_Shape& aS=aIt.Value();
	355	aBOP.AddTool(aS);
	356	}
	357	//
	358	aBOP.SetOperation(aOp);
	359	//
	360	aBOP.PerformWithFiller(aPF);
	361	iErr=aBOP.ErrorStatus();
	362	if (iErr) {
	363	Sprintf(buf, " error: %d\n", iErr);
	364	di << buf;
	365	return 0;
	366	}
	367	//
	368	const TopoDS_Shape& aR=aBOP.Shape();
	369	if (aR.IsNull()) {
	370	di << " null shape\n";
	371	return 0;
	372	}
	373	//
	374	DBRep::Set(a[1], aR);
	375	return 0;
	376	}
	377