//
// 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
+// 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.
#include <BRep_Builder.hxx>
#include <BRepBndLib.hxx>
#include <Bnd_Box.hxx>
+#include <Bnd_Box2d.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <ProjLib_ComputeApproxOnPolarSurface.hxx>
#include <DrawTrSurf.hxx>
+#include <Geom_Plane.hxx>
-
+#include <OSD_Timer.hxx>
#include <Draw_Segment3D.hxx>
#include <Draw_Marker3D.hxx>
#include <Draw_MarkerShape.hxx>
-
+#include <BRepPrimAPI_MakeBox.hxx>
#include <stdio.h>
Standard_IMPORT Draw_Viewer dout;
+//=======================================================================
+//function : ConvertBndToShape
+//purpose : Creates TopoDS_Solid from theBox
+//=======================================================================
+static void ConvertBndToShape(const Bnd_OBB& theBox,
+ const char* const theName)
+{
+ if (theBox.IsVoid())
+ {
+ DBRep::Set (theName, TopoDS_Shape());
+ return;
+ }
+ const gp_Pnt &aBaryCenter = theBox.Center();
+ const gp_XYZ &aXDir = theBox.XDirection(),
+ &aYDir = theBox.YDirection(),
+ &aZDir = theBox.ZDirection();
+ Standard_Real aHalfX = theBox.XHSize(),
+ aHalfY = theBox.YHSize(),
+ aHalfZ = theBox.ZHSize();
+
+ gp_Ax2 anAxes(aBaryCenter, aZDir, aXDir);
+ anAxes.SetLocation(aBaryCenter.XYZ() - aHalfX*aXDir - aHalfY*aYDir - aHalfZ*aZDir);
+ TopoDS_Solid aBox = BRepPrimAPI_MakeBox(anAxes, 2.0*aHalfX, 2.0*aHalfY, 2.0*aHalfZ);
+ DBRep::Set(theName, aBox);
+}
//=======================================================================
// addpcurve
// transform
//=======================================================================
-static Standard_Integer transform(Draw_Interpretor& di,Standard_Integer n,const char** a)
+static Standard_Integer transform(Draw_Interpretor& ,Standard_Integer n,const char** a)
{
if (n <= 1) return 1;
const char* aName = a[0];
Standard_Boolean isBasic = Standard_False;
+ Standard_Boolean isCopy = Standard_False;
+
+ // Check "copy" flag.
+ if (!strcmp(a[n-1], "-copy")) {
+ isCopy = Standard_True;
+ last = --n;
+ }
if (!strcmp(aName,"reset")) {
}
for (Standard_Integer i = 1; i < last; i++) {
TopoDS_Shape S = DBRep::Get(a[i]);
if (S.IsNull())
- di << a[i] << " is not a valid shape\n";
+ {
+ std::cerr << "Error: " << a[i] << " is not a valid shape\n";
+ return 1;
+ }
else
DBRep::Set(a[i],S.Located(L));
}
for (Standard_Integer i = 1; i < last; i++) {
TopoDS_Shape S = DBRep::Get(a[i]);
if (S.IsNull()) {
- di << a[i] << " is not a valid shape\n";
+ std::cerr << "Error: " << a[i] << " is not a valid shape\n";
+ return 1;
}
else {
- trf.Perform(S);
+ trf.Perform(S, isCopy);
if (!trf.IsDone())
return 1;
DBRep::Set(a[i],trf.Shape());
TopoDS_Shape S = DBRep::Get(a[2]);
if (S.IsNull()) {
//cout << a[2] << " is not a valid shape" << endl;
- di << a[2] << " is not a valid shape" << "\n";
+ di << a[2] << " is not a valid shape\n";
}
else {
gtrf.Perform(S);
static Standard_Integer tcopy(Draw_Interpretor& di,Standard_Integer n,const char** a)
{
Standard_Boolean copyGeom = Standard_True;
+ Standard_Boolean copyMesh = Standard_False;
Standard_Integer iFirst = 1; // index of first shape argument
- if (n > 1 && a[1][0] == '-' && a[1][1] == 'n' )
+ if (n > 1)
{
- copyGeom = Standard_False;
- iFirst = 2;
+ for (Standard_Integer i = 1; i <= 2; i++)
+ {
+ if (a[i][0] != '-')
+ break;
+ if (a[i][1] == 'n')
+ {
+ copyGeom = Standard_False;
+ iFirst++;
+ }
+ else if (a[i][1] == 'm')
+ {
+ copyMesh = Standard_True;
+ iFirst++;
+ }
+ }
}
if (n < 3 || (n - iFirst) % 2) {
- cout << "Use: " << a[0] << " [-n(ogeom)] shape1 copy1 [shape2 copy2 [...]]" << endl;
- cout << "Option -n forbids copying of geometry (it will be shared)" << endl;
+ cout << "Use: " << a[0] << " [-n(ogeom)] [-m(esh)] shape1 copy1 [shape2 copy2 [...]]" << endl;
+ cout << "Option -n forbids copying of geometry (it will be shared)" << endl;
+ cout << "Option -m forces copying of mesh (disabled by default)" << endl;
return 1;
}
BRepBuilderAPI_Copy cop;
Standard_Integer nbPairs = (n - iFirst) / 2;
for (Standard_Integer i=0; i < nbPairs; i++) {
- cop.Perform(DBRep::Get(a[i+iFirst]), copyGeom);
+ cop.Perform(DBRep::Get(a[i+iFirst]), copyGeom, copyMesh);
DBRep::Set(a[i+iFirst+1],cop.Shape());
di << a[i+iFirst+1] << " ";
}
TopoDS_Shape S = DBRep::Get(a[2*i+2]);
if (S.IsNull()) {
//cout << a[2*i+2] << " is not a valid shape" << endl;
- di << a[2*i+2] << " is not a valid shape" << "\n";
+ di << a[2*i+2] << " is not a valid shape\n";
}
else {
nbscv.Perform(S);
// sameparameter
//=======================================================================
-static Standard_Integer sameparameter(Draw_Interpretor& ,Standard_Integer n,const char** a)
+static Standard_Integer sameparameter(Draw_Interpretor& di,Standard_Integer n,const char** a)
{
- if (n < 2) return 1;
- Standard_Real tol = 1.e-7;
- TopoDS_Shape S = DBRep::Get(a[1]);
- if (S.IsNull()) return 1;
+ if (n < 2)
+ {
+ di << "Use sameparameter [result] shape [toler]\n";
+ di << "shape is an initial shape\n";
+ di << "result is a result shape. if skipped = > initial shape will be modified\n";
+ di << "toler is tolerance (default is 1.e-7)";
+ return 1;
+ }
+ Standard_Real aTol = 1.e-7;
Standard_Boolean force = !strcmp(a[0],"fsameparameter");
- if (n == 3) tol = Draw::Atof(a[2]);
- BRepLib::SameParameter(S,tol,force);
+ Standard_Real aTol1 = Draw::Atof(a[n-1]);
+ Standard_Boolean IsUseTol = aTol1>0;
+ if (IsUseTol)
+ aTol = aTol1;
+
+ TopoDS_Shape anInpS = DBRep::Get(IsUseTol ? a[n-2] : a[n-1]);
+ if (anInpS.IsNull())
+ return 1;
+
+ if ((n == 4 && IsUseTol) || (n == 3 && !IsUseTol))
+ {
+ TopoDS_Shape aResultSh;
+ BRepTools_ReShape aResh;
+ BRepLib::SameParameter(anInpS,aResh,aTol,force);
+ aResultSh = aResh.Apply(anInpS);
+ DBRep::Set(a[1],aResultSh);
+ }
+ else
+ {
+ BRepLib::SameParameter(anInpS,aTol,force);
+ DBRep::Set(a[1],anInpS);
+ }
- DBRep::Set(a[1],S);
return 0;
}
//=======================================================================
//function : updatetol
//purpose :
//=======================================================================
-static Standard_Integer updatetol(Draw_Interpretor& ,Standard_Integer n,const char** a)
+static Standard_Integer updatetol(Draw_Interpretor& di,Standard_Integer n,const char** a)
{
- if (n < 2) return 1;
+ if (n < 2)
+ {
+ di << "Use updatetololerance [result] shape [param]\n";
+ di << "shape is an initial shape\n";
+ di << "result is a result shape. if skipped = > initial shape will be modified\n";
+ di << "if [param] is absent - not verify of face tolerance, else - perform it";
+ return 1;
+ }
+ TopoDS_Shape aSh1 = DBRep::Get(a[n-1]);
+ Standard_Boolean IsF = aSh1.IsNull();
- TopoDS_Shape S = DBRep::Get(a[1]);
- if (S.IsNull()) return 1;
+ TopoDS_Shape anInpS = IsF ? DBRep::Get(a[n-2]) : aSh1;
+ if (anInpS.IsNull())
+ return 1;
- if (n==2) BRepLib::UpdateTolerances(S);
- else BRepLib::UpdateTolerances(S,Standard_True);
- DBRep::Set(a[1],S);
- return 0;
+ if ((n == 4 && IsF) || (n == 3 && !IsF))
+ {
+ TopoDS_Shape aResultSh;
+ BRepTools_ReShape aResh;
+ BRepLib::UpdateTolerances(anInpS,aResh, IsF);
+ aResultSh = aResh.Apply(anInpS);
+ DBRep::Set(a[1],aResultSh);
+ }
+ else
+ {
+ BRepLib::UpdateTolerances(anInpS, IsF);
+ DBRep::Set(a[1],anInpS);
+ }
+ return 0;
}
//=======================================================================
}
-//=======================================================================
-//function : boundingstr
-//purpose :
-//=======================================================================
-static Standard_Integer boundingstr(Draw_Interpretor& di,Standard_Integer n,const char** a)
-{
- if (n < 2) return 1;
- TopoDS_Shape S = DBRep::Get(a[1]);
- if (S.IsNull()) return 1;
- Bnd_Box B;
- BRepBndLib::Add(S,B);
- Standard_Real axmin,aymin,azmin,axmax,aymax,azmax;
- B.Get(axmin,aymin,azmin,axmax,aymax,azmax);
- di << axmin<<" "<< aymin<<" "<< azmin<<" "<< axmax<<" "<< aymax<<" "<< azmax;
- if (n >= 8) {
- Draw::Set(a[2],axmin) ;
- Draw::Set(a[3],aymin) ;
- Draw::Set(a[4],azmin) ;
- Draw::Set(a[5],axmax) ;
- Draw::Set(a[6],aymax) ;
- Draw::Set(a[7],azmax) ;
- }
- return 0;
-}
-
//=======================================================================
//function : getcoords
//purpose :
return 0;
}
+//! Parse 6 real values for defining AABB.
+static Standard_Boolean parseMinMax (const char** theArgVec, Bnd_Box& theBox)
+{
+ const TCollection_AsciiString aMin[3] = { theArgVec[0], theArgVec[1], theArgVec[2] };
+ const TCollection_AsciiString aMax[3] = { theArgVec[3], theArgVec[4], theArgVec[5] };
+ if (!aMin[0].IsRealValue()
+ || !aMin[1].IsRealValue()
+ || !aMin[2].IsRealValue()
+ || !aMax[0].IsRealValue()
+ || !aMax[1].IsRealValue()
+ || !aMax[2].IsRealValue())
+ {
+ return Standard_False;
+ }
+
+ const gp_Pnt aPntMin (aMin[0].RealValue(), aMin[1].RealValue(), aMin[2].RealValue());
+ const gp_Pnt aPntMax (aMax[0].RealValue(), aMax[1].RealValue(), aMax[2].RealValue());
+ theBox.SetVoid();
+ theBox.Add (aPntMin);
+ theBox.Add (aPntMax);
+ return Standard_True;
+}
+
//=======================================================================
-//function : bounding
+//function : BoundBox
//purpose :
//=======================================================================
-static Standard_Integer bounding(Draw_Interpretor& di,Standard_Integer n,const char** a)
+static Standard_Integer BoundBox(Draw_Interpretor& theDI,
+ Standard_Integer theNArg,
+ const char** theArgVal)
{
- if (n < 2) return 1;
- Standard_Real axmin,aymin,azmin,axmax,aymax,azmax;
- Bnd_Box B; Handle(Draw_Box) DB;
+ // 1. Parse arguments
+
+ TopoDS_Shape aShape;
+ Bnd_Box anAABB;
+
+ Standard_Boolean doPrint = Standard_False;
+ Standard_Boolean useOldSyntax = Standard_False;
+ Standard_Boolean isOBB = Standard_False;
+ Standard_Boolean isTriangulationReq = Standard_True;
+ Standard_Boolean isOptimal = Standard_False;
+ Standard_Boolean isTolerUsed = Standard_False;
+ Standard_Boolean isFinitePart = Standard_False;
+ Standard_Boolean hasToDraw = Standard_True;
- if (n == 2) {
- TopoDS_Shape S = DBRep::Get(a[1]);
- if (S.IsNull()) return 1;
- BRepBndLib::Add(S,B);
- B.Get(axmin,aymin,azmin,axmax,aymax,azmax);
- DB = new Draw_Box(gp_Pnt(axmin,aymin,azmin),gp_Pnt(axmax,aymax,azmax),Draw_orange);
- dout<<DB;
- di << axmin<<" "<< aymin<<" "<< azmin<<" "<< axmax<<" "<< aymax<<" "<< azmax;
- }
- else if (n == 7) {
- axmin=Draw::Atof(a[1]);
- aymin=Draw::Atof(a[2]);
- azmin=Draw::Atof(a[3]);
- axmax=Draw::Atof(a[4]);
- aymax=Draw::Atof(a[5]);
- azmax=Draw::Atof(a[6]);
- DB = new Draw_Box(gp_Pnt(axmin,aymin,azmin),gp_Pnt(axmax,aymax,azmax),Draw_orange);
- dout<<DB;
+ TCollection_AsciiString anOutVars[6];
+ TCollection_AsciiString aResShapeName;
+ for (Standard_Integer anArgIter = 1; anArgIter < theNArg; ++anArgIter)
+ {
+ TCollection_AsciiString anArgCase (theArgVal[anArgIter]);
+ anArgCase.LowerCase();
+ if (anArgCase == "-obb")
+ {
+ isOBB = Standard_True;
+ }
+ else if (anArgCase == "-aabb")
+ {
+ isOBB = Standard_False;
+ }
+ else if (anArgCase == "-shape"
+ && anArgIter + 1 < theNArg
+ && aResShapeName.IsEmpty())
+ {
+ aResShapeName = theArgVal[++anArgIter];
+ hasToDraw = Standard_False;
+ }
+ else if (anArgCase == "-dump"
+ || anArgCase == "-print")
+ {
+ doPrint = Standard_True;
+ }
+ else if (anArgCase == "-save"
+ && anArgIter + 6 < theNArg
+ && anOutVars[0].IsEmpty())
+ {
+ for (int aCompIter = 0; aCompIter < 6; ++aCompIter)
+ {
+ anOutVars[aCompIter] = theArgVal[anArgIter + aCompIter + 1];
+ }
+ anArgIter += 6;
+ }
+ else if (anArgCase == "-notriangulation")
+ {
+ isTriangulationReq = Standard_False;
+ }
+ else if (anArgCase == "-optimal")
+ {
+ isOptimal = Standard_True;
+ }
+ else if (anArgCase == "-exttoler")
+ {
+ isTolerUsed = Standard_True;
+ }
+ else if (anArgCase == "-nodraw")
+ {
+ hasToDraw = Standard_False;
+ }
+ else if (anArgCase == "-finite"
+ || anArgCase == "-finitepart")
+ {
+ isFinitePart = Standard_True;
+ }
+ else if (aShape.IsNull()
+ && !DBRep::Get (theArgVal[anArgIter]).IsNull())
+ {
+ aShape = DBRep::Get (theArgVal[anArgIter]);
+ }
+ else if (anAABB.IsVoid()
+ && anArgIter + 5 < theNArg
+ && parseMinMax (theArgVal + anArgIter, anAABB))
+ {
+ anArgIter += 5;
+ }
+ else
+ {
+ std::cout << "Syntax error at argument '" << theArgVal[anArgIter] << "'.\n";
+ return 1;
+ }
+ }
+
+ if (anAABB.IsVoid()
+ && aShape.IsNull())
+ {
+ std::cout << "Syntax error: input is not specified (neither shape nor coordinates)\n";
+ return 1;
+ }
+ else if (!anAABB.IsVoid()
+ && (isOBB || isOptimal || isTolerUsed))
+ {
+ std::cout << "Syntax error: Options -obb, -optimal and -extToler cannot be used for explicitly defined AABB.\n";
+ return 1;
+ }
+ else if (isOBB
+ && !anOutVars[0].IsEmpty())
+ {
+ std::cout << "Error: Option -save works only with axes-aligned boxes.\n";
+ return 1;
+ }
+
+ // enable printing (old syntax) if neither saving to shape nor to DRAW variables is requested
+ if (! doPrint && anOutVars[0].IsEmpty() && aResShapeName.IsEmpty())
+ {
+ doPrint = Standard_True;
+ useOldSyntax = Standard_True;
+ }
+
+ // 2. Compute box and save results
+ Handle(Draw_Box) aDB;
+ if (isOBB)
+ {
+ Bnd_OBB anOBB;
+ BRepBndLib::AddOBB(aShape, anOBB, isTriangulationReq, isOptimal, isTolerUsed);
+
+ if (anOBB.IsVoid())
+ {
+ theDI << "Void box.\n";
+ }
+ else if (doPrint)
+ {
+ const gp_Pnt &aBaryCenter= anOBB.Center();
+ const gp_XYZ &aXDir = anOBB.XDirection(),
+ &aYDir = anOBB.YDirection(),
+ &aZDir = anOBB.ZDirection();
+ theDI << "Oriented bounding box\n";
+ theDI << "Center: " << aBaryCenter.X() << " " <<
+ aBaryCenter.Y() << " " <<
+ aBaryCenter.Z() << "\n";
+ theDI << "X-axis: " << aXDir.X() << " " << aXDir.Y() << " " << aXDir.Z() << "\n";
+ theDI << "Y-axis: " << aYDir.X() << " " << aYDir.Y() << " " << aYDir.Z() << "\n";
+ theDI << "Z-axis: " << aZDir.X() << " " << aZDir.Y() << " " << aZDir.Z() << "\n";
+ theDI << "Half X: " << anOBB.XHSize() << "\n"
+ << "Half Y: " << anOBB.YHSize() << "\n"
+ << "Half Z: " << anOBB.ZHSize() << "\n";
+ }
+
+ if (hasToDraw
+ && !anOBB.IsVoid())
+ {
+ aDB = new Draw_Box (anOBB, Draw_orange);
+ }
+
+ if (!aResShapeName.IsEmpty())
+ {
+ ConvertBndToShape (anOBB, aResShapeName.ToCString());
+ }
+ }
+ else // if(!isOBB)
+ {
+ if (!aShape.IsNull())
+ {
+ anAABB.SetVoid ();
+ if(isOptimal)
+ {
+ BRepBndLib::AddOptimal (aShape, anAABB, isTriangulationReq, isTolerUsed);
+ }
+ else
+ {
+ BRepBndLib::Add (aShape, anAABB, isTriangulationReq);
+ }
+ }
+
+ if (anAABB.IsVoid())
+ {
+ theDI << "Void box.\n";
+ }
+ else
+ {
+ if (isFinitePart && anAABB.IsOpen())
+ {
+ anAABB = anAABB.FinitePart();
+ }
+ const gp_Pnt aMin = anAABB.CornerMin();
+ const gp_Pnt aMax = anAABB.CornerMax();
+
+ // print to DRAW
+ if (doPrint)
+ {
+ if (useOldSyntax)
+ {
+ theDI << aMin.X() << " " << aMin.Y() << " " << aMin.Z() << " "
+ << aMax.X() << " " << aMax.Y() << " " << aMax.Z() << "\n";
+ }
+ else
+ {
+ theDI << "Axes-aligned bounding box\n";
+ theDI << "X-range: " << aMin.X() << " " << aMax.X() << "\n"
+ << "Y-range: " << aMin.Y() << " " << aMax.Y() << "\n"
+ << "Z-range: " << aMin.Z() << " " << aMax.Z() << "\n";
+ if (anAABB.IsOpen()
+ && anAABB.HasFinitePart())
+ {
+ Bnd_Box aFinitAabb = anAABB.FinitePart();
+ const gp_Pnt aFinMin = aFinitAabb.CornerMin();
+ const gp_Pnt aFinMax = aFinitAabb.CornerMax();
+ theDI << "Finite part\n";
+ theDI << "X-range: " << aFinMin.X() << " " << aFinMax.X() << "\n"
+ << "Y-range: " << aFinMin.Y() << " " << aFinMax.Y() << "\n"
+ << "Z-range: " << aFinMin.Z() << " " << aFinMax.Z() << "\n";
+ }
+ }
+ }
+
+ // save DRAW variables
+ if (!anOutVars[0].IsEmpty())
+ {
+ Draw::Set (anOutVars[0].ToCString(), aMin.X());
+ Draw::Set (anOutVars[1].ToCString(), aMin.Y());
+ Draw::Set (anOutVars[2].ToCString(), aMin.Z());
+ Draw::Set (anOutVars[3].ToCString(), aMax.X());
+ Draw::Set (anOutVars[4].ToCString(), aMax.Y());
+ Draw::Set (anOutVars[5].ToCString(), aMax.Z());
+ }
+
+ // add presentation to DRAW viewer
+ if (hasToDraw)
+ {
+ aDB = new Draw_Box (anAABB, Draw_orange);
+ }
+ }
+
+ // save as shape
+ if (!aResShapeName.IsEmpty())
+ {
+ ConvertBndToShape (anAABB, aResShapeName.ToCString());
+ }
+ }
+
+ if (!aDB.IsNull())
+ {
+ dout << aDB;
+ }
+ return 0;
+}
+
+//=======================================================================
+//function : IsBoxesInterfered
+//purpose :
+//=======================================================================
+static Standard_Integer IsBoxesInterfered(Draw_Interpretor& theDI,
+ Standard_Integer theNArg,
+ const char** theArgVal)
+{
+ if(theNArg < 2)
+ {
+ theDI << "Use: isbbinterf shape1 shape2 [-o].\n";
+ return 1;
+ }
+
+ const TopoDS_Shape aShape1 = DBRep::Get(theArgVal[1]);
+ const TopoDS_Shape aShape2 = DBRep::Get(theArgVal[2]);
+
+ Standard_Boolean isOBB = (theNArg > 3) && (!strcmp(theArgVal[3], "-o"));
+
+ if(isOBB)
+ {
+ Bnd_OBB anOBB1, anOBB2;
+ BRepBndLib::AddOBB(aShape1, anOBB1);
+ BRepBndLib::AddOBB(aShape2, anOBB2);
+
+ if(anOBB1.IsOut(anOBB2))
+ {
+ theDI << "The shapes are NOT interfered by OBB.\n";
+ }
+ else
+ {
+ theDI << "The shapes are interfered by OBB.\n";
+ }
+ }
+ else
+ {
+ Bnd_Box anAABB1, anAABB2;
+ BRepBndLib::Add(aShape1, anAABB1);
+ BRepBndLib::Add(aShape2, anAABB2);
+
+ if(anAABB1.IsOut(anAABB2))
+ {
+ theDI << "The shapes are NOT interfered by AABB.\n";
+ }
+ else
+ {
+ theDI << "The shapes are interfered by AABB.\n";
+ }
+ }
+
+ return 0;
+}
+
+//=======================================================================
+//function : gbounding
+//purpose :
+//=======================================================================
+#include <GeomAdaptor_Surface.hxx>
+#include <BndLib_AddSurface.hxx>
+#include <BndLib_Add3dCurve.hxx>
+#include <BndLib_Add2dCurve.hxx>
+#include <Draw_Segment2D.hxx>
+static Standard_Integer gbounding(Draw_Interpretor& di,Standard_Integer n,const char** a)
+{
+ if (n != 2 && n != 3)
+ {
+ di << "Usage: gbounding surf/curve/curve2d [-o] \n";
+ di << "[-o] turn on Optimal mode ('off' by default) \n";
+ return 1;
+ }
+ else
+ {
+ Standard_Boolean IsOptimal = Standard_False;
+ if (n == 3 && !strcmp(a[2], "-o"))
+ IsOptimal = Standard_True;
+
+ Standard_Real axmin,aymin,azmin,axmax,aymax,azmax;
+ Bnd_Box B;
+ Bnd_Box2d B2d;
+ Handle(Draw_Box) DB;
+ Standard_Boolean Is3d = Standard_True;
+ Handle(Geom_Curve) C;
+ Handle(Geom_Surface) S;
+ Handle_Geom2d_Curve C2d;
+ S = DrawTrSurf::GetSurface(a[1]);
+ if (!S.IsNull())
+ {
+ //add surf
+ GeomAdaptor_Surface aGAS(S);
+ if (IsOptimal)
+ BndLib_AddSurface::AddOptimal(aGAS, Precision::Confusion(), B);
+ else
+ BndLib_AddSurface::Add(aGAS, Precision::Confusion(), B);
+ }
+ else
+ {
+ C = DrawTrSurf::GetCurve(a[1]);
+ if (!C.IsNull())
+ {
+ // add cur
+ GeomAdaptor_Curve aGAC(C);
+ if (IsOptimal)
+ BndLib_Add3dCurve::AddOptimal(aGAC, Precision::Confusion(), B);
+ else
+ BndLib_Add3dCurve::Add(aGAC, Precision::Confusion(), B);
+ }
+ else
+ {
+ C2d = DrawTrSurf::GetCurve2d(a[1]);
+ if (!C2d.IsNull())
+ {
+ //add cur2d
+ Is3d = Standard_False;
+ if (IsOptimal)
+ BndLib_Add2dCurve::AddOptimal(C2d, C2d->FirstParameter(), C2d->LastParameter(), Precision::Confusion(), B2d);
+ else
+ BndLib_Add2dCurve::Add(C2d, C2d->FirstParameter(), C2d->LastParameter(), Precision::Confusion(), B2d);
+ }
+ else
+ {
+ di << "Wrong argument \n";
+ return 1;
+ }
+ }
+ }
+
+ if (Is3d)
+ {
+ B.Get(axmin,aymin,azmin,axmax,aymax,azmax);
+ DB = new Draw_Box(B, Draw_vert);
+ dout<<DB;
+ di << axmin<<" "<< aymin<<" "<< azmin<<" "<< axmax<<" "<< aymax<<" "<< azmax;
+ }
+ else
+ {
+ B2d.Get(axmin,aymin,axmax,aymax);
+ gp_Pnt2d p1(axmin, aymin);
+ gp_Pnt2d p2(axmax, aymin);
+ gp_Pnt2d p3(axmax, aymax);
+ gp_Pnt2d p4(axmin, aymax);
+ Draw_Segment2D* S1 = new Draw_Segment2D(p1, p2, Draw_vert);
+ Draw_Segment2D* S2 = new Draw_Segment2D(p2, p3, Draw_vert);
+ Draw_Segment2D* S3 = new Draw_Segment2D(p3, p4, Draw_vert);
+ Draw_Segment2D* S4 = new Draw_Segment2D(p4, p1, Draw_vert);
+ dout << S1 << S2 << S3 << S4;
+ di << axmin<<" "<< aymin<<" "<< axmax<<" "<< aymax;
+ }
}
return 0;
}
+
//=======================================================================
//function : findplane
//purpose :
if (a_plane_finder.Found()) {
//cout << " a plane is found " ;
di << " a plane is found \n";
- DrawTrSurf::Set(a[2],a_plane_finder.Plane()) ;
+ const Handle(Geom_Geometry)& aSurf = a_plane_finder.Plane(); // to avoid ambiguity
+ DrawTrSurf::Set(a[2],aSurf) ;
}
return 0 ;
}
TopoDS_Shape TheShape1 = DBRep::Get(id1);
//cout << "Pick positions with button "<<endl;
- di << "Pick positions with button "<< "\n";
+ di << "Pick positions with button \n";
Standard_Integer id,X,Y,b;
gp_Trsf T;
gp_Pnt P1,P2;
nbV = mapS.Extent();
-//#ifndef WNT
Standard_SStream sss;
sss << "\n## Tolerances on the shape " << a[1] << " (nbFaces:" << nbF
<< " nbEdges:" << nbE << " nbVtx:" << nbV << ")\n" ;
if(TmE<=TME) sss << "\n Edge : Min " << setw(8) << TmE <<" Max " << setw(8) << TME << " \n ";
if(TmV<=TMV) sss << "\n Vertex : Min " << setw(8) << TmV <<" Max " << setw(8) << TMV << " \n ";
theCommands << sss;
- //#endif*/
+
return 0;
}
static Standard_Integer vecdc(Draw_Interpretor& di,Standard_Integer ,const char** ) {
//cout << "Pick positions with button "<<endl;
- di << "Pick positions with button "<< "\n";
+ di << "Pick positions with button \n";
Standard_Integer id,X,Y,b;
gp_Trsf T;
Standard_Boolean IsWire=OrtProj.BuildWire(Wire);
if (IsWire) {
//cout << " BuildWire OK " << endl;
- di << " BuildWire OK " << "\n";
+ di << " BuildWire OK \n";
}
DBRep::Set(a[1], OrtProj.Shape());
return 0;
aGTrsf.SetVectorialPart(rot);
BRepBuilderAPI_GTransform aBRepGTrsf (aShapeBase, aGTrsf, Standard_False);
if (!aBRepGTrsf.IsDone())
- Standard_ConstructionError::Raise("Scaling not done");
+ throw Standard_ConstructionError("Scaling not done");
TopoDS_Shape Result = aBRepGTrsf.Shape();
DBRep::Set(a[1], Result);
return 0;
}
+//=======================================================================
+//function : compareshapes
+//purpose :
+//=======================================================================
+static Standard_Integer compareshapes(Draw_Interpretor& di,
+ Standard_Integer n,
+ const char** a)
+{
+ if (n != 3) {
+ di << "Compare shapes. Usage: compare shape1 shape2\n";
+ return 1;
+ }
+ // get shapes
+ TopoDS_Shape aS1 = DBRep::Get(a[1]);
+ TopoDS_Shape aS2 = DBRep::Get(a[2]);
+ // check shapes
+ if (aS1.IsNull() || aS2.IsNull()) {
+ di << "null shapes\n";
+ return 0;
+ }
+ // compare shapes
+ if (aS1.IsSame(aS2)) {
+ di << "same shapes\n";
+ if (aS1.IsEqual(aS2)) {
+ di << "equal shapes\n";
+ }
+ }
+ else {
+ di << "shapes are not same\n";
+ }
+ return 0;
+}
+
+//=======================================================================
+//function : issubshape
+//purpose :
+//=======================================================================
+static Standard_Integer issubshape(Draw_Interpretor& di,
+ Standard_Integer n,
+ const char** a)
+{
+ if (n != 3) {
+ di << "Check if the shape is sub-shape of other shape and get its index in the shape.\n";
+ di << "Usage: issubshape subshape shape\n";
+ return 1;
+ }
+ // get shapes
+ TopoDS_Shape aSubShape = DBRep::Get(a[1]);
+ TopoDS_Shape aShape = DBRep::Get(a[2]);
+ // check shapes
+ if (aSubShape.IsNull() || aShape.IsNull()) {
+ di << "null shapes\n";
+ return 0;
+ }
+ // find index of the sub-shape in the shape
+ TopTools_MapOfShape aMShapes;
+ // try to find the SubShape in Shape
+ TopExp_Explorer anExp(aShape, aSubShape.ShapeType());
+ for (; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape& aSS = anExp.Current();
+ if (aMShapes.Add(aSS)) {
+ if (aSS.IsSame(aSubShape)) {
+ break;
+ }
+ }
+ }
+ //
+ if (anExp.More()) {
+ di << a[1] << " is sub-shape of " << a[2] << ". Index in the shape: " << aMShapes.Extent() << ".\n";
+ }
+ else {
+ di << a[1] << " is NOT sub-shape of " << a[2] << ".\n";
+ }
+ //
+ return 0;
+}
+
void BRepTest::BasicCommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
transform,g);
theCommands.Add("tmove",
- "tmove name1 name2 ... name, set location from name",
+ "tmove name1 name2 ... name, set location from name [-copy]",
__FILE__,
transform,g);
theCommands.Add("ttranslate",
- "ttranslate name1 name2 ... dx dy dz",
+ "ttranslate name1 name2 ... dx dy dz [-copy]",
__FILE__,
transform,g);
theCommands.Add("trotate",
- "trotate name1 name2 ... x y z dx dy dz angle",
+ "trotate name1 name2 ... x y z dx dy dz angle [-copy]",
__FILE__,
transform,g);
theCommands.Add("tmirror",
- "tmirror name x y z dx dy dz",
+ "tmirror name x y z dx dy dz [-copy]",
__FILE__,
transform,g);
theCommands.Add("tscale",
- "tscale name x y z scale",
+ "tscale name x y z scale [-copy]",
__FILE__,
transform,g);
theCommands.Add("tcopy",
- "tcopy [-n(ogeom)] name1 result1 [name2 result2 ...]",
+ "tcopy [-n(ogeom)] [-m(esh)] name1 result1 [name2 result2 ...]",
__FILE__,
tcopy,g);
sameparameter,g);
theCommands.Add("sameparameter",
- "sameparameter shapename [tol (default 1.e-7)]",
+ "sameparameter [result] shape [tol]",
__FILE__,
sameparameter,g);
theCommands.Add("updatetolerance",
- "updatetolerance myShape [param] \n if [param] is absent - not verify of face tolerance, else - perform it",
+ "updatetolerance [result] shape [param] \n if [param] is absent - not verify of face tolerance, else - perform it",
__FILE__,
updatetol,g);
__FILE__,
getcoords,g);
- theCommands.Add("bounding",
- "bounding shape [ xmin ymin zmin xmax ymax zmax] ; draw bounds",
+ theCommands.Add ("bounding",
+ "bounding {shape | xmin ymin zmin xmax ymax zmax}"
+ "\n\t\t: [-obb] [-noTriangulation] [-optimal] [-extToler]"
+ "\n\t\t: [-dump] [-shape name] [-nodraw] [-finitePart]"
+ "\n\t\t: [-save xmin ymin zmin xmax ymax zmax]"
+ "\n\t\t:"
+ "\n\t\t: Computes a bounding box. Two types of the source data are supported:"
+ "\n\t\t: a shape or AABB corners (xmin, ymin, zmin, xmax, ymax, zmax)."
+ "\n\t\t:"
+ "\n\t\t: Calculation options (applicable only if input is a shape):"
+ "\n\t\t: -obb Compute Oriented Bounding Box (OBB) instead of AABB."
+ "\n\t\t: -noTriangulation Force use of exact geometry for calculation"
+ "\n\t\t: even if triangulation is present."
+ "\n\t\t: -optimal Force calculation of optimal (more tight) AABB."
+ "\n\t\t: In case of OBB, applies to initial AABB used in OBB calculation."
+ "\n\t\t: -extToler Include tolerance of the shape in the resulting box."
+ "\n\t\t:"
+ "\n\t\t: Output options:"
+ "\n\t\t: -dump Prints the information about computed Bounding Box."
+ "\n\t\t: It is enabled by default (with plain old syntax for AABB)"
+ "\n\t\t: if neither -shape nor -save is specified."
+ "\n\t\t: -shape Stores computed box as solid in DRAW variable with specified name."
+ "\n\t\t: -save Stores min and max coordinates of AABB in specified variables."
+ "\n\t\t: -noDraw Avoid drawing resulting Bounding Box in DRAW viewer."
+ "\n\t\t: -finite Return finite part of infinite box.",
+ __FILE__, BoundBox, g);
+
+ //
+ theCommands.Add("gbounding",
+ "gbounding surf/curve/curve2d [-o] ",
__FILE__,
- bounding,g);
+ gbounding,g);
- theCommands.Add("boundingstr",
- "boundingstr shape [ xmin ymin zmin xmax ymax zmax] ; print bounding box",
- __FILE__,
- boundingstr,g);
+ theCommands.Add("isbbinterf", "isbbinterf shape1 shape2 [-o]\n"
+ "Checks whether the bounding-boxes created from "
+ "the given shapes are interfered. If \"-o\"-option "
+ "is switched on then the oriented boxes will be checked. "
+ "Otherwise, axes-aligned boxes will be checked.",
+ __FILE__, IsBoxesInterfered, g);
theCommands.Add("nurbsconvert",
"nurbsconvert result name [result name]",
"scalexyz res shape factor_x factor_y factor_z",
__FILE__,
scalexyz, g);
+
+ theCommands.Add("compare",
+ "Compare shapes. Usage: compare shape1 shape2",
+ __FILE__,
+ compareshapes, g);
+
+ theCommands.Add("issubshape",
+ "issubshape subshape shape\n"
+ "\t\tCheck if the shape is sub-shape of other shape and get its index in the shape.",
+ __FILE__,
+ issubshape, g);
}