Removed duplicating semicolons ;;.
Removed redundant semicolon at namespace closure.
}
else
{
- Quantity_Color CC = Quantity_NOC_YELLOW;;
+ Quantity_Color CC = Quantity_NOC_YELLOW;
if( HasColor() ) CC = myDrawer->Color();
else if (myDrawer->HasLink()) AIS_GraphicTool::GetLineColor(myDrawer->Link(),AIS_TOA_Line,CC);
myDrawer->LineAspect()->SetColor(CC);
gp_Pln pln(myPlane->Pln());
gp_Dir dir(pln.XAxis().Direction());
gp_Vec transvec = gp_Vec(dir)*myArrowSize;
- curpos = myPntAttach.Translated(transvec);;
+ curpos = myPntAttach.Translated(transvec);
myPosition = curpos;
myAutomaticPosition = Standard_True;
}
const AIS_TypeOfAttribute Att)
{
Handle(Prs3d_LineAspect) LA = GetLineAspect(Dr,Att);
- return LA->Aspect()->Type();;
+ return LA->Aspect()->Type();
}
gp_Pln pln(myPlane->Pln());
gp_Dir dir(pln.XAxis().Direction());
gp_Vec transvec = gp_Vec(dir)*myArrowSize;
- curpos = myFAttach.Translated(transvec);;
+ curpos = myFAttach.Translated(transvec);
myPosition = curpos;
myAutomaticPosition = Standard_True;
}
#include <V3d_View.hxx>
#include <Standard_Version.hxx>
#include <Standard_DefineHandle.hxx>
-NCOLLECTION_HSEQUENCE(AIS_ManipulatorObjectSequence, Handle(AIS_InteractiveObject));
+
+NCOLLECTION_HSEQUENCE(AIS_ManipulatorObjectSequence, Handle(AIS_InteractiveObject))
DEFINE_STANDARD_HANDLE (AIS_Manipulator, AIS_InteractiveObject)
gp_Pnt myTSAttach = mySAttach.Transformed (myRelativePos);
gp_Dir myTDirAttach = myDirAttach.Transformed (myRelativePos);
gp_Dir myTDirAttach2 = myDirAttach2.Transformed (myRelativePos);
- gp_Pnt Tcurpos = myPosition.Transformed (myRelativePos);;
+ gp_Pnt Tcurpos = myPosition.Transformed (myRelativePos);
gp_Lin L1 (myTFAttach,myTDirAttach);
gp_Lin L2 (myTSAttach,myTDirAttach2);
gp_Elips2d Adaptor2d_OffsetCurve::Ellipse() const
{
if (myCurve->GetType() == GeomAbs_Ellipse && myOffset == 0.) {
- return myCurve->Ellipse();;
+ return myCurve->Ellipse();
}
else {
throw Standard_NoSuchObject("Adaptor2d_OffsetCurve:Ellipse");
if (surumin || survmin || surumax || survmax) {
return(Standard_True);
}
- return(Standard_False);;
+ return Standard_False;
}
}
Standard_Real Uf = F.Parameter(Lin->Point(1));
Standard_Real Ul = F.Parameter(Lin->Point(NbPoint))-Uf;
for (i=2; i<NbPoint; i++) {
- theParams(i) = (F.Parameter(Lin->Point(i))-Uf)/Ul;;
+ theParams(i) = (F.Parameter(Lin->Point(i))-Uf)/Ul;
}
AppDef_Compute theAppDef(theParams,dmin,dmax,tol3d,tol2d,nbit,
Standard_True, Standard_True);
Standard_Real Uf = F.Parameter(Lin->Point(1));
Standard_Real Ul = F.Parameter(Lin->Point(NbPoint))-Uf;
for (i=2; i<NbPoint; i++) {
- theParams(i) = (F.Parameter(Lin->Point(i))-Uf)/Ul;;
+ theParams(i) = (F.Parameter(Lin->Point(i))-Uf)/Ul;
}
theapprox.Init(dmin,dmax,tol3d,tol2d,nbit,Standard_True,
myDone = Standard_True;
for (i = bdeb; i <= bfin; i++) {
for (j = bdeb; j <= bfin; j++) {
- IBPij = IBP(i, j);;
+ IBPij = IBP(i, j);
for (k = 1; k<= nbcol; k++) {
myPoles(i, k) += IBPij * B2(j, k);
}
math_Matrix& DA) {
Standard_Integer i, j, id, Ndeg = NbPoles-1;
- Standard_Real u0, u1, y0, y1, xs, bj, bj1;;
+ Standard_Real u0, u1, y0, y1, xs, bj, bj1;
Standard_Integer first = U.Lower(), last = U.Upper();
math_Vector B(1, NbPoles-1);
{
if (!done) {throw StdFail_NotDone();}
- Standard_Integer i, j, j2, npoints = nbP+nbP2d;;
+ Standard_Integer i, j, j2, npoints = nbP+nbP2d;
gp_Pnt Pt;
gp_Pnt2d Pt2d;
Standard_Integer ideb = resinit, ifin = resfin;
myC3d->D0(pc3d[ii],Pc3d);
dist2 = Pcons.SquareDistance(Pc3d);
use_parameter = (dist2 <= Tol2 && (pc3d[ii] > pc3d[count-1] + deltamin)) ;
- Standard_Real aDistMin = RealLast();;
+ Standard_Real aDistMin = RealLast();
if(use_parameter) {
if(dist2 > dmax2) dmax2 = dist2;
{
if (myCref.IsNull())
return;
- Standard_Boolean ok=Standard_True;;
+ Standard_Boolean ok = Standard_True;
Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&myShape.TShape());
Standard_Real Tol = BRep_Tool::Tolerance(TopoDS::Edge(myShape));
else {
TopoDS_Shape aLocalShape = Faces.First().EmptyCopied();
TopoDS_Face NF = TopoDS::Face(aLocalShape);
- // TopoDS_Face NF = TopoDS::Face(Faces.First().EmptyCopied());;
+ // TopoDS_Face NF = TopoDS::Face(Faces.First().EmptyCopied());
B.Add (NF,WI);
Faces.Append (NF);
BuildFaceIn (NF, WI, KeyContains, KeyIsIn, TopAbs_FORWARD,Faces);
fprintf(afile,"%s\n","# Result is Null ");
fprintf(afile, "%s %s %s\n","restore", aName1.ToCString(), "arg1");
- fprintf(afile, "%s %s %s\n","restore", aName2.ToCString(), "arg2");;
+ fprintf(afile, "%s %s %s\n","restore", aName2.ToCString(), "arg2");
TCollection_AsciiString aBopString;
switch (theOperation)
{
gp_Vec d1u1,d1v1,d2u1,d2v1,d2uv1,d1;
gp_Vec ns,ns2,dnplan,dnw,dn2w; //,np2,dnp2;
- gp_Vec ncrossns;;
+ gp_Vec ncrossns;
gp_Vec resulu,resulv,temp,tgct,resul;
gp_Vec d1urst,d1vrst;
gp_Pnt Center,bid;
gp_Vec d1u1,d1v1,d2u1,d2v1,d2uv1,d1;
gp_Vec ns,ns2,dnplan,dnw,dn2w;//,np2,dnp2;
- gp_Vec ncrossns;;
+ gp_Vec ncrossns;
gp_Vec resulu,resulv,temp,tgct,resul;
gp_Vec d1urst,d1vrst;
gp_Pnt Center,bid;
{
if(anExtr.NbExt() > 0)
{
- Standard_Integer i, imin = 0;;
+ Standard_Integer i, imin = 0;
Standard_Real dmin = RealLast();
Standard_Real uextr = 0., vextr = 0.;
Extrema_POnSurf P1, P2;
break;
case BRepFeat_EmptyCutResult :
s << "Failure in Cut : Empty resulting shape";
- break;;
+ break;
case BRepFeat_FalseSide :
s << "Verify plane and wire orientation";
break;
TopoDS_Edge BRepFill_Pipe::Edge(const TopoDS_Edge& ESpine,
const TopoDS_Vertex& VProfile)
{
- Standard_Integer ii, ispin = 0, iprof = 0, count = 0;;
+ Standard_Integer ii, ispin = 0, iprof = 0, count = 0;
// *************************************************
// Search if VProfile is a Vertex of myProfile
// Control direction & Range
Standard_Real R, First, Last, Tol=1.e-4;
- Standard_Boolean reverse = Standard_False;;
+ Standard_Boolean reverse = Standard_False;
// Class BRep_Tool without fields and without Constructor :
else if (Type == GeomAbs_BezierCurve) {
Handle(Geom_BezierCurve) BZ = AC.Bezier();
Standard_Integer NbPoles = BZ->NbPoles();
- Standard_Real aMaxPoleDist2 = 0.0, aMaxTol2 = theMaxTol*theMaxTol;;
+ Standard_Real aMaxPoleDist2 = 0.0, aMaxTol2 = theMaxTol*theMaxTol;
gp_Pnt P1,P2;
P1 = BZ->Pole(1);
for (Standard_Integer i = 2; i <= NbPoles; i++) {
//=======================================================================
void BRepMesh_Delaun::insertInternalEdges()
{
- Handle(IMeshData::MapOfInteger) anInternalEdges = InternalEdges();;
+ Handle(IMeshData::MapOfInteger) anInternalEdges = InternalEdges();
// Destruction of triancles intersecting internal edges
// and their replacement by makeshift triangles
//---------------------------
// E1 generated a tube.
//---------------------------
- F1 = TopoDS::Face(InitOffsetFace.Image(E1).First());;
+ F1 = TopoDS::Face(InitOffsetFace.Image(E1).First());
TopExp::Vertices(E1,V[0],V[1]);
const TopTools_ListOfShape& AncE1 = Analyse.Ancestors(E1);
return 1;
}
gp_Dir D(Draw::Atof(a[2]), Draw::Atof(a[3]), Draw::Atof(a[4]));
- Sweep->SetMode(D);;
+ Sweep->SetMode(D);
}
else if (!strcmp(a[1], "-FX")) {
if ((n != 5) && (n != 8)) {
if (OF2isEdge) { // Update CutEdges.
exp.Next();
const TopoDS_Edge& EOnF2 = TopoDS::Edge(exp.Current());
- TopExp::Vertices(EOnF2,V1,V2);;
+ TopExp::Vertices(EOnF2,V1,V2);
gp_Pnt P1 = BRep_Tool::Pnt(V1);
Projector.Init(P1,GC2);
Standard_IStream& BinTools::GetInteger(Standard_IStream& IS, Standard_Integer& aValue)
{
if(!IS.read ((char*)&aValue, sizeof(Standard_Integer)))
- throw Storage_StreamTypeMismatchError();;
+ throw Storage_StreamTypeMismatchError();
#if DO_INVERSE
aValue = InverseInt (aValue);
#endif
Standard_IStream& BinTools::GetExtChar(Standard_IStream& IS, Standard_ExtCharacter& theValue)
{
if(!IS.read ((char*)&theValue, sizeof(Standard_ExtCharacter)))
- throw Storage_StreamTypeMismatchError();;
+ throw Storage_StreamTypeMismatchError();
#if DO_INVERSE
theValue = InverseExtChar (theValue);
#endif
Standard_Real Norm2;
C->D2(US,P,D1,D2);
- Norm2 = D1.SquareMagnitude();;
+ Norm2 = D1.SquareMagnitude();
if (Norm2 < gp::Resolution()) { KF = 0.0;}
else { KF = Abs(D1^D2)/(Norm2*sqrt(Norm2));}
C->D2(UL,P,D1,D2);
- Norm2 = D1.SquareMagnitude();;
+ Norm2 = D1.SquareMagnitude();
if (Norm2 < gp::Resolution()) { KL = 0.0;}
else { KL = Abs(D1^D2)/(Norm2*sqrt(Norm2));}
gp_Vec2d D1,D2;
gp_Pnt2d P;
C->D2(U,P,D1,D2);
- Standard_Real Norm2 = D1.SquareMagnitude();;
+ Standard_Real Norm2 = D1.SquareMagnitude();
if (Norm2 < Tol) {
K1 = 0.0;
}
gp_Vec2d D1,D2;
gp_Pnt2d P;
C->D2(U,P,D1,D2);
- Standard_Real Norm2 = D1.SquareMagnitude();;
+ Standard_Real Norm2 = D1.SquareMagnitude();
if (Norm2 < Tol) {
K1 = 0.0;
}
previousP.Parameter(),tolesp);
Ext2.SetValue(previousP.PointOnS2(),
sol(3),sol(4),
- previousP.Parameter(),tolesp);;
+ previousP.Parameter(),tolesp);
if (!previousP.IsTangencyPoint()) {
Ext1.SetTangent(previousP.TangentOnS1());
Ext2.SetTangent(previousP.TangentOnS2());
{
gp_Vec d1u1,d1v1,d2u1,d2v1,d2uv1,d1,d2;
gp_Vec ns,ns2,dnplan,dnw,dn2w; //,np2,dnp2;
- gp_Vec ncrossns;;
+ gp_Vec ncrossns;
gp_Vec resulu,resulv,temp,tgct,resul;
gp_Pnt Center;
- Standard_Real norm,ndotns,grosterme;;
+ Standard_Real norm,ndotns,grosterme;
math_Vector sol(1,2),valsol(1,2),secmember(1,2);
math_Matrix gradsol(1,2,1,2);
gp_Vec d1u1,d1v1,d2u1,d2v1,d2uv1,d1;
gp_Vec ns,ns2,dnplan,dnw,dn2w; //,np2,dnp2;
- gp_Vec ncrossns;;
+ gp_Vec ncrossns;
gp_Vec resulu,resulv,temp,tgct,resul;
gp_Pnt Center;
Abs(valsol(4)) <= Tol*Tol)
return Standard_True;
- return Standard_False;;
+ return Standard_False;
}
//=======================================================================
Abs(valsol(4)) <= Tol)
return Standard_True;
- return Standard_False;;
+ return Standard_False;
}
//=======================================================================
//! A referenced document may indicate through this
//! virtual method that it does not allow the closing of
//! aDocument which it references through the reference
- //! aReferenceIdentifier. By default returns Standard_True;;
+ //! aReferenceIdentifier. By default returns Standard_True.
Standard_EXPORT virtual Standard_Boolean CanCloseReference (const Handle(CDM_Document)& aDocument, const Standard_Integer aReferenceIdentifier) const;
//! A referenced document may update its internal
Standard_Integer IArcspine = DStr.AddShape(Arcspine);
Standard_Integer IVtx = CorDat->IndexFirstPointOnS1();
- TopAbs_Orientation OVtx = TopAbs_FORWARD;;
+ TopAbs_Orientation OVtx = TopAbs_FORWARD;
for(ex.Init(Arcspine.Oriented(TopAbs_FORWARD),TopAbs_VERTEX);
ex.More(); ex.Next()) {
#endif
TopoDS_Edge edgecouture;
- Standard_Boolean couture,intcouture=Standard_False;;
+ Standard_Boolean couture,intcouture=Standard_False;
Standard_Real tolreached = tolesp;
Standard_Real par1 =0.,par2 =0.;
Standard_Integer indpt = 0,Icurv1 = 0,Icurv2 = 0;
#endif
TopoDS_Edge edgecouture;
- Standard_Boolean couture,intcouture=Standard_False;;
+ Standard_Boolean couture,intcouture=Standard_False;
Standard_Real tolreached = tolesp;
Standard_Real par1 = 0.,par2 = 0.;
Standard_Integer indpt =0,Icurv1 =0,Icurv2 =0;
Spine->SetMode(myMode);
Standard_Real Offset = -1;
if (myMode == ChFiDS_ConstThroatWithPenetrationChamfer)
- Offset = Min(Dis1,Dis2);;
-
+ {
+ Offset = Min(Dis1,Dis2);
+ }
+
Spine->SetEdges(E_wnt);
if(PerformElement(Spine, Offset, F)){
Spine->Load();
const Standard_Boolean RecRst,
const math_Vector& Soldep)
{
- Handle(ChFiDS_SurfData) Data = SeqData(1);;
+ Handle(ChFiDS_SurfData) Data = SeqData(1);
Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
if(fsp.IsNull()) throw Standard_ConstructionError("PerformSurf : this is not the spine of a fillet");
Handle(BRepBlend_Line) lin;
const Standard_Boolean RecRst2,
const math_Vector& Soldep)
{
- Handle(ChFiDS_SurfData) Data = SeqData(1);;
+ Handle(ChFiDS_SurfData) Data = SeqData(1);
Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
if(fsp.IsNull()) throw Standard_ConstructionError("PerformSurf : this is not the spine of a fillet");
Handle(BRepBlend_Line) lin;
#endif
if (!anIS) {
// Can not open file
- std::cout << "Error: can't open file " << aFileName <<std::endl;;
+ std::cout << "Error: can't open file " << aFileName <<std::endl;
return 1;
}
char buf[1024];
TCollection_ExtendedString aKey(itr.Key());
TCollection_AsciiString aStr(aKey,'?');
Standard_Integer aValue = itr.Value();
- std::cout << "Key = " << aStr.ToCString() << " Value = " <<aValue<<std::endl;;
+ std::cout << "Key = " << aStr.ToCString() << " Value = " <<aValue<<std::endl;
}
return 0;
if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if(anAtt.IsNull()) {
- std::cout << "NamedData attribute is not found or not set" << std::endl;;
+ std::cout << "NamedData attribute is not found or not set" << std::endl;
return 1;}
j = 4;
Standard_Boolean Draw_Viewer::SaveView(const Standard_Integer id,
const char* filename)
{
- if (Draw_Batch) return Standard_False;;
+ if (Draw_Batch)
+ {
+ return Standard_False;
+ }
Flush();
if (myViews[id]) {
return myViews[id]->Save(filename);
Standard_Boolean DrawWindow::DefineColor (const Standard_Integer, const char*)
{
return Standard_True;
-};
+}
#endif
if (op->NbSubExpressions() > 1) {
str = "(";
str += op->String();
- str += ")";;
+ str += ")";
}
else {
str = op->String();
if (op->NbSubExpressions() > 1) {
str += "(";
str += op->String();
- str += ")";;
+ str += ")";
}
else {
str += op->String();
TCollection_AsciiString res = myFunction->GetStringName();
res += "(";
res += Operand()->String();
- res += ")";;
+ res += ")";
return res;
}
Standard_Boolean isonedge1 = myListStripe.First()->SetOfSurfData()->Value(1)->
VertexFirstOnS1().IsOnArc();
Standard_Boolean isonedge2= myListStripe.First()->SetOfSurfData()->Value(1)->
- VertexFirstOnS2().IsOnArc();;
+ VertexFirstOnS2().IsOnArc();
if (isonedge1 && isonedge2)
{return FilletSurf_TwoExtremityOnEdge;}
namespace
{
-
// list of supported extensions
static Standard_CString Font_FontMgr_Extensions[] =
{
"ttc",
NULL
};
-
- };
+ }
#else
WellDone = Standard_True;
NbrSol = 1;
TheSame1(1) = 0;
- qualifier1(1) = Qualified1.Qualifier();;
+ qualifier1(1) = Qualified1.Qualifier();
qualifier2(1) = Qualified2.Qualifier();
pnttg1sol(1)=gp_Pnt2d(Cen.XY()+cote*Radius*gp_XY(ydir,-xdir));
pnttg2sol(1)=gp_Pnt2d(Cen.XY()+Radius*gp_XY(ydir,-xdir));
tol(1) = 2.e-15*M_PI;
tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
- tol(4) = Tol/10.;;
+ tol(4) = Tol/10.;
gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
const Standard_Real wTol,
const Standard_Real pas)
{
- Standard_Boolean ok = Standard_True;;
+ Standard_Boolean ok = Standard_True;
Standard_Integer ii, L = DP1.Length();
Standard_Real d2w;
gp_Vec d2P;
if ((SectionType == GeomAbs_Circle) && IsTrsf) {
gp_Circ C = AC.Circle();
Standard_Real Radius;
- Standard_Boolean IsGoodSide = Standard_True;;
+ Standard_Boolean IsGoodSide = Standard_True;
C.Transform(Tf2);
gp_Vec DC;
// On calcul le centre eventuel
for(i=1; i<=NTCurve; i++)
if (myLinCont->Value(i)->Order()!=-1)
- { Standard_Integer NbPt=myParCont->Value(i).Length();;
+ { Standard_Integer NbPt=myParCont->Value(i).Length();
// first constraint point (j=0)
// Standard_Integer NbPt=myParCont->Length();
if (iordre==0) {
if (start.IsNull()) {
return res;
}
- Handle(IGESGeom_CircularArc) Circle = new IGESGeom_CircularArc;;
+ Handle(IGESGeom_CircularArc) Circle = new IGESGeom_CircularArc();
IGESConvGeom_GeomBuilder Build;
Standard_Real U1 = Udeb;
for (Standard_Integer j = 1; j <= nbnodes; j ++)
{
S << "[" << j << "]: - NodeIdentifier : "
- << ent->NodeIdentifier(j) << " - Node :"<<Message_EndLine; ;
+ << ent->NodeIdentifier(j) << " - Node :"<<Message_EndLine;
S << "Node : ";
dumper.Dump (ent->Node(j),S, 1);
S << " - Parameters : " << Message_EndLine;
const Handle(IGESData_IGESReaderData)& IR,
IGESData_ParamReader& PR) const
{
- Handle(Interface_Check) ach = new Interface_Check;;
+ Handle(Interface_Check) ach = new Interface_Check();
Handle(Interface_ReaderModule) imodule;
Standard_Integer CN;
Handle(Interface_Protocol) IGESDraw_Protocol::Resource
(const Standard_Integer /*num*/) const
{
- Handle(Interface_Protocol) res = IGESDimen::Protocol();;
+ Handle(Interface_Protocol) res = IGESDimen::Protocol();
return res;
}
Handle(Interface_Protocol) IGESGeom_Protocol::Resource
(const Standard_Integer /*num*/) const
{
- Handle(Interface_Protocol) res = IGESBasic::Protocol();;
+ Handle(Interface_Protocol) res = IGESBasic::Protocol();
return res;
}
//Standard_Boolean st; //szv#4:S4163:12Mar99 not needed
Standard_Integer nbSegments;
- Standard_Integer aType, aDegree, nbDimensions;;
+ Standard_Integer aType, aDegree, nbDimensions;
Handle(TColStd_HArray1OfReal) allBreakPoints;
Handle(TColStd_HArray2OfReal) allXPolynomials;
Handle(TColStd_HArray2OfReal) allYPolynomials;
Handle(Interface_Protocol) IGESGraph_Protocol::Resource
(const Standard_Integer /*num*/) const
{
- Handle(Interface_Protocol) res = IGESBasic::Protocol();;
+ Handle(Interface_Protocol) res = IGESBasic::Protocol();
return res;
}
Handle(Interface_Protocol) IGESSolid_Protocol::Resource
(const Standard_Integer /*num*/) const
{
- Handle(Interface_Protocol) res = IGESGeom::Protocol();;
+ Handle(Interface_Protocol) res = IGESGeom::Protocol();
return res;
}
// MGE 03/08/98
//Standard_Boolean abool; //szv#4:S4163:12Mar99 moved down
- Standard_Integer nbfaces=0;; //szv#4:S4163:12Mar99 `i` moved in for
+ Standard_Integer nbfaces=0; //szv#4:S4163:12Mar99 `i` moved in for
//Handle(IGESSolid_Face) aface; //szv#4:S4163:12Mar99 moved down
Handle(IGESSolid_HArray1OfFace) tempFaces;
Handle(TColStd_HArray1OfInteger) tempOrientation;
if (colT==(colP+colP)) {
colT++;
linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
- colO=colP+1;;
+ colO=colP+1;
}
else {
colT--;
linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
- colO=colP-1;;
+ colO=colP-1;
}
break;
case 3: // Oblique
Standard_Real div = dpOeT[iObj][iToo]-dpOeT[inext][iToo];
if(div>floatGap || div<-floatGap) {
parO[iObj]=dpOeT[iObj][iToo]/
- (dpOeT[iObj][iToo]-dpOeT[inext][iToo]);;
+ (dpOeT[iObj][iToo]-dpOeT[inext][iToo]);
piO=(IntPatch_PolyhedronTool::Point(FirstPol,OI[iObj]).XYZ()) +
(voo[iObj]*parO[iObj]);
}
if (colT==(colP+colP)) {
colT++;
linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
- colO=colP+1;;
+ colO=colP+1;
}
else {
colT--;
linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
- colO=colP-1;;
+ colO=colP-1;
}
break;
case 3: // Oblique
T1=FinTT;
NewTriangle(numP2,numP3,FinTP,TTriangles,MySurface,TPoints);
FinTT++;
- T2=FinTT;;
+ T2=FinTT;
NewTriangle(numP3,numP1,FinTP,TTriangles,MySurface,TPoints);
FinTT++;
}
BornSup(1) = BornInf(1); // limit the parameter
UVap(1) = BornInf(1);
- UVap(2) += Step*Duvy*StepSign;;
+ UVap(2) += Step*Duvy*StepSign;
return Standard_True;
}
else if (supu) { // jag 940616
else {
Vf.Orientation(TopAbs_REVERSED);
Vl.Orientation(TopAbs_FORWARD);
- rev = Standard_True;;
+ rev = Standard_True;
}
B.MakeEdge(NewEdg,Cimg,Precision::Confusion());
{
myError.Reset();
- Standard_Boolean retVal = Standard_False;;
+ Standard_Boolean retVal = Standard_False;
TCollection_AsciiString fName;
myPath.SystemName ( fName );
RationalArray[Index] = PolesArray[OtherIndex]; Index++; OtherIndex++;
}
Index -= Dimension;
- OtherIndex ++;;
+ ++OtherIndex;
for (jj = ii - 1 ; jj >= 0 ; jj--) {
Factor = binomial_array[jj] * PolesArray[(ii-jj) * Dimension1 + Dimension];
aSfwr->CheckSmallEdges(theSmallEdges,theEdgeToFaces,theFaceWithSmall, theMultyEdges);
aSfwr->MergeSmallEdges (theSmallEdges,theEdgeToFaces,theFaceWithSmall, theMultyEdges, aModeDrop,tolang);
//aSfwr->FixSmallEdges();
- TopoDS_Shape resShape = aSfwr->Shape();;
+ TopoDS_Shape resShape = aSfwr->Shape();
DBRep::Set ( argv[1], resShape );
return 0;
}
di << "Usage: " << argv[0] << " invalid number of arguments\n";
return 1;
}
- Handle(TDocStd_Document) aDoc = new TDocStd_Document("dummy");;
+ Handle(TDocStd_Document) aDoc = new TDocStd_Document("dummy");
TopoDS_Shape s1 = BRepPrimAPI_MakeBox(1,1,1).Shape();
TDF_Label lab1 = XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->NewShape();
XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->SetShape(lab1, s1);
if (aMem1 > aMem0)
theDI << "Error: memory increased by " << (int)(aMem1 - aMem0) << " bytes\n";
-};
+}
static Standard_Integer OCC29064 (Draw_Interpretor& theDI, Standard_Integer theArgc, const char** theArgv)
{
#ifdef OCCT_DEBUG
std::cout << "Warning: Point " << Model()->StringLabel ( P )->String() << " is not valid for centroid" << std::endl;
#endif
- return Standard_False;;
+ return Standard_False;
}
gp_Pnt pos ( P->CoordinatesValue(1), P->CoordinatesValue(2), P->CoordinatesValue(3) );
aSfwr->CheckSmallEdges(theSmallEdges,theEdgeToFaces,theFaceWithSmall, theMultyEdges);
aSfwr->MergeSmallEdges (theSmallEdges,theEdgeToFaces,theFaceWithSmall, theMultyEdges, aModeDrop,tolang);
//aSfwr->FixSmallEdges();
- TopoDS_Shape resShape = aSfwr->Shape();;
+ TopoDS_Shape resShape = aSfwr->Shape();
DBRep::Set ( a[1], resShape );
return 0;
}
/*if(aSurf->IsVPeriodic()) {
Standard_Real aDelta = (VL > VF ? VL - VF : VF - VL );
- v1 = (aDelta > 2.*M_PI ? 0. : VF + ShapeAnalysis::AdjustByPeriod(VF,0.5*(UL+UF),2*M_PI)); ;
+ v1 = (aDelta > 2.*M_PI ? 0. : VF + ShapeAnalysis::AdjustByPeriod(VF,0.5*(UL+UF),2*M_PI));
v2 = (aDelta > 2.*M_PI ? 2.* M_PI : v1 + aDelta);
}*/
if(!aSurf->IsVPeriodic()) {//else
if ( crv.IsNull() )
continue;
- Handle(Geom2d_Curve) c2d = BRep_Tool::CurveOnSurface ( edge, face, f, l );;
+ Handle(Geom2d_Curve) c2d = BRep_Tool::CurveOnSurface ( edge, face, f, l );
if ( c2d.IsNull() ) continue;
Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve ( c2d, f, l );
Adaptor3d_CurveOnSurface ACS(GHPC,AS);
Standard_Integer i; // svv #1
for ( i=begInd; ; i++ ) {
if ( i > nb ) i = 1;
- TopoDS_Edge edge = wire->Edge ( i );;
+ TopoDS_Edge edge = wire->Edge ( i );
Handle(Geom2d_Curve) c2d;
Standard_Real f, l;
ShapeBuild_Edge sbe;
Standard_Integer nb = sbwd->NbEdges();
- Standard_Boolean end = (nb == 0), degstop = Standard_False;;
+ Standard_Boolean end = (nb == 0), degstop = Standard_False;
Standard_Integer stop = nb;
Standard_Integer degn2 = 0;
gp_Pnt pdeg;
if (myRemoveLoopMode<1) {
for ( Standard_Integer iter=0; iter < 30; iter++ ) {
- Standard_Boolean loopRemoved = Standard_False;;
+ Standard_Boolean loopRemoved = Standard_False;
Standard_Real prevFirst = 0 , prevLast = 0;
for ( Standard_Integer i=1; i<=points2d.Length(); i++ ) {
gp_Pnt pint = points3d.Value(i);
default :
case GeomAbs_C1 : BasCriterion = GeomAbs_C2; break;
case GeomAbs_C2 : BasCriterion = GeomAbs_C3; break;
- case GeomAbs_C3 : //if (ShapeUpgrade::Debug()) std::cout<<". this criterion is not suitable for a Offset Surface"<<std::endl;;
+ case GeomAbs_C3 : //if (ShapeUpgrade::Debug()) std::cout<<". this criterion is not suitable for a Offset Surface"<<std::endl;
#ifdef OCCT_DEBUG
std::cout << "Warning: ShapeUpgrade_SplitSurfaceContinuity: criterion C3 for Offset surface" << std::endl;
#endif
Standard_EXPORT Handle(TColgp_HArray1OfXYZ) Points() const;
- DEFINE_STANDARD_RTTIEXT(StepVisual_CoordinatesList,StepVisual_TessellatedItem);
+ DEFINE_STANDARD_RTTIEXT(StepVisual_CoordinatesList,StepVisual_TessellatedItem)
private:
typedef NCollection_Vector<Handle(TColStd_HSequenceOfInteger)> StepVisual_VectorOfHSequenceOfInteger;
-DEFINE_STANDARD_HANDLE(StepVisual_TessellatedCurveSet, StepVisual_TessellatedItem);
+DEFINE_STANDARD_HANDLE(StepVisual_TessellatedCurveSet, StepVisual_TessellatedItem)
class StepVisual_TessellatedCurveSet : public StepVisual_TessellatedItem
NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> myCurves;
public :
- DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedCurveSet,StepVisual_TessellatedItem);
+ DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedCurveSet,StepVisual_TessellatedItem)
};
#endif // StepVisual_TessellatedCurveSet
//! Returns a DraughtingCalloutElement select type
Standard_EXPORT StepVisual_TessellatedItem();
- DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedItem,StepGeom_GeometricRepresentationItem);
+ DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedItem,StepGeom_GeometricRepresentationItem)
};
#endif // StepVisual_TessellatedItem
std::cout<<"Undo(): dead lock between these attributes:"<<std::endl;
for (itr.Initialize(ADlist); itr.More(); itr.Next()) {
std::cout<<"AttributeDelta type = "<<itr.Value()->DynamicType()->Name();
- std::cout<<" Attribute type = "<<itr.Value()->Attribute()->DynamicType()->Name()<<std::endl;;
+ std::cout<<" Attribute type = "<<itr.Value()->Attribute()->DynamicType()->Name()<<std::endl;
if (before)
std::cout<<"BeforeUndo(): dead lock."<<std::endl;
else
//ota : to allow concentric constraint display between vertex and edge
if (shape1.ShapeType() != TopAbs_EDGE && shape2.ShapeType() != TopAbs_EDGE) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeConcentric: concentric between two vertexes : NOT DISPLAYED" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeConcentric: concentric between two vertexes : NOT DISPLAYED" << std::endl;
#endif
NullifyAIS(anAIS);
return;
Handle(Geom_Plane) aplane = Handle(Geom_Plane)::DownCast(ageom3);
if (aplane.IsNull()) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeConcentric: nul plane" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeConcentric: nul plane" << std::endl;
#endif
NullifyAIS(anAIS);
return;
Standard_Integer nbgeom = aConst->NbGeometries();
if (nbgeom < 4) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeEqual: at least four geometries are needed" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeEqual: at least four geometries are needed" << std::endl;
#endif
NullifyAIS(anAIS);
return;
Standard_Integer nbgeom = aConst->NbGeometries();
if (nbgeom < 2) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeEqualRadius: at least two geometries are needed" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeEqualRadius: at least two geometries are needed" << std::endl;
#endif
NullifyAIS(anAIS);
return;
Standard_Integer nbgeom = aConst->NbGeometries();
if (nbgeom < 1) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeDiameter: at least one constrainte is needed" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeDiameter: at least one constrainte is needed" << std::endl;
#endif
NullifyAIS(anAIS);
return;
Standard_Integer nbgeom = aConst->NbGeometries();
if (nbgeom < 1) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeFix: at least one constrainte is needed" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeFix: at least one constrainte is needed" << std::endl;
#endif
NullifyAIS(anAIS);
return;
}
if (!aConst->IsPlanar()) {
#ifdef OCCT_DEBUG
- std::cout << "TPrsStd_ConstraintTools::ComputeFix: must be a planar constraint" << std::endl;;
+ std::cout << "TPrsStd_ConstraintTools::ComputeFix: must be a planar constraint" << std::endl;
#endif
NullifyAIS(anAIS);
return;
const Handle(IntPatch_Line)& L = myIntersector.Line(i);
LI.SetLine(L,S1,S2);
LI.Index(i);
- myLineNb++;;
+ myLineNb++;
}*/}
if (newV) {
aFName+=postfix;
for (i=1; i<=n; i++) {
- TCollection_AsciiString aI(i), aName;;
+ TCollection_AsciiString aI(i), aName;
aName+=aFName; aName+=aI;
const TopoDS_Shape& aShape=aMapOfShapeWithState.FindKey(i);
if (tSPS) debsplitsemess(iE);
#endif
- Standard_Boolean isspliton = IsSplit(E,TopAbs_ON);;
+ Standard_Boolean isspliton = IsSplit(E,TopAbs_ON);
if (!isspliton) continue;
const TopTools_ListOfShape& LESD = BDS.ShapeSameDomain(E);
}
if(!myMapShapeStatus.IsBound(I))
myMapShapeStatus.Bind(I,TopOpeBRepDS_OK);
- return Standard_True;;
+ return Standard_True;
}
//=======================================================================
#ifdef OCCT_DEBUG
if (trc) {
std::cout<<"CorrectONUVISO ";
- std::cout<<"iso faulty "<<tocorrectisoe<<" deg faulty "<<tocorrectdege<<std::endl;;
+ std::cout<<"iso faulty "<<tocorrectisoe<<" deg faulty "<<tocorrectdege<<std::endl;
}
debcorrUV();
#endif
Standard_EXPORT Standard_Boolean FUN_tool_parVonE(const TopoDS_Vertex& v,const TopoDS_Edge& E,Standard_Real& par)
{
Standard_Real tol = Precision::Confusion();
- Standard_Boolean isVofE = Standard_False;;
+ Standard_Boolean isVofE = Standard_False;
TopExp_Explorer ex;
for (ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
// for (TopExp_Explorer ex(E,TopAbs_VERTEX); ex.More(); ex.Next()) {
std::cout<<" UNITS DICTIONARY : "<<std::endl;
for(;explorer.MoreQuantity();explorer.NextQuantity())
{
- std::cout<<explorer.Quantity()<<std::endl;;
+ std::cout<<explorer.Quantity()<<std::endl;
for(; explorer.MoreUnit(); explorer.NextUnit())
std::cout<<" "<<explorer.Unit()<<std::endl;
}
Standard_Boolean myHasAxis;
gp_Ax2 myPlane;
gp_Pnt myPnt;
- gp_Pnt myPntText;;
+ gp_Pnt myPntText;
Standard_Boolean myHasPlane;
Standard_Boolean myHasPnt;
Standard_Boolean myHasPntText;
public:
- DEFINE_STANDARD_RTTIEXT(XCAFDoc_AssemblyItemRef, TDF_Attribute);
+ DEFINE_STANDARD_RTTIEXT(XCAFDoc_AssemblyItemRef, TDF_Attribute)
Standard_EXPORT static const Standard_GUID& GetID();
if (control->ModeWriteBounds (modemin,modemax)) {
sout<<"Write Mode : allowed values "<<modemin<<" to "<<modemax<<Message_EndLine;
for (Standard_Integer modd = modemin; modd <= modemax; modd ++) {
- sout<<modd<<" : "<<control->ModeWriteHelp (modd)<<Message_EndLine;;
+ sout<<modd<<" : "<<control->ModeWriteHelp (modd)<<Message_EndLine;
}
}
sout<<"Write Mode : actual = "<<TW->TransferMode()<<Message_EndLine;
o << " Status = Done \n";
o <<" Location Vector = " << Location() << "\n";
o <<" Minimum value = "<< Minimum()<<"\n";
- o <<" Number of iterations = "<<NbIterations() <<"\n";;
+ o <<" Number of iterations = "<<NbIterations() <<"\n";
}
else {
o<< " Status = not Done because " << (Standard_Integer)TheStatus << "\n";
if(NbSol<4) {
Standard_Integer startIndex = NbSol + 1;
for( Standard_Integer solIt = startIndex; solIt <= 4; solIt++) {
- Teta = M_PI + IntegerPart(Mod)*2.0*M_PI;;
+ Teta = M_PI + IntegerPart(Mod)*2.0*M_PI;
X = Teta - MyBorneInf;
if ((X >= (-Epsilon(Delta))) && (X <= Delta + Epsilon(Delta))) {
if (Abs(A-C+E) <= Eps) {