Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
// Created on: 1995-06-16
// Created by: Jacques GOUSSARD
// 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 <Draw_Interpretor.hxx>
#include <Draw_Appli.hxx>
#include <DrawTrSurf.hxx>
#include <Draw_ProgressIndicator.hxx>
#include <TopExp_Explorer.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_CylindricalSurface.hxx>
// #include <BRepFeat_LocalOperation.hxx>
#include <BRepFeat_MakeCylindricalHole.hxx>
#include <BRepFeat_SplitShape.hxx>
#include <BRepFeat_Gluer.hxx>
#include <BRepFeat.hxx>
#include <BRepFeat_MakePrism.hxx>
#include <BRepFeat_MakeRevol.hxx>
#include <BRepFeat_MakePipe.hxx>
#include <BRepFeat_MakeDPrism.hxx>
#include <BRepFeat_MakeLinearForm.hxx>
#include <BRepFeat_MakeRevolutionForm.hxx>
#include <LocOpe_FindEdges.hxx>
#include <LocOpe_FindEdgesInFace.hxx>
#include <BRepOffset_MakeOffset.hxx>
#include <BRepOffsetAPI_MakeOffsetShape.hxx>
#include <BRepOffset_MakeSimpleOffset.hxx>
#include <BRep_Builder.hxx>
#include <DBRep.hxx>
#include <DBRep_DrawableShape.hxx>
#include <BRepTest.hxx>
#include <BRepTest_Objects.hxx>
#include <BRepFilletAPI_MakeFillet.hxx>
#include <ChFi3d_FilletShape.hxx>
#include <Message.hxx>
#include <Precision.hxx>
#ifdef _WIN32
Standard_IMPORT Draw_Viewer dout;
#endif
static BRepFeat_MakeCylindricalHole& getHole()
{
static BRepFeat_MakeCylindricalHole theHole;
return theHole;
}
static Standard_Boolean WithControl = Standard_True;
Standard_Boolean DownCastingEnforcing = Standard_False;
static BRepFeat_MakePrism& getPrism()
{
static BRepFeat_MakePrism thePrism;
return thePrism;
}
static BRepFeat_MakeDPrism& getDPrism()
{
static BRepFeat_MakeDPrism theDPrism;
return theDPrism;
}
static BRepFeat_MakeRevol& getRevol()
{
static BRepFeat_MakeRevol theRevol;
return theRevol;
}
static BRepFeat_MakePipe& getPipe()
{
static BRepFeat_MakePipe thePipe;
return thePipe;
}
static BRepFeat_MakeLinearForm& getLienarForm()
{
static BRepFeat_MakeLinearForm theLF;
return theLF;
}
static BRepFeat_MakeRevolutionForm& getRevolutionForm()
{
static BRepFeat_MakeRevolutionForm theRF;
return theRF;
}
// Input shapes for Prism, DPrism, Revol, Pipe
static TopoDS_Shape theSbase, thePbase;
static TopoDS_Face theSkface;
static Standard_Boolean dprdef = Standard_False;
static Standard_Boolean prdef = Standard_False;
static Standard_Boolean rvdef = Standard_False;
static Standard_Boolean pidef = Standard_False;
static Standard_Boolean lfdef = Standard_False;
static Standard_Boolean rfdef = Standard_False;
static Standard_Real tesp = 1.0e-4;
static Standard_Real t3d = 1.e-4;
static Standard_Real t2d = 1.e-5;
static Standard_Real ta = 1.e-2;
static Standard_Real fl = 1.e-3;
static Standard_Real tapp_angle = 1.e-2;
static GeomAbs_Shape blend_cont = GeomAbs_C1;
static BRepFilletAPI_MakeFillet* Rakk = 0;
static void Print(Draw_Interpretor& di, const BRepFeat_Status St)
{
di << " Error Status : ";
switch (St)
{
case BRepFeat_NoError:
di << "No error";
break;
case BRepFeat_InvalidPlacement:
di << "Invalid placement";
break;
case BRepFeat_HoleTooLong:
di << "Hole too long";
break;
}
}
static Standard_Integer Loc(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 6)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
TopoDS_Shape T = DBRep::Get(a[3]);
Standard_Boolean Fuse;
if (!strcasecmp("F", a[4]))
{
Fuse = Standard_True;
}
else if (!strcasecmp("C", a[4]))
{
Fuse = Standard_False;
}
else
{
return 1;
}
TopTools_ListOfShape LF;
for (Standard_Integer i = 0; i <= narg - 6; i++)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[i + 5], TopAbs_FACE));
LF.Append(aLocalShape);
// LF.Append(TopoDS::Face(DBRep::Get(a[i+5],TopAbs_FACE)));
}
// BRepFeat_LocalOperation BLoc(S);
// BLoc.Perform(T,LF,Fuse);
// BLoc.BuildPartsOfTool();
TopTools_ListOfShape parts;
BRepFeat_Builder BLoc;
BLoc.Init(S, T);
BLoc.SetOperation(Fuse);
// BRepFeat_LocalOperation BLoc;
// BLoc.Init(S,T,Fuse);
BLoc.Perform();
BLoc.PartsOfTool(parts);
#if 0
char newname[1024];
strcpy(newname, a[1]);
char* p = newname;
while (*p != '\0') p++;
*p = '_';
p++;
TopTools_ListIteratorOfListOfShape its(parts);
dout.Clear();
i = 0;
for (; its.More(); its.Next()) {
i++;
Sprintf(p, "%d", i);
DBRep::Set(newname, its.Value());
}
if (i >= 2) {
dout.Flush();
Standard_Integer qq, ww, ee, button;
TopoDS_Shell S;
do {
TopoDS_Shape aLocalShape(DBRep::Get(".", TopAbs_SHELL));
S = TopoDS::Shell(aLocalShape);
// S = TopoDS::Shell(DBRep::Get(".",TopAbs_SHELL));
Draw::LastPick(qq, ww, ee, button);
if (!S.IsNull()) {
switch (button) {
case 1:
//BLoc.RemovePart(S);
break;
case 2:
BLoc.KeepPart(S);
break;
default:
{}
}
}
else {
button = 3;
}
} while (button != 3);
}
#endif
BLoc.PerformResult();
if (!BLoc.HasErrors())
{
// dout.Clear();
DBRep::Set(a[1], BLoc.Shape());
dout.Flush();
return 0;
}
theCommands << "Local operation not done";
return 1;
}
static Standard_Integer HOLE1(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 10 || narg == 11)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
gp_Pnt Or(Draw::Atof(a[3]), Draw::Atof(a[4]), Draw::Atof(a[5]));
gp_Dir Di(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
Standard_Real Radius = Draw::Atof(a[9]);
getHole().Init(S, gp_Ax1(Or, Di));
if (narg <= 10)
{
getHole().Perform(Radius);
}
else
{
Standard_Real pfrom = Draw::Atof(a[10]);
Standard_Real pto = Draw::Atof(a[11]);
getHole().Perform(Radius, pfrom, pto, WithControl);
}
getHole().Build();
if (!getHole().HasErrors())
{
// dout.Clear();
DBRep::Set(a[1], getHole().Shape());
dout.Flush();
return 0;
}
theCommands << "Echec de MakeCylindricalHole";
Print(theCommands, getHole().Status());
return 1;
}
static Standard_Integer HOLE2(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 10)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
gp_Pnt Or(Draw::Atof(a[3]), Draw::Atof(a[4]), Draw::Atof(a[5]));
gp_Dir Di(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
Standard_Real Radius = Draw::Atof(a[9]);
getHole().Init(S, gp_Ax1(Or, Di));
getHole().PerformThruNext(Radius, WithControl);
getHole().Build();
if (!getHole().HasErrors())
{
// dout.Clear();
DBRep::Set(a[1], getHole().Shape());
dout.Flush();
return 0;
}
theCommands << "Echec de MakeCylindricalHole";
Print(theCommands, getHole().Status());
return 1;
}
static Standard_Integer HOLE3(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 10)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
gp_Pnt Or(Draw::Atof(a[3]), Draw::Atof(a[4]), Draw::Atof(a[5]));
gp_Dir Di(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
Standard_Real Radius = Draw::Atof(a[9]);
getHole().Init(S, gp_Ax1(Or, Di));
getHole().PerformUntilEnd(Radius, WithControl);
getHole().Build();
if (!getHole().HasErrors())
{
// dout.Clear();
DBRep::Set(a[1], getHole().Shape());
dout.Flush();
return 0;
}
theCommands << "Echec de MakeCylindricalHole";
Print(theCommands, getHole().Status());
return 1;
}
static Standard_Integer HOLE4(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 11)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
gp_Pnt Or(Draw::Atof(a[3]), Draw::Atof(a[4]), Draw::Atof(a[5]));
gp_Dir Di(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
Standard_Real Radius = Draw::Atof(a[9]);
Standard_Real Length = Draw::Atof(a[10]);
getHole().Init(S, gp_Ax1(Or, Di));
getHole().PerformBlind(Radius, Length, WithControl);
getHole().Build();
if (!getHole().HasErrors())
{
// dout.Clear();
DBRep::Set(a[1], getHole().Shape());
dout.Flush();
return 0;
}
theCommands << "Echec de MakeCylindricalHole";
Print(theCommands, getHole().Status());
return 1;
}
static Standard_Integer CONTROL(Draw_Interpretor& theCommands,
Standard_Integer narg,
const char** a)
{
if (narg >= 2)
{
WithControl = strcmp("0", a[1]) != 0;
}
if (WithControl)
{
theCommands << "Mode avec controle";
}
else
{
theCommands << "Mode sans controle";
}
return 0;
}
//=======================================================================
// function : reportOffsetState
// purpose : Print state of offset operation by error code.
//=======================================================================
static void reportOffsetState(Draw_Interpretor& theCommands, const BRepOffset_Error theErrorCode)
{
switch (theErrorCode)
{
case BRepOffset_NoError: {
theCommands << "OK. Offset performed successfully.";
break;
}
case BRepOffset_BadNormalsOnGeometry: {
theCommands << "ERROR. Degenerated normal on input data.";
break;
}
case BRepOffset_C0Geometry: {
theCommands << "ERROR. C0 continuity of input data.";
break;
}
case BRepOffset_NullOffset: {
theCommands << "ERROR. Null offset of all faces.";
break;
}
case BRepOffset_NotConnectedShell: {
theCommands
<< "ERROR. Incorrect set of faces to remove, the remaining shell is not connected.";
break;
}
case BRepOffset_CannotTrimEdges: {
theCommands << "ERROR. Can not trim edges.";
break;
}
case BRepOffset_CannotFuseVertices: {
theCommands << "ERROR. Can not fuse vertices.";
break;
}
case BRepOffset_CannotExtentEdge: {
theCommands << "ERROR. Can not extent edge.";
break;
}
case BRepOffset_MixedConnectivity: {
theCommands << "ERROR. Mixed connectivity of faces.";
break;
}
default: {
theCommands << "ERROR. offsetperform operation not done.";
break;
}
}
}
//=================================================================================================
static Standard_Integer PRW(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 9)
return 1;
TopoDS_Shape S = DBRep::Get(a[3]);
BRepFeat_MakePrism thePFace;
gp_Vec V;
TopoDS_Shape FFrom, FUntil;
Standard_Integer borne;
Standard_Boolean fuse;
if (a[1][0] == 'f' || a[1][0] == 'F')
{
fuse = Standard_True;
}
else if (a[1][0] == 'c' || a[1][0] == 'C')
{
fuse = Standard_False;
}
else
{
return 1;
}
if (a[4][0] == '.' || IsAlphabetic(a[4][0]))
{
if (narg < 10)
{
return 1;
}
if (a[5][0] == '.' || IsAlphabetic(a[5][0]))
{
if (narg < 11)
{
return 1;
}
V.SetCoord(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
FFrom = DBRep::Get(a[4], TopAbs_SHAPE);
FUntil = DBRep::Get(a[5], TopAbs_SHAPE);
borne = 9;
}
else
{
V.SetCoord(Draw::Atof(a[5]), Draw::Atof(a[6]), Draw::Atof(a[7]));
FUntil = DBRep::Get(a[4], TopAbs_SHAPE);
borne = 8;
}
}
else
{
V.SetCoord(Draw::Atof(a[4]), Draw::Atof(a[5]), Draw::Atof(a[6]));
borne = 7;
}
Standard_Real Length = V.Magnitude();
if (Length < Precision::Confusion())
{
return 1;
}
TopoDS_Shape aLocalShape(DBRep::Get(a[borne], TopAbs_FACE));
TopoDS_Face F = TopoDS::Face(aLocalShape);
// TopoDS_Face F = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
BRepFeat_SplitShape Spls(F);
for (Standard_Integer i = borne + 1; i < narg; i++)
{
TopoDS_Wire wir;
if (a[i][0] != '-')
{
aLocalShape = DBRep::Get(a[i], TopAbs_WIRE);
wir = TopoDS::Wire(aLocalShape);
// wir = TopoDS::Wire(DBRep::Get(a[i],TopAbs_WIRE));
}
else
{
if (a[i][1] == '\0')
return 1;
const char* Temp = a[i] + 1;
aLocalShape = DBRep::Get(Temp, TopAbs_WIRE);
wir = TopoDS::Wire(aLocalShape);
// wir = TopoDS::Wire(DBRep::Get(Temp,TopAbs_WIRE));
wir.Reverse();
}
Spls.Add(wir, F);
}
Spls.Build();
TopoDS_Shape ToPrism;
const TopTools_ListOfShape& lleft = Spls.DirectLeft();
if (lleft.Extent() == 1)
{
thePFace.Init(S, lleft.First(), F, V, fuse, Standard_True);
ToPrism = lleft.First();
}
else
{
BRep_Builder B;
TopoDS_Shell Sh;
B.MakeShell(Sh);
TopTools_ListIteratorOfListOfShape it;
for (it.Initialize(lleft); it.More(); it.Next())
{
B.Add(Sh, TopoDS::Face(it.Value()));
}
Sh.Closed(BRep_Tool::IsClosed(Sh));
thePFace.Init(S, Sh, F, V, fuse, Standard_True);
ToPrism = Sh;
}
// Recherche des faces de glissement, si on n`a pas sketche sur une face
// du shape de depart
// for (TopExp_Explorer exp(S,TopAbs_FACE);exp.More();exp.Next()) {
TopExp_Explorer exp(S, TopAbs_FACE);
for (; exp.More(); exp.Next())
{
if (exp.Current().IsSame(F))
{
break;
}
}
if (!exp.More())
{
LocOpe_FindEdgesInFace FEIF;
for (exp.Init(S, TopAbs_FACE); exp.More(); exp.Next())
{
const TopoDS_Face& fac = TopoDS::Face(exp.Current());
Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
{
Su = Handle(Geom_RectangularTrimmedSurface)::DownCast(Su)->BasisSurface();
}
if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane))
{
gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
if (pl.Contains(gp_Lin(pl.Location(), V), Precision::Confusion(), Precision::Angular()))
{
FEIF.Set(ToPrism, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
thePFace.Add(FEIF.Edge(), fac);
}
}
}
else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface))
{
gp_Cylinder cy = Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
if (V.IsParallel(cy.Axis().Direction(), Precision::Angular()))
{
FEIF.Set(ToPrism, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
thePFace.Add(FEIF.Edge(), fac);
}
}
}
}
}
if (borne == 7)
{
thePFace.Perform(Length);
}
else if (borne == 8)
{
thePFace.Perform(FUntil);
}
else if (borne == 9)
{
if (!(FFrom.IsNull() || FUntil.IsNull()))
{
thePFace.Perform(FFrom, FUntil);
}
else if (FFrom.IsNull())
{
if (!FUntil.IsNull())
{
thePFace.PerformFromEnd(FUntil);
}
else
{
thePFace.PerformThruAll();
}
}
else
{
// il faudrait inverser V et appeler PerfomFromEnd...
// std::cout << "Not Implemented" << std::endl;
theCommands << "Not Implemented\n";
}
}
if (!thePFace.IsDone())
{
theCommands << "Local operation not done";
return 1;
}
DBRep::Set(a[2], thePFace);
dout.Flush();
return 0;
}
//=================================================================================================
static Standard_Integer PRF(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 8)
return 1;
TopoDS_Shape S = DBRep::Get(a[3]);
BRepFeat_MakePrism thePFace;
Standard_Integer borne;
gp_Vec V;
TopoDS_Shape FFrom, FUntil;
Standard_Boolean fuse;
if (a[1][0] == 'f' || a[1][0] == 'F')
{
fuse = Standard_True;
}
else if (a[1][0] == 'c' || a[1][0] == 'C')
{
fuse = Standard_False;
}
else
{
return 1;
}
if (a[4][0] == '.' || IsAlphabetic(a[4][0]))
{
if (narg < 9)
{
return 1;
}
if (a[5][0] == '.' || IsAlphabetic(a[5][0]))
{
if (narg < 10)
{
return 1;
}
borne = 9;
V.SetCoord(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
FFrom = DBRep::Get(a[4], TopAbs_SHAPE);
FUntil = DBRep::Get(a[5], TopAbs_SHAPE);
}
else
{
borne = 8;
V.SetCoord(Draw::Atof(a[5]), Draw::Atof(a[6]), Draw::Atof(a[7]));
FUntil = DBRep::Get(a[4], TopAbs_SHAPE);
}
}
else
{
borne = 7;
V.SetCoord(Draw::Atof(a[4]), Draw::Atof(a[5]), Draw::Atof(a[6]));
}
Standard_Real Length = V.Magnitude();
if (Length < Precision::Confusion())
{
return 1;
}
TopoDS_Shape ToPrism;
if (narg == borne + 1)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[borne], TopAbs_FACE));
TopoDS_Face F = TopoDS::Face(aLocalShape);
// TopoDS_Face F = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
thePFace.Init(S, F, F, V, fuse, Standard_True);
ToPrism = F;
}
else
{
TopoDS_Shell She;
BRep_Builder B;
B.MakeShell(She);
for (Standard_Integer i = borne; i < narg; i++)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[i], TopAbs_FACE));
TopoDS_Face F = TopoDS::Face(aLocalShape);
// TopoDS_Face F = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
if (!F.IsNull())
{
B.Add(She, F);
}
}
She.Closed(BRep_Tool::IsClosed(She));
thePFace.Init(S, She, TopoDS_Face(), V, fuse, Standard_False);
ToPrism = She;
}
// Recherche des faces de glissement, on ne prisme pas une face
// du shape de depart
// for (TopExp_Explorer exp(ToPrism,TopAbs_FACE);exp.More();exp.Next()) {
TopExp_Explorer exp(ToPrism, TopAbs_FACE);
for (; exp.More(); exp.Next())
{
// for (TopExp_Explorer exp2(S,TopAbs_FACE);exp2.More();exp2.Next()) {
TopExp_Explorer exp2(S, TopAbs_FACE);
for (; exp2.More(); exp2.Next())
{
if (exp2.Current().IsSame(exp.Current()))
{
break;
}
}
if (exp2.More())
{
break;
}
}
if (!exp.More())
{
LocOpe_FindEdgesInFace FEIF;
for (exp.Init(S, TopAbs_FACE); exp.More(); exp.Next())
{
const TopoDS_Face& fac = TopoDS::Face(exp.Current());
Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
{
Su = Handle(Geom_RectangularTrimmedSurface)::DownCast(Su)->BasisSurface();
}
if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane))
{
gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
if (pl.Contains(gp_Lin(pl.Location(), V), Precision::Confusion(), Precision::Angular()))
{
FEIF.Set(ToPrism, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
thePFace.Add(FEIF.Edge(), fac);
}
}
}
else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface))
{
gp_Cylinder cy = Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
if (V.IsParallel(cy.Axis().Direction(), Precision::Angular()))
{
FEIF.Set(ToPrism, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
thePFace.Add(FEIF.Edge(), fac);
}
}
}
}
}
if (borne == 7)
{
thePFace.Perform(Length);
}
else if (borne == 8)
{
thePFace.Perform(FUntil);
}
else if (borne == 9)
{
if (!(FFrom.IsNull() || FUntil.IsNull()))
{
thePFace.Perform(FFrom, FUntil);
}
else if (FFrom.IsNull())
{
if (!FUntil.IsNull())
{
thePFace.PerformFromEnd(FUntil);
}
else
{
thePFace.PerformThruAll();
}
}
else
{ // FUntil.IsNull()
// il faudrait inverser V et appeler PerfomFromEnd...
// std::cout << "Not Implemented" << std::endl;
theCommands << "Not Implemented\n";
}
}
if (!thePFace.IsDone())
{
theCommands << "Local operation not done";
return 1;
}
DBRep::Set(a[2], thePFace);
dout.Flush();
return 0;
}
//=================================================================================================
static Standard_Integer SPLS(Draw_Interpretor&, Standard_Integer narg, const char** a)
{
Standard_Integer newnarg;
if (narg < 3)
{
Message::SendFail()
<< "Invalid number of arguments. Should be : splitshape result shape [splitedges] "
"[face wire/edge/compound [wire/edge/compound ...] "
"[face wire/edge/compound [wire/edge/compound...] ...] "
"[@ edgeonshape edgeonwire [edgeonshape edgeonwire...]]";
return 1;
}
TopoDS_Shape S = DBRep::Get(a[2]);
if (S.IsNull())
{
Message::SendFail() << "Invalid input shape " << a[2];
return 1;
}
BRepFeat_SplitShape Spls(S);
Standard_Boolean pick = Standard_False;
TopoDS_Shape EF;
Standard_Real u, v;
Standard_Integer i = 3;
for (newnarg = 3; newnarg < narg; newnarg++)
{
if (a[newnarg][0] == '@')
{
break;
}
}
if (newnarg == 3 || (newnarg != narg && ((narg - newnarg) <= 2 || (narg - newnarg) % 2 != 1)))
{
return 1;
}
Standard_Boolean isSplittingEdges = Standard_False;
TopTools_SequenceOfShape aSplitEdges;
if (i < newnarg)
{
pick = (a[i][0] == '.');
TopoDS_Shape aSh = DBRep::Get(a[i]);
if (aSh.IsNull())
{
Message::SendFail() << "Invalid input shape " << a[i];
return 1;
}
if (aSh.ShapeType() == TopAbs_FACE)
EF = TopoDS::Face(aSh);
else
{
if (aSh.ShapeType() == TopAbs_COMPOUND || aSh.ShapeType() == TopAbs_WIRE
|| aSh.ShapeType() == TopAbs_EDGE)
{
TopExp_Explorer aExpE(aSh, TopAbs_EDGE, TopAbs_FACE);
for (; aExpE.More(); aExpE.Next())
aSplitEdges.Append(aExpE.Current());
isSplittingEdges = !aSplitEdges.IsEmpty();
}
}
}
i++;
while (i < newnarg)
{
if (pick)
{
DBRep_DrawableShape::LastPick(EF, u, v);
}
if (!isSplittingEdges && !EF.IsNull() && EF.ShapeType() == TopAbs_FACE)
{
// face wire/edge ...
while (i < newnarg)
{
TopoDS_Shape W;
Standard_Boolean rever = Standard_False;
if (a[i][0] == '-')
{
if (a[i][1] == '\0')
return 1;
pick = (a[i][1] == '.');
const char* Temp = a[i] + 1;
W = DBRep::Get(Temp, TopAbs_SHAPE, Standard_False);
rever = Standard_True;
}
else
{
pick = (a[i][0] == '.');
W = DBRep::Get(a[i], TopAbs_SHAPE, Standard_False);
}
if (W.IsNull())
{
return 1; // on n`a rien recupere
}
TopAbs_ShapeEnum wtyp = W.ShapeType();
if (wtyp != TopAbs_WIRE && wtyp != TopAbs_EDGE && wtyp != TopAbs_COMPOUND && pick)
{
DBRep_DrawableShape::LastPick(W, u, v);
wtyp = W.ShapeType();
}
if (wtyp != TopAbs_WIRE && wtyp != TopAbs_EDGE && wtyp != TopAbs_COMPOUND)
{
EF = DBRep::Get(a[i]);
break;
}
else
{
if (rever)
{
W.Reverse();
}
if (wtyp == TopAbs_WIRE)
{
Spls.Add(TopoDS::Wire(W), TopoDS::Face(EF));
}
else if (wtyp == TopAbs_EDGE)
{
Spls.Add(TopoDS::Edge(W), TopoDS::Face(EF));
}
else
{
Spls.Add(TopoDS::Compound(W), TopoDS::Face(EF));
}
}
i++;
}
}
else
{
if (isSplittingEdges)
{
TopoDS_Shape aSh = DBRep::Get(a[i]);
if (aSh.IsNull())
{
Message::SendFail() << "Invalid input shape " << a[i];
return 1;
}
TopExp_Explorer aExpE(aSh, TopAbs_EDGE, TopAbs_FACE);
for (; aExpE.More(); aExpE.Next())
aSplitEdges.Append(aExpE.Current());
}
else
{
Message::SendFail()
<< "Invalid input arguments. Should be : splitshape result shape [splitedges] "
"[face wire/edge/compound [wire/edge/compound ...] "
"[face wire/edge/compound [wire/edge/compound...] ...] "
"[@ edgeonshape edgeonwire [edgeonshape edgeonwire...]]";
return 1;
}
}
i++;
}
if (isSplittingEdges)
Spls.Add(aSplitEdges);
// ici, i vaut newnarg
for (; i < narg; i += 2)
{
TopoDS_Shape Ew, Es;
TopoDS_Shape aLocalShape(DBRep::Get(a[i], TopAbs_EDGE));
Es = TopoDS::Edge(aLocalShape);
// Es = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
if (Es.IsNull())
{
return 1;
}
aLocalShape = DBRep::Get(a[i + 1], TopAbs_EDGE);
Ew = TopoDS::Edge(aLocalShape);
// Ew = TopoDS::Edge(DBRep::Get(a[i+1],TopAbs_EDGE));
if (Ew.IsNull())
{
Message::SendFail() << "Invalid input shape " << a[i + 1];
return 1;
}
Spls.Add(TopoDS::Edge(Ew), TopoDS::Edge(Es));
}
DBRep::Set(a[1], Spls);
return 0;
}
//=================================================================================================
Standard_Integer thickshell(Draw_Interpretor& theCommands, Standard_Integer n, const char** a)
{
if (n < 4)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
if (S.IsNull())
return 1;
Standard_Real Of = Draw::Atof(a[3]);
GeomAbs_JoinType JT = GeomAbs_Arc;
if (n > 4)
{
if (!strcmp(a[4], "i"))
JT = GeomAbs_Intersection;
if (!strcmp(a[4], "t"))
JT = GeomAbs_Tangent;
}
Standard_Boolean Inter = Standard_False; // Standard_True;
Standard_Real Tol = Precision::Confusion();
if (n > 5)
Tol = Draw::Atof(a[5]);
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(theCommands, 1);
BRepOffset_MakeOffset B;
B.Initialize(S, Of, Tol, BRepOffset_Skin, Inter, 0, JT, Standard_True);
B.MakeOffsetShape(aProgress->Start());
const BRepOffset_Error aRetCode = B.Error();
reportOffsetState(theCommands, aRetCode);
if (!B.Shape().IsNull())
{
DBRep::Set(a[1], B.Shape());
}
return 0;
}
//=================================================================================================
static Standard_Integer mkoffsetshape(Draw_Interpretor& theDI,
Standard_Integer theArgNb,
const char** theArgVec)
{
if (theArgNb < 4)
{
return 0;
}
TopoDS_Shape aShape = DBRep::Get(theArgVec[2]);
if (aShape.IsNull())
{
theDI << "Shape is null";
return 1;
}
Standard_Real anOffVal = Draw::Atof(theArgVec[3]);
BRepOffsetAPI_MakeOffsetShape aMaker;
if (theArgNb == 4)
{
aMaker.PerformBySimple(aShape, anOffVal);
}
else
{
Standard_Real aTol = Draw::Atof(theArgVec[4]);
Standard_Boolean anInt = Standard_False;
if (theArgNb > 5)
{
if ((Draw::Atof(theArgVec[5]) == 1))
{
anInt = Standard_True;
}
}
Standard_Boolean aSelfInt = Standard_False;
if (theArgNb > 6)
{
if (Draw::Atof(theArgVec[6]) == 1)
{
aSelfInt = Standard_True;
}
}
GeomAbs_JoinType aJoin = GeomAbs_Arc;
if (theArgNb > 7)
{
if (!strcmp(theArgVec[7], "i"))
{
aJoin = GeomAbs_Intersection;
}
}
Standard_Boolean aRemIntEdges = Standard_False;
if (theArgNb > 8)
{
if (Draw::Atof(theArgVec[8]) == 1)
{
aRemIntEdges = Standard_True;
}
}
aMaker
.PerformByJoin(aShape, anOffVal, aTol, BRepOffset_Skin, anInt, aSelfInt, aJoin, aRemIntEdges);
}
if (!aMaker.IsDone())
{
theDI << " Error: Offset is not done.\n";
return 1;
}
DBRep::Set(theArgVec[1], aMaker.Shape());
return 0;
}
//=================================================================================================
Standard_Integer offsetshape(Draw_Interpretor& theCommands, Standard_Integer n, const char** a)
{
if (n < 4)
return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
if (S.IsNull())
return 1;
Standard_Real Of = Draw::Atof(a[3]);
Standard_Boolean Inter = (!strcmp(a[0], "offsetcompshape"));
GeomAbs_JoinType JT = GeomAbs_Arc;
if (!strcmp(a[0], "offsetinter"))
{
JT = GeomAbs_Intersection;
Inter = Standard_True;
}
BRepOffset_MakeOffset B;
Standard_Integer IB = 4;
Standard_Real Tol = Precision::Confusion();
if (n > 4)
{
TopoDS_Shape SF = DBRep::Get(a[4], TopAbs_FACE);
if (SF.IsNull())
{
IB = 5;
Tol = Draw::Atof(a[4]);
}
}
B.Initialize(S, Of, Tol, BRepOffset_Skin, Inter, 0, JT);
//------------------------------------------
// recuperation et chargement des bouchons.
//----------------------------------------
Standard_Boolean YaBouchon = Standard_False;
for (Standard_Integer i = IB; i < n; i++)
{
TopoDS_Shape SF = DBRep::Get(a[i], TopAbs_FACE);
if (!SF.IsNull())
{
YaBouchon = Standard_True;
B.AddFace(TopoDS::Face(SF));
}
}
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(theCommands, 1);
if (!YaBouchon)
B.MakeOffsetShape(aProgress->Start());
else
B.MakeThickSolid(aProgress->Start());
const BRepOffset_Error aRetCode = B.Error();
reportOffsetState(theCommands, aRetCode);
if (!B.Shape().IsNull())
{
DBRep::Set(a[1], B.Shape());
}
return 0;
}
static BRepOffset_MakeOffset TheOffset;
static Standard_Real TheRadius;
static Standard_Boolean theYaBouchon;
static Standard_Real TheTolerance = Precision::Confusion();
static Standard_Boolean TheInter = Standard_False;
static GeomAbs_JoinType TheJoin = GeomAbs_Arc;
static Standard_Boolean RemoveIntEdges = Standard_False;
Standard_Integer offsetparameter(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
if (n == 1)
{
di << " offsetparameter Tol Inter(c/p) JoinType(a/i/t) [RemoveInternalEdges(r/k)]\n";
di << " Current Values\n";
di << " --> Tolerance : " << TheTolerance << "\n";
di << " --> TheInter : ";
if (TheInter)
{
di << "Complete";
}
else
{
di << "Partial";
}
di << "\n --> TheJoin : ";
switch (TheJoin)
{
case GeomAbs_Arc:
di << "Arc";
break;
case GeomAbs_Intersection:
di << "Intersection";
break;
default:
break;
}
//
di << "\n --> Internal Edges : ";
if (RemoveIntEdges)
{
di << "Remove";
}
else
{
di << "Keep";
}
di << "\n";
//
return 0;
}
if (n < 4)
return 1;
//
TheTolerance = Draw::Atof(a[1]);
TheInter = strcmp(a[2], "p") != 0;
//
if (!strcmp(a[3], "a"))
TheJoin = GeomAbs_Arc;
else if (!strcmp(a[3], "i"))
TheJoin = GeomAbs_Intersection;
else if (!strcmp(a[3], "t"))
TheJoin = GeomAbs_Tangent;
//
RemoveIntEdges = (n >= 5) ? !strcmp(a[4], "r") : Standard_False;
//
return 0;
}
//=================================================================================================
Standard_Integer offsetload(Draw_Interpretor&, Standard_Integer n, const char** a)
{
if (n < 2)
return 1;
TopoDS_Shape S = DBRep::Get(a[1]);
if (S.IsNull())
return 1;
Standard_Real Of = Draw::Atof(a[2]);
TheRadius = Of;
// Standard_Boolean Inter = Standard_True;
TheOffset.Initialize(S,
Of,
TheTolerance,
BRepOffset_Skin,
TheInter,
0,
TheJoin,
Standard_False,
RemoveIntEdges);
//------------------------------------------
// recuperation et chargement des bouchons.
//----------------------------------------
for (Standard_Integer i = 3; i < n; i++)
{
TopoDS_Shape SF = DBRep::Get(a[i], TopAbs_FACE);
if (!SF.IsNull())
{
TheOffset.AddFace(TopoDS::Face(SF));
}
}
if (n < 4)
theYaBouchon = Standard_False; // B.MakeOffsetShape();
else
theYaBouchon = Standard_True; // B.MakeThickSolid ();
return 0;
}
//=================================================================================================
Standard_Integer offsetonface(Draw_Interpretor&, Standard_Integer n, const char** a)
{
if (n < 3)
return 1;
for (Standard_Integer i = 1; i < n; i += 2)
{
TopoDS_Shape SF = DBRep::Get(a[i], TopAbs_FACE);
if (!SF.IsNull())
{
Standard_Real Of = Draw::Atof(a[i + 1]);
TheOffset.SetOffsetOnFace(TopoDS::Face(SF), Of);
}
}
return 0;
}
//=================================================================================================
Standard_Integer offsetperform(Draw_Interpretor& theCommands,
Standard_Integer theNArg,
const char** a)
{
if (theNArg < 2)
return 1;
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(theCommands, 1);
if (theYaBouchon)
TheOffset.MakeThickSolid(aProgress->Start());
else
TheOffset.MakeOffsetShape(aProgress->Start());
if (TheOffset.IsDone())
{
DBRep::Set(a[1], TheOffset.Shape());
}
else
{
const BRepOffset_Error aRetCode = TheOffset.Error();
reportOffsetState(theCommands, aRetCode);
}
// Store the history of Boolean operation into the session
if (BRepTest_Objects::IsHistoryNeeded())
{
TopTools_ListOfShape aLA;
aLA.Append(TheOffset.InitShape());
BRepTest_Objects::SetHistory<BRepOffset_MakeOffset>(aLA, TheOffset);
}
return 0;
}
//=================================================================================================
static Standard_Integer ROW(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 13)
return 1;
TopoDS_Shape S = DBRep::Get(a[3]);
BRepFeat_MakeRevol theRFace;
gp_Dir D;
gp_Pnt Or;
Standard_Real Angle = 0;
TopoDS_Shape FFrom, FUntil;
Standard_Integer i, borne;
Standard_Boolean fuse;
if (a[1][0] == 'f' || a[1][0] == 'F')
{
fuse = Standard_True;
}
else if (a[1][0] == 'c' || a[1][0] == 'C')
{
fuse = Standard_False;
}
else
{
return 1;
}
FFrom = DBRep::Get(a[4], TopAbs_SHAPE);
if (FFrom.IsNull())
{
Angle = Draw::Atof(a[4]);
Angle *= M_PI / 180.;
i = 5;
}
else
{
FUntil = DBRep::Get(a[5], TopAbs_SHAPE);
if (FUntil.IsNull())
{
i = 5;
FUntil = FFrom;
FFrom.Nullify();
}
else
{
if (narg < 14)
{
return 1;
}
i = 6;
}
}
borne = i + 6;
Or.SetCoord(Draw::Atof(a[i]), Draw::Atof(a[i + 1]), Draw::Atof(a[i + 2]));
D.SetCoord(Draw::Atof(a[i + 3]), Draw::Atof(a[i + 4]), Draw::Atof(a[i + 5]));
gp_Ax1 theAxis(Or, D);
TopoDS_Shape aLocalShape(DBRep::Get(a[borne], TopAbs_FACE));
TopoDS_Face F = TopoDS::Face(aLocalShape);
// TopoDS_Face F = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
BRepFeat_SplitShape Spls(F);
for (i = borne + 1; i < narg; i++)
{
TopoDS_Wire wir;
if (a[i][0] != '-')
{
aLocalShape = DBRep::Get(a[i], TopAbs_WIRE);
wir = TopoDS::Wire(aLocalShape);
// wir = TopoDS::Wire(DBRep::Get(a[i],TopAbs_WIRE));
}
else
{
if (a[i][1] == '\0')
return 1;
const char* Temp = a[i] + 1;
aLocalShape = DBRep::Get(Temp, TopAbs_WIRE);
wir = TopoDS::Wire(aLocalShape);
// wir = TopoDS::Wire(DBRep::Get(Temp,TopAbs_WIRE));
wir.Reverse();
}
Spls.Add(wir, F);
}
Spls.Build();
TopoDS_Shape ToRotate;
const TopTools_ListOfShape& lleft = Spls.DirectLeft();
if (lleft.Extent() == 1)
{
theRFace.Init(S, lleft.First(), F, theAxis, fuse, Standard_True);
ToRotate = lleft.First();
}
else
{
BRep_Builder B;
TopoDS_Shell Sh;
B.MakeShell(Sh);
TopTools_ListIteratorOfListOfShape it;
for (it.Initialize(lleft); it.More(); it.Next())
{
B.Add(Sh, TopoDS::Face(it.Value()));
}
Sh.Closed(BRep_Tool::IsClosed(Sh));
theRFace.Init(S, Sh, F, theAxis, fuse, Standard_True);
ToRotate = Sh;
}
// Recherche des faces de glissement
// for (TopExp_Explorer exp(S,TopAbs_FACE);exp.More();exp.Next()) {
TopExp_Explorer exp(S, TopAbs_FACE);
for (; exp.More(); exp.Next())
{
if (exp.Current().IsSame(F))
{
break;
}
}
if (!exp.More())
{
LocOpe_FindEdgesInFace FEIF;
for (exp.Init(S, TopAbs_FACE); exp.More(); exp.Next())
{
const TopoDS_Face& fac = TopoDS::Face(exp.Current());
Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
{
Su = Handle(Geom_RectangularTrimmedSurface)::DownCast(Su)->BasisSurface();
}
if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane))
{
gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
if (pl.Axis().IsParallel(theAxis, Precision::Angular()))
{
FEIF.Set(ToRotate, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
theRFace.Add(FEIF.Edge(), fac);
}
}
}
else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface))
{
gp_Cylinder cy = Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
if (cy.Axis().IsCoaxial(theAxis, Precision::Angular(), Precision::Confusion()))
{
FEIF.Set(ToRotate, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
theRFace.Add(FEIF.Edge(), fac);
}
}
}
}
}
if (borne == 11)
{
if (FUntil.IsNull())
{
theRFace.Perform(Angle);
}
else
{
theRFace.Perform(FUntil);
}
}
else
{ // borne == 12
theRFace.Perform(FFrom, FUntil);
}
if (!theRFace.IsDone())
{
theCommands << "Local operation not done";
return 1;
}
DBRep::Set(a[2], theRFace);
dout.Flush();
return 0;
}
//=================================================================================================
static Standard_Integer ROF(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 12)
return 1;
TopoDS_Shape S = DBRep::Get(a[3]);
BRepFeat_MakeRevol theRFace;
gp_Dir D;
gp_Pnt Or;
Standard_Real Angle = 0;
TopoDS_Shape FFrom, FUntil;
Standard_Integer i, borne;
Standard_Boolean fuse;
if (a[1][0] == 'f' || a[1][0] == 'F')
{
fuse = Standard_True;
}
else if (a[1][0] == 'c' || a[1][0] == 'C')
{
fuse = Standard_False;
}
else
{
return 1;
}
FFrom = DBRep::Get(a[4], TopAbs_SHAPE);
if (FFrom.IsNull())
{
Angle = Draw::Atof(a[4]);
Angle *= M_PI / 180.;
i = 5;
}
else
{
FUntil = DBRep::Get(a[5], TopAbs_SHAPE);
if (FUntil.IsNull())
{
i = 5;
FUntil = FFrom;
FFrom.Nullify();
}
else
{
if (narg < 13)
{
return 1;
}
i = 6;
}
}
borne = i + 6;
Or.SetCoord(Draw::Atof(a[i]), Draw::Atof(a[i + 1]), Draw::Atof(a[i + 2]));
D.SetCoord(Draw::Atof(a[i + 3]), Draw::Atof(a[i + 4]), Draw::Atof(a[i + 5]));
gp_Ax1 theAxis(Or, D);
TopoDS_Shape ToRotate;
if (narg == borne + 1)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[borne], TopAbs_FACE));
TopoDS_Face F = TopoDS::Face(aLocalShape);
// TopoDS_Face F = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
theRFace.Init(S, F, F, theAxis, fuse, Standard_True);
ToRotate = F;
}
else
{
TopoDS_Shell She;
BRep_Builder B;
B.MakeShell(She);
for (i = borne; i < narg; i++)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[i], TopAbs_FACE));
TopoDS_Face F = TopoDS::Face(aLocalShape);
// TopoDS_Face F = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
if (!F.IsNull())
{
B.Add(She, F);
}
}
She.Closed(BRep_Tool::IsClosed(She));
theRFace.Init(S, She, TopoDS_Face(), theAxis, fuse, Standard_False);
ToRotate = She;
}
// for (TopExp_Explorer exp(ToRotate,TopAbs_FACE);exp.More();exp.Next()) {
TopExp_Explorer exp(ToRotate, TopAbs_FACE);
for (; exp.More(); exp.Next())
{
// for (TopExp_Explorer exp2(S,TopAbs_FACE);exp2.More();exp2.Next()) {
TopExp_Explorer exp2(S, TopAbs_FACE);
for (; exp2.More(); exp2.Next())
{
if (exp2.Current().IsSame(exp.Current()))
{
break;
}
}
if (exp2.More())
{
break;
}
}
if (!exp.More())
{
LocOpe_FindEdgesInFace FEIF;
for (exp.Init(S, TopAbs_FACE); exp.More(); exp.Next())
{
const TopoDS_Face& fac = TopoDS::Face(exp.Current());
Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
{
Su = Handle(Geom_RectangularTrimmedSurface)::DownCast(Su)->BasisSurface();
}
if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane))
{
gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
if (pl.Axis().IsParallel(theAxis, Precision::Angular()))
{
FEIF.Set(ToRotate, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
theRFace.Add(FEIF.Edge(), fac);
}
}
}
else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface))
{
gp_Cylinder cy = Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
if (cy.Axis().IsCoaxial(theAxis, Precision::Angular(), Precision::Confusion()))
{
FEIF.Set(ToRotate, fac);
for (FEIF.Init(); FEIF.More(); FEIF.Next())
{
theRFace.Add(FEIF.Edge(), fac);
}
}
}
}
}
if (borne == 11)
{
if (FUntil.IsNull())
{
theRFace.Perform(Angle);
}
else
{
theRFace.Perform(FUntil);
}
}
else
{ // borne == 12
theRFace.Perform(FFrom, FUntil);
}
if (!theRFace.IsDone())
{
theCommands << "Local operation not done";
return 1;
}
DBRep::Set(a[2], theRFace);
dout.Flush();
return 0;
}
//=======================================================================
// function : GLU
// purpose : Commande glue
//=======================================================================
static Standard_Integer GLU(Draw_Interpretor&, Standard_Integer narg, const char** a)
{
if (narg < 6 || narg % 2 != 0)
return 1;
TopoDS_Shape Sne = DBRep::Get(a[2]);
TopoDS_Shape Sba = DBRep::Get(a[3]);
Standard_Boolean pick;
BRepFeat_Gluer theGl(Sne, Sba);
TopoDS_Shape Fne, Fba;
LocOpe_FindEdges fined;
Standard_Integer i = 4;
Standard_Boolean first = Standard_True;
while (i < narg)
{
pick = (a[i][0] == '.');
Fne = DBRep::Get(a[i]);
if (Fne.IsNull())
{
return 1;
}
TopAbs_ShapeEnum sht = Fne.ShapeType();
if (pick && sht != TopAbs_FACE && sht != TopAbs_EDGE)
{
Standard_Real u, v;
DBRep_DrawableShape::LastPick(Fne, u, v);
sht = Fne.ShapeType();
}
if (first && sht != TopAbs_FACE)
{
return 1;
}
first = Standard_False;
pick = (a[i + 1][0] == '.');
Fba = DBRep::Get(a[i + 1]);
if (Fba.IsNull())
{
return 1;
}
if (pick && Fba.ShapeType() != sht)
{
Standard_Real u, v;
DBRep_DrawableShape::LastPick(Fba, u, v);
}
if (Fba.ShapeType() != sht)
{
return 1;
}
if (sht == TopAbs_FACE)
{
const TopoDS_Face& f1 = TopoDS::Face(Fne);
const TopoDS_Face& f2 = TopoDS::Face(Fba);
theGl.Bind(f1, f2);
fined.Set(Fne, Fba);
for (fined.InitIterator(); fined.More(); fined.Next())
{
theGl.Bind(fined.EdgeFrom(), fined.EdgeTo());
}
}
else
{
theGl.Bind(TopoDS::Edge(Fne), TopoDS::Edge(Fba));
}
i += 2;
}
DBRep::Set(a[1], theGl);
dout.Flush();
return 0;
}
static Standard_Integer DEFIN(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (strcasecmp(a[0], "FEATPRISM") && strcasecmp(a[0], "FEATDPRISM")
&& strcasecmp(a[0], "FEATREVOL") && strcasecmp(a[0], "FEATPIPE") && strcasecmp(a[0], "FEATLF")
&& strcasecmp(a[0], "FEATRF"))
{
return 1;
}
if ((!strcasecmp(a[0], "FEATPRISM") && narg != 9)
|| (!strcasecmp(a[0], "FEATREVOL") && narg != 12)
|| (!strcasecmp(a[0], "FEATDPRISM") && narg != 7)
|| (!strcasecmp(a[0], "FEATPIPE") && narg != 7) || (!strcasecmp(a[0], "FEATLF") && narg != 12)
|| (!strcasecmp(a[0], "FEATRF") && narg != 14))
{
theCommands << "invalid number of arguments";
return 1;
}
TopoDS_Shape Sbase = DBRep::Get(a[1]);
if (Sbase.IsNull())
{
theCommands << "null basis shape";
return 1;
}
Standard_Integer Ifuse = Draw::Atoi(a[narg - 2]);
Standard_Integer Imodif = Draw::Atoi(a[narg - 1]);
Standard_Integer Fuse = Ifuse;
Standard_Boolean Modify = (Imodif != 0);
TopoDS_Shape Pbase;
TopoDS_Face Skface;
TopoDS_Wire W;
Handle(Geom_Plane) P;
BRepFeat_StatusError se;
if (strcasecmp(a[0], "FEATLF") && strcasecmp(a[0], "FEATRF"))
{
Pbase = DBRep::Get(a[2]);
if (Pbase.IsNull())
{
theCommands << "null shape to transform";
return 1;
}
TopoDS_Shape aLocalShape(DBRep::Get(a[3], TopAbs_FACE));
Skface = TopoDS::Face(aLocalShape);
// Skface = TopoDS::Face(DBRep::Get(a[3],TopAbs_FACE));
if (Skface.IsNull())
{
theCommands << "null face of Sketch";
return 1;
}
}
else
{
TopoDS_Shape aLocalShape(DBRep::Get(a[2], TopAbs_WIRE));
W = TopoDS::Wire(aLocalShape);
// W = TopoDS::Wire(DBRep::Get(a[2], TopAbs_WIRE));
if (W.IsNull())
{
theCommands << "null profile for rib or slot";
return 1;
}
Handle(Geom_Surface) s = DrawTrSurf::GetSurface(a[3]);
P = Handle(Geom_Plane)::DownCast(s);
if (P.IsNull())
{
theCommands << "null plane to transform";
return 1;
}
}
if (narg == 9 || narg == 12 || narg == 14)
{
// Standard_Real X,Y,Z,X1,Y1,Z1;
Standard_Real X, Y, Z;
X = Draw::Atof(a[4]);
Y = Draw::Atof(a[5]);
Z = Draw::Atof(a[6]);
if (narg == 9)
{ // prism
prdef = Standard_True;
theSbase = Sbase;
thePbase = Pbase;
theSkface = Skface;
getPrism().Init(Sbase, Pbase, Skface, gp_Dir(X, Y, Z), Fuse, Modify);
}
else if (narg == 14)
{
rfdef = Standard_True;
gp_Pnt Or(X, Y, Z);
X = Draw::Atof(a[7]);
Y = Draw::Atof(a[8]);
Z = Draw::Atof(a[9]);
Standard_Real H1 = Draw::Atof(a[10]);
Standard_Real H2 = Draw::Atof(a[11]);
gp_Ax1 ax1(Or, gp_Dir(X, Y, Z));
getRevolutionForm().Init(Sbase, W, P, ax1, H1, H2, Fuse, Modify);
if (!getRevolutionForm().IsDone())
{
se = getRevolutionForm().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
}
else if (narg == 12 && strcasecmp(a[0], "FEATLF"))
{
rvdef = Standard_True;
gp_Pnt Or(X, Y, Z);
X = Draw::Atof(a[7]);
Y = Draw::Atof(a[8]);
Z = Draw::Atof(a[9]);
theSbase = Sbase;
thePbase = Pbase;
theSkface = Skface;
getRevol().Init(Sbase, Pbase, Skface, gp_Ax1(Or, gp_Dir(X, Y, Z)), Fuse, Modify);
}
else
{
lfdef = Standard_True;
gp_Vec Direct(X, Y, Z);
X = Draw::Atof(a[7]);
Y = Draw::Atof(a[8]);
Z = Draw::Atof(a[9]);
getLienarForm().Init(Sbase, W, P, Direct, gp_Vec(X, Y, Z), Fuse, Modify);
if (!getLienarForm().IsDone())
{
se = getLienarForm().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
}
}
else if (narg == 7)
{
if (!strcasecmp(a[0], "FEATDPRISM"))
{
if (Pbase.ShapeType() != TopAbs_FACE)
{
theCommands << "Invalid DPrism base";
return 1;
}
Standard_Real Angle = Draw::Atof(a[4]) * M_PI / 360;
dprdef = Standard_True;
theSbase = Sbase;
thePbase = Pbase;
theSkface = Skface;
getDPrism().Init(Sbase, TopoDS::Face(Pbase), Skface, Angle, Fuse, Modify);
}
else
{ // FEATPIPE
TopoDS_Shape aLocalShape(DBRep::Get(a[4], TopAbs_WIRE));
TopoDS_Wire Spine = TopoDS::Wire(aLocalShape);
// TopoDS_Wire Spine = TopoDS::Wire(DBRep::Get(a[4],TopAbs_WIRE));
if (Spine.IsNull())
{
TopoDS_Shape Edspine = DBRep::Get(a[4], TopAbs_EDGE);
if (Edspine.IsNull())
{
theCommands << "null spine";
return 1;
}
BRep_Builder B;
B.MakeWire(Spine);
B.Add(Spine, Edspine);
}
pidef = Standard_True;
theSbase = Sbase;
thePbase = Pbase;
theSkface = Skface;
getPipe().Init(Sbase, Pbase, Skface, Spine, Fuse, Modify);
}
}
return 0;
}
static Standard_Integer ADD(Draw_Interpretor&, Standard_Integer narg, const char** a)
{
Standard_Integer i;
if (narg < 4 || narg % 2 != 0)
{
return 1;
}
if (!strcasecmp("PRISM", a[1]))
{
if (!prdef)
{
return 1;
}
for (i = 2; i < narg; i += 2)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[i], TopAbs_EDGE));
TopoDS_Edge edg = TopoDS::Edge(aLocalShape);
// TopoDS_Edge edg = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
if (edg.IsNull())
{
return 1;
}
aLocalShape = DBRep::Get(a[i + 1], TopAbs_FACE);
TopoDS_Face fac = TopoDS::Face(aLocalShape);
// TopoDS_Face fac = TopoDS::Face(DBRep::Get(a[i+1],TopAbs_FACE));
if (fac.IsNull())
{
return 1;
}
getPrism().Add(edg, fac);
}
}
else if (!strcasecmp("REVOL", a[1]))
{
if (!rvdef)
{
return 1;
}
for (i = 2; i < narg; i += 2)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[i], TopAbs_EDGE));
TopoDS_Edge edg = TopoDS::Edge(aLocalShape);
// TopoDS_Edge edg = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
if (edg.IsNull())
{
return 1;
}
aLocalShape = DBRep::Get(a[i + 1], TopAbs_FACE);
TopoDS_Face fac = TopoDS::Face(aLocalShape);
// TopoDS_Face fac = TopoDS::Face(DBRep::Get(a[i+1],TopAbs_FACE));
if (fac.IsNull())
{
return 1;
}
getRevol().Add(edg, fac);
}
}
else if (!strcasecmp("PIPE", a[1]))
{
if (!pidef)
{
return 1;
}
for (i = 2; i < narg; i += 2)
{
TopoDS_Shape aLocalShape(DBRep::Get(a[i], TopAbs_EDGE));
TopoDS_Edge edg = TopoDS::Edge(aLocalShape);
// TopoDS_Edge edg = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
if (edg.IsNull())
{
return 1;
}
aLocalShape = DBRep::Get(a[i + 1], TopAbs_FACE);
TopoDS_Face fac = TopoDS::Face(aLocalShape);
// TopoDS_Face fac = TopoDS::Face(DBRep::Get(a[i+1],TopAbs_FACE));
if (fac.IsNull())
{
return 1;
}
getPipe().Add(edg, fac);
}
}
else
{
return 1;
}
return 0;
}
static Standard_Integer PERF(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (narg < 3)
{
return 1;
}
if (strcasecmp(a[0], "FEATPERFORM") && strcasecmp(a[0], "FEATPERFORMVAL"))
{
return 1;
}
TopTools_ListOfShape anArgs;
Standard_Integer Kas;
if (!strcasecmp("PRISM", a[1]))
{
Kas = 1;
if (!prdef)
{
theCommands << "prism not defined";
return 1;
}
}
else if (!strcasecmp("REVOL", a[1]))
{
Kas = 2;
if (!rvdef)
{
theCommands << "revol not defined";
return 1;
}
}
else if (!strcasecmp("PIPE", a[1]))
{
Kas = 3;
if (!pidef)
{
theCommands << "pipe not defined";
return 1;
}
if (!strcasecmp(a[0], "FEATPERFORMVAL"))
{
theCommands << "invalid command for pipe";
return 1;
}
}
else if (!strcasecmp("DPRISM", a[1]))
{
Kas = 4;
if (!dprdef)
{
theCommands << "dprism not defined";
return 1;
}
}
else if (!strcasecmp("LF", a[1]))
{
Kas = 5;
if (!lfdef)
{
theCommands << "lf not defined";
return 1;
}
if (!strcasecmp(a[0], "FEATPERFORMVAL"))
{
theCommands << "invalid command for lf";
return 1;
}
}
else if (!strcasecmp("RF", a[1]))
{
Kas = 6;
if (!rfdef)
{
theCommands << "rf not defined";
return 1;
}
if (!strcasecmp(a[0], "FEATPERFORMVAL"))
{
theCommands << "invalid command for rf";
return 1;
}
}
else
{
theCommands << "unknown argument : " << a[1];
return 1;
}
if (!strcasecmp(a[0], "FEATPERFORMVAL"))
{
if (narg != 4 && narg != 5)
{
theCommands << "invalid number of arguments";
return 1;
}
if (narg == 4)
{
Standard_Real Val = Draw::Atof(a[3]);
if (Kas == 1)
{
getPrism().Perform(Val);
}
else if (Kas == 2)
{
Val *= (M_PI / 180.);
getRevol().Perform(Val);
}
else if (Kas == 4)
{
getDPrism().Perform(Val);
}
else if (Kas == 5)
{
theCommands << "invalid command for lf";
return 1;
}
else if (Kas == 6)
{
theCommands << "invalid command for rf";
return 1;
}
}
else if (narg == 5)
{
Standard_Real Val = Draw::Atof(a[3]);
TopoDS_Shape FUntil = DBRep::Get(a[4], TopAbs_SHAPE);
if (Kas == 1)
{
getPrism().PerformUntilHeight(FUntil, Val);
}
else if (Kas == 2)
{
Val *= (M_PI / 180.);
getRevol().PerformUntilAngle(FUntil, Val);
}
else if (Kas == 4)
{
getDPrism().PerformUntilHeight(FUntil, Val);
}
else
{
theCommands << "invalid command for ribs or slots";
return 1;
}
}
}
else if (!strcasecmp(a[0], "FEATPERFORM"))
{
if (narg == 3)
{ // Thru all
switch (Kas)
{
case 1:
getPrism().PerformThruAll();
break;
case 2:
getRevol().PerformThruAll();
break;
case 3:
getPipe().Perform();
break;
case 4:
getDPrism().PerformThruAll();
break;
case 5:
getLienarForm().Perform();
break;
case 6:
getRevolutionForm().Perform();
break;
default:
return 1;
}
}
else if (narg == 4)
{ // Until
TopoDS_Shape Funtil = DBRep::Get(a[3], TopAbs_SHAPE);
switch (Kas)
{
case 1: {
if (Funtil.IsNull())
{
getPrism().PerformUntilEnd();
}
else
{
getPrism().Perform(Funtil);
}
}
break;
case 2: {
if (!Funtil.IsNull())
{
getRevol().Perform(Funtil);
}
else
{
return 1;
}
}
break;
case 3: {
if (!Funtil.IsNull())
{
getPipe().Perform(Funtil);
}
else
{
theCommands << "invalid command for ribs pipe";
return 1;
}
}
break;
case 4: {
if (!Funtil.IsNull())
{
getDPrism().Perform(Funtil);
}
else
{
getDPrism().PerformUntilEnd();
}
}
break;
case 5: {
theCommands << "invalid command for lf";
return 1;
}
break;
case 6: {
theCommands << "invalid command for rf";
return 1;
}
break;
default:
return 1;
}
}
else if (narg == 5)
{
TopoDS_Shape Ffrom = DBRep::Get(a[3], TopAbs_SHAPE);
TopoDS_Shape Funtil = DBRep::Get(a[4], TopAbs_SHAPE);
if (Funtil.IsNull())
{
return 1;
}
switch (Kas)
{
case 1: {
if (Ffrom.IsNull())
{
getPrism().PerformFromEnd(Funtil);
}
else
{
getPrism().Perform(Ffrom, Funtil);
}
}
break;
case 2: {
if (Ffrom.IsNull())
{
return 1;
}
getRevol().Perform(Ffrom, Funtil);
}
break;
case 3: {
if (Ffrom.IsNull())
{
return 1;
}
getPipe().Perform(Ffrom, Funtil);
}
break;
case 4: {
if (Ffrom.IsNull())
{
getDPrism().PerformFromEnd(Funtil);
}
else
{
getDPrism().Perform(Ffrom, Funtil);
}
}
break;
default:
return 1;
}
}
}
BRepFeat_StatusError se;
switch (Kas)
{
case 1:
if (!getPrism().IsDone())
{
se = getPrism().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
DBRep::Set(a[2], getPrism());
dout.Flush();
// History
if (BRepTest_Objects::IsHistoryNeeded())
{
anArgs.Clear();
anArgs.Append(theSbase);
anArgs.Append(thePbase);
anArgs.Append(theSkface);
BRepTest_Objects::SetHistory(anArgs, getPrism());
}
return 0;
case 2:
if (!getRevol().IsDone())
{
se = getRevol().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
// History
if (BRepTest_Objects::IsHistoryNeeded())
{
anArgs.Clear();
anArgs.Append(theSbase);
anArgs.Append(thePbase);
anArgs.Append(theSkface);
BRepTest_Objects::SetHistory(anArgs, getRevol());
}
DBRep::Set(a[2], getRevol());
dout.Flush();
return 0;
case 3:
if (!getPipe().IsDone())
{
se = getPipe().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
// History
if (BRepTest_Objects::IsHistoryNeeded())
{
anArgs.Clear();
anArgs.Append(theSbase);
anArgs.Append(thePbase);
anArgs.Append(theSkface);
BRepTest_Objects::SetHistory(anArgs, getPipe());
}
DBRep::Set(a[2], getPipe());
dout.Flush();
return 0;
case 4:
if (!getDPrism().IsDone())
{
se = getDPrism().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
// History
if (BRepTest_Objects::IsHistoryNeeded())
{
anArgs.Clear();
anArgs.Append(theSbase);
anArgs.Append(thePbase);
anArgs.Append(theSkface);
BRepTest_Objects::SetHistory(anArgs, getDPrism());
}
DBRep::Set(a[2], getDPrism());
dout.Flush();
return 0;
case 5:
if (!getLienarForm().IsDone())
{
se = getLienarForm().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
DBRep::Set(a[2], getLienarForm());
dout.Flush();
return 0;
case 6:
if (!getRevolutionForm().IsDone())
{
se = getRevolutionForm().CurrentStatusError();
// BRepFeat::Print(se,std::cout) << std::endl;
Standard_SStream aSStream;
BRepFeat::Print(se, aSStream);
theCommands << aSStream << "\n";
return 1;
}
DBRep::Set(a[2], getRevolutionForm());
dout.Flush();
return 0;
default:
return 1;
}
}
static Standard_Integer BOSS(Draw_Interpretor& theCommands, Standard_Integer narg, const char** a)
{
if (strcasecmp(a[0], "ENDEDGES") && strcasecmp(a[0], "FILLET") && strcasecmp(a[0], "BOSSAGE"))
{
return 1;
}
if ((!strcasecmp(a[0], "ENDEDGES") && narg != 5)
|| (!strcasecmp(a[0], "FILLET") && (narg < 5 || narg % 2 != 1))
|| (!strcasecmp(a[0], "BOSSAGE") && narg != 6))
{
theCommands.PrintHelp(a[0]);
return 1;
}
Standard_Integer Kas = 0;
Standard_Integer dprsig = 0;
if (!strcasecmp("ENDEDGES", a[0]))
{
Kas = 1;
dprsig = Draw::Atoi(a[4]);
}
else if (!strcasecmp("FILLET", a[0]))
{
Kas = 2;
}
else if (!strcasecmp("BOSSAGE", a[0]))
{
Kas = 3;
dprsig = Draw::Atoi(a[5]);
}
TopoDS_Shape theShapeTop;
TopoDS_Shape theShapeBottom;
if (Kas == 1 || Kas == 3)
{
if (!strcasecmp("DPRISM", a[1]))
{
if (!dprdef)
{
theCommands << "dprism not defined";
return 1;
}
}
else
{
theCommands << "unknown argument : " << a[1];
return 1;
}
getDPrism().BossEdges(dprsig);
TopTools_ListOfShape theTopEdges, theLatEdges;
theTopEdges = getDPrism().TopEdges();
theLatEdges = getDPrism().LatEdges();
TopTools_ListIteratorOfListOfShape it;
BRep_Builder B;
B.MakeCompound(TopoDS::Compound(theShapeTop));
it.Initialize(theTopEdges);
for (; it.More(); it.Next())
{
TopExp_Explorer exp;
for (exp.Init(it.Value(), TopAbs_EDGE); exp.More(); exp.Next())
{
B.Add(theShapeTop, exp.Current());
}
}
DBRep::Set(a[2], theShapeTop);
dout.Flush();
B.MakeCompound(TopoDS::Compound(theShapeBottom));
it.Initialize(theLatEdges);
for (; it.More(); it.Next())
{
B.Add(theShapeBottom, it.Value());
}
DBRep::Set(a[3], theShapeBottom);
dout.Flush();
if (Kas == 1)
return 0;
}
if (Kas == 2 || Kas == 3)
{
// Standard_Integer nrad;
TopoDS_Shape V;
if (Kas == 2)
{
V = DBRep::Get(a[2], TopAbs_SHAPE);
}
else if (Kas == 3)
{
V = getDPrism();
}
if (V.IsNull())
return 1;
ChFi3d_FilletShape FSh = ChFi3d_Rational;
if (Rakk)
delete Rakk;
Rakk = new BRepFilletAPI_MakeFillet(V, FSh);
Rakk->SetParams(ta, tesp, t2d, t3d, t2d, fl);
Rakk->SetContinuity(blend_cont, tapp_angle);
Standard_Real Rad;
TopoDS_Shape S;
TopoDS_Edge E;
Standard_Integer nbedge = 0;
if (Kas == 2)
{
for (Standard_Integer ii = 1; ii < (narg - 1) / 2; ii++)
{
Rad = Draw::Atof(a[2 * ii + 1]);
if (Rad == 0.)
continue;
S = DBRep::Get(a[(2 * ii + 2)], TopAbs_SHAPE);
TopExp_Explorer exp;
for (exp.Init(S, TopAbs_EDGE); exp.More(); exp.Next())
{
E = TopoDS::Edge(exp.Current());
if (!E.IsNull())
{
Rakk->Add(Rad, E);
nbedge++;
}
}
}
}
else if (Kas == 3)
{
Rad = Draw::Atof(a[3]);
if (Rad != 0.)
{
S = theShapeTop;
TopExp_Explorer exp;
for (exp.Init(S, TopAbs_EDGE); exp.More(); exp.Next())
{
E = TopoDS::Edge(exp.Current());
if (!E.IsNull())
{
Rakk->Add(Rad, E);
nbedge++;
}
}
}
Rad = Draw::Atof(a[4]);
if (Rad != 0.)
{
S = theShapeBottom;
TopExp_Explorer exp;
for (exp.Init(S, TopAbs_EDGE); exp.More(); exp.Next())
{
E = TopoDS::Edge(exp.Current());
if (!E.IsNull())
{
Rakk->Add(Rad, E);
nbedge++;
}
}
}
}
if (!nbedge)
return 1;
Rakk->Build();
if (!Rakk->IsDone())
return 1;
TopoDS_Shape res = Rakk->Shape();
if (Kas == 2)
{
DBRep::Set(a[1], res);
}
else if (Kas == 3)
{
DBRep::Set(a[2], res);
}
dout.Flush();
// Save history for fillet
if (BRepTest_Objects::IsHistoryNeeded())
{
TopTools_ListOfShape anArg;
anArg.Append(V);
BRepTest_Objects::SetHistory(anArg, *Rakk);
}
return 0;
}
return 1;
}
//=============================================================================
// function : ComputeSimpleOffset
// purpose : Computes simple offset.
//=============================================================================
static Standard_Integer ComputeSimpleOffset(Draw_Interpretor& theCommands,
Standard_Integer narg,
const char** a)
{
if (narg < 4)
{
theCommands << "offsetshapesimple result shape offsetvalue [solid] [tolerance=1e-7]\n";
return 1;
}
// Input data.
TopoDS_Shape aShape = DBRep::Get(a[2]);
if (aShape.IsNull())
{
theCommands << "Input shape is null";
return 0;
}
const Standard_Real anOffsetValue = Draw::Atof(a[3]);
if (Abs(anOffsetValue) < gp::Resolution())
{
theCommands << "Null offset value";
return 0;
}
Standard_Boolean makeSolid = (narg > 4 && !strcasecmp(a[4], "solid"));
int iTolArg = (makeSolid ? 5 : 4);
Standard_Real aTol = (narg > iTolArg ? Draw::Atof(a[iTolArg]) : Precision::Confusion());
BRepOffset_MakeSimpleOffset aMaker(aShape, anOffsetValue);
aMaker.SetTolerance(aTol);
aMaker.SetBuildSolidFlag(makeSolid);
aMaker.Perform();
if (!aMaker.IsDone())
{
theCommands << "ERROR:" << aMaker.GetErrorMessage() << "\n";
return 0;
}
DBRep::Set(a[1], aMaker.GetResultShape());
return 0;
}
//=================================================================================================
void BRepTest::FeatureCommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
if (done)
return;
done = Standard_True;
DBRep::BasicCommands(theCommands);
const char* g = "TOPOLOGY Feature commands";
theCommands.Add(
"localope",
" Performs a local top. operation : localope result shape tool F/C (fuse/cut) face [face...]",
__FILE__,
Loc,
g);
theCommands.Add(
"hole",
" Performs a hole : hole result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius [Pfrom Pto]",
__FILE__,
HOLE1,
g);
theCommands.Add(
"firsthole",
" Performs the first hole : firsthole result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius",
__FILE__,
HOLE2,
g);
theCommands.Add(
"holend",
" Performs the hole til end : holend result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius",
__FILE__,
HOLE3,
g);
theCommands.Add("blindhole",
" Performs the blind hole : blindhole result shape Or.X Or.Y Or.Z Dir.X Dir.Y "
"Dir.Z Radius Length",
__FILE__,
HOLE4,
g);
theCommands.Add("holecontrol",
"Sets/Unsets or display controls on holes : holecontrol [0/1]",
__FILE__,
CONTROL,
g);
theCommands.Add("wprism",
"Prisms wires on a face : wprism f[use]/c[ut] result shape [[FaceFrom] "
"FaceUntil] VecX VecY VecZ SkecthFace wire1 [wire2 ....]",
__FILE__,
PRW,
g);
theCommands.Add("fprism",
"Prisms a set of faces of a shape : fprism f[use]/c[ut] result shape [[FaceFrom] "
"FaceUntil] VecX VecY VecZ face1 [face2...]",
__FILE__,
PRF,
g);
theCommands.Add("wrotate",
"Rotates wires on a face : wrotate f[use]/c[ut] result shape Angle/[FFrom] "
"FUntil OX OY OZ DX DY DZ SkecthFace wire1 [wire2 ....]",
__FILE__,
ROW,
g);
theCommands.Add("frotate",
"Rotates a set of faces of a shape : frotate f[use]/c[ut] result shape "
"Angle/[FaceFrom] FaceUntil OX OY OZ DX DY DZ face1 [face2...]",
__FILE__,
ROF,
g);
theCommands.Add("splitshape",
"splitshape result shape [splitedges] [face wire/edge/compound "
"[wire/edge/compound ...][face wire/edge/compound [wire/edge/compound...] ...] "
"[@ edgeonshape edgeonwire [edgeonshape edgeonwire...]]",
__FILE__,
SPLS,
g);
theCommands.Add("thickshell",
"thickshell r shape offset [jointype [tol] ]",
__FILE__,
thickshell,
g);
theCommands.Add("mkoffsetshape",
"mkoffsetshape r shape offset [Tol] [Intersection(0/1)] [SelfInter(0/1)] "
"[JoinType(a/i)] [RemoveInternalEdges(0/1)]",
__FILE__,
mkoffsetshape,
g);
theCommands.Add("offsetshape",
"offsetshape r shape offset [tol] [face ...]",
__FILE__,
offsetshape,
g);
theCommands.Add("offsetcompshape",
"offsetcompshape r shape offset [face ...]",
__FILE__,
offsetshape,
g);
theCommands.Add("offsetparameter",
"offsetparameter Tol Inter(c/p) JoinType(a/i/t) [RemoveInternalEdges(r/k)]",
__FILE__,
offsetparameter,
g);
theCommands.Add("offsetload",
"offsetload shape offset bouchon1 bouchon2 ...",
__FILE__,
offsetload,
g);
theCommands.Add("offsetonface",
"offsetonface face1 offset1 face2 offset2 ...",
__FILE__,
offsetonface,
g);
theCommands.Add("offsetperform", "offsetperform result", __FILE__, offsetperform, g);
theCommands.Add("glue",
"glue result shapenew shapebase facenew facebase [facenew facebase...] [edgenew "
"edgebase [edgenew edgebase...]]",
__FILE__,
GLU,
g);
theCommands.Add("featprism",
"Defines the arguments for a prism : featprism shape element skface Dirx Diry "
"Dirz Fuse(0/1/2) Modify(0/1)",
__FILE__,
DEFIN,
g);
theCommands.Add("featrevol",
"Defines the arguments for a revol : featrevol shape element skface Ox Oy Oz Dx "
"Dy Dz Fuse(0/1/2) Modify(0/1)",
__FILE__,
DEFIN,
g);
theCommands.Add("featpipe",
"Defines the arguments for a pipe : featpipe shape element skface spine "
"Fuse(0/1/2) Modify(0/1)",
__FILE__,
DEFIN,
g);
theCommands.Add("featdprism",
"Defines the arguments for a drafted prism : featdprism shape face skface angle "
"Fuse(0/1/2) Modify(0/1)",
__FILE__,
DEFIN,
g);
theCommands.Add("featlf",
"Defines the arguments for a linear rib or slot : featlf shape wire plane DirX "
"DirY DirZ DirX DirY DirZ Fuse(0/1/2) Modify(0/1)",
__FILE__,
DEFIN,
g);
theCommands.Add("featrf",
"Defines the arguments for a rib or slot of revolution : featrf shape wire plane "
"X Y Z DirX DirY DirZ Size Size Fuse(0/1/2) Modify(0/1)",
__FILE__,
DEFIN,
g);
theCommands.Add("addslide",
" Adds sliding elements : addslide prism/revol/pipe edge face [edge face...]",
__FILE__,
ADD,
g);
theCommands.Add("featperform",
" Performs the prism revol dprism linform or pipe :featperform "
"prism/revol/pipe/dprism/lf result [[Ffrom] Funtil]",
__FILE__,
PERF,
g);
theCommands.Add("featperformval",
" Performs the prism revol dprism or linform with a value :featperformval "
"prism/revol/dprism/lf result value",
__FILE__,
PERF,
g);
theCommands.Add("endedges",
" Return top and bottom edges of dprism :endedges dprism shapetop shapebottom "
"First/LastShape (1/2)",
__FILE__,
BOSS,
g);
theCommands.Add(
"fillet",
" Perform fillet on compounds of edges :fillet result object rad1 comp1 rad2 comp2 ...",
__FILE__,
BOSS,
g);
theCommands.Add("bossage",
" Perform fillet on top and bottom edges of dprism :bossage dprism result radtop "
"radbottom First/LastShape (1/2)",
__FILE__,
BOSS,
g);
theCommands.Add("offsetshapesimple",
"offsetshapesimple result shape offsetvalue [solid] [tolerance=1e-7]",
__FILE__,
ComputeSimpleOffset,
g);
}
36c80dbe7This file is pinned to the selected release. Download the original to open it in your design tool.