OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0031004: Coding - eliminate warnings issued by gcc 9.1.0

Browse Source 
Fixed -Wrestrict warning within OSD::SetSignal().

Fixed -Wdeprecated-copy warning by adding missing counterpart
in pair copy constructor / assignment operator or by removing trivial constructor.

AdvApp2Var_Node, AdvApp2Var_Patch are now declared as Handle.
AdvApp2Var_Iso is now passed by Handle.

Disabled operator= for TDF_Transaction and TDF_IDFilter.

Standard.cxx - fixed GCC version mischeck causing building failure with experimental GCC versions.

TopOpeBRepDS_EXPORT.cxx - fixed -Wmaybe-uninitialized warnings.
This commit is contained in:
kgv 2020-05-08 23:41:22 +03:00 committed by bugmaster
parent 4b59685af1
commit 158f2931a7
55 changed files with 670 additions and 1001 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/AdvApp2Var/AdvApp2Var_ApproxAFunc2Var.cxx
View File

@ -244,7 +244,7 @@ void AdvApp2Var_ApproxAFunc2Var::InitGrid(const Standard_Integer NbInt)
{
Standard_Integer iu=myConditions.UOrder(),iv=myConditions.VOrder(),iint;
AdvApp2Var_Patch M0(myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,iu,iv);
Handle(AdvApp2Var_Patch) M0 = new AdvApp2Var_Patch (myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,iu,iv);
AdvApp2Var_SequenceOfPatch Net;
Net.Append(M0);
@ -259,29 +259,29 @@ void AdvApp2Var_ApproxAFunc2Var::InitGrid(const Standard_Integer NbInt)
gp_XY UV1(myFirstParInU,myFirstParInV);
AdvApp2Var_Node C1(UV1,iu,iv);
Handle(AdvApp2Var_Node) C1 = new AdvApp2Var_Node (UV1,iu,iv);
gp_XY UV2(myLastParInU,myFirstParInV);
AdvApp2Var_Node C2(UV2,iu,iv);
Handle(AdvApp2Var_Node) C2 = new AdvApp2Var_Node (UV2,iu,iv);
gp_XY UV4(myLastParInU,myLastParInV);
AdvApp2Var_Node C4(UV4,iu,iv);
Handle(AdvApp2Var_Node) C4 = new AdvApp2Var_Node (UV4,iu,iv);
gp_XY UV3(myFirstParInU,myLastParInV);
AdvApp2Var_Node C3(UV3,iu,iv);
Handle(AdvApp2Var_Node) C3 = new AdvApp2Var_Node (UV3,iu,iv);
AdvApp2Var_SequenceOfNode Bag;
Bag.Append(C1);
Bag.Append(C2);
Bag.Append(C3);
Bag.Append(C4);
AdvApp2Var_Iso V0(GeomAbs_IsoV,myFirstParInV,
Handle(AdvApp2Var_Iso) V0 = new AdvApp2Var_Iso (GeomAbs_IsoV,myFirstParInV,
myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
1,iu,iv);
AdvApp2Var_Iso V1(GeomAbs_IsoV,myLastParInV,
Handle(AdvApp2Var_Iso) V1 = new AdvApp2Var_Iso (GeomAbs_IsoV,myLastParInV,
myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
2,iu,iv);
AdvApp2Var_Iso U0(GeomAbs_IsoU,myFirstParInU,
Handle(AdvApp2Var_Iso) U0 = new AdvApp2Var_Iso (GeomAbs_IsoU,myFirstParInU,
myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
3,iu,iv);
AdvApp2Var_Iso U1(GeomAbs_IsoU,myLastParInU,
Handle(AdvApp2Var_Iso) U1 = new AdvApp2Var_Iso (GeomAbs_IsoU,myLastParInU,
myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
4,iu,iv);
@ -557,68 +557,74 @@ void AdvApp2Var_ApproxAFunc2Var::ComputeConstraints(const AdvApprox_Cutting& UCh
Standard_Real dec;
Standard_Boolean more;
Standard_Integer ind1, ind2, NbPatch, NbU, NbV;
AdvApp2Var_Iso Is;
Standard_Integer indN1, indN2;
Standard_Integer iu = myConditions.UOrder(), iv = myConditions.VOrder();
AdvApp2Var_Node N1(iu,iv), N2(iu,iv);
while ( myConstraints.FirstNotApprox(ind1, ind2, Is) ) {
for (Handle(AdvApp2Var_Iso) anIso = myConstraints.FirstNotApprox(ind1, ind2); !anIso.IsNull(); anIso = myConstraints.FirstNotApprox(ind1, ind2))
{
// approximation of iso and calculation of constraints at extremities
const Standard_Integer indN1 = myConstraints.FirstNode(anIso->Type(),ind1,ind2);
N1 = *myConstraints.Node(indN1);
const Standard_Integer indN2 = myConstraints.LastNode(anIso->Type(),ind1,ind2);
N2 = *myConstraints.Node(indN2);
// approximation of iso and calculation of constraints at extremities
indN1 = myConstraints.FirstNode(Is.Type(),ind1,ind2);
N1 = myConstraints.Node(indN1);
indN2 = myConstraints.LastNode(Is.Type(),ind1,ind2);
N2 = myConstraints.Node(indN2);
Is.MakeApprox(myConditions,
myFirstParInU, myLastParInU,
myFirstParInV, myLastParInV,
Func, N1 , N2);
if (Is.IsApproximated()) {
// iso is approached at the required tolerance
myConstraints.ChangeIso(ind1,ind2,Is);
myConstraints.ChangeNode(indN1) = N1;
myConstraints.ChangeNode(indN2) = N2;
// note that old code attempted to make copy of anIso here (but copy was incomplete)
anIso->MakeApprox (myConditions,
myFirstParInU, myLastParInU,
myFirstParInV, myLastParInV,
Func, N1 , N2);
if (anIso->IsApproximated())
{
// iso is approached at the required tolerance
myConstraints.ChangeIso(ind1,ind2,anIso);
*myConstraints.Node(indN1) = N1;
*myConstraints.Node(indN2) = N2;
}
else {
// Approximation is not satisfactory
else
{
// Approximation is not satisfactory
NbU = myResult.NbPatchInU();
NbV = myResult.NbPatchInV();
if (Is.Type()==GeomAbs_IsoV) {
NbPatch = (NbU+1)*NbV;
more = UChoice.Value(Is.T0(),Is.T1(),dec);
if (anIso->Type()==GeomAbs_IsoV)
{
NbPatch = (NbU+1)*NbV;
more = UChoice.Value(anIso->T0(), anIso->T1(), dec);
}
else {
NbPatch = (NbV+1)*NbU;
more = VChoice.Value(Is.T0(),Is.T1(),dec);
else
{
NbPatch = (NbV+1)*NbU;
more = VChoice.Value(anIso->T0(),anIso->T1(),dec);
}
if (NbPatch<=myMaxPatches && more) {
// It is possible to cut iso
if (Is.Type()==GeomAbs_IsoV) {
myResult.UpdateInU(dec);
myConstraints.UpdateInU(dec);
}
else {
myResult.UpdateInV(dec);
myConstraints.UpdateInV(dec);
}
if (NbPatch<=myMaxPatches && more)
{
// It is possible to cut iso
if (anIso->Type()==GeomAbs_IsoV)
{
myResult.UpdateInU(dec);
myConstraints.UpdateInU(dec);
}
else
{
myResult.UpdateInV(dec);
myConstraints.UpdateInV(dec);
}
}
else {
// It is not possible to cut : the result is preserved
if (Is.HasResult()) {
Is.OverwriteApprox();
myConstraints.ChangeIso(ind1,ind2,Is);
myConstraints.ChangeNode(indN1) = N1;
myConstraints.ChangeNode(indN2) = N2;
}
else {
myHasResult = myDone = Standard_False;
throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
}
else
{
// It is not possible to cut : the result is preserved
if (anIso->HasResult())
{
anIso->OverwriteApprox();
myConstraints.ChangeIso(ind1,ind2,anIso);
*myConstraints.Node(indN1) = N1;
*myConstraints.Node(indN2) = N2;
}
else
{
myHasResult = myDone = Standard_False;
throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
}
}
}
}
@ -638,74 +644,82 @@ void AdvApp2Var_ApproxAFunc2Var::ComputeConstraints(const AdvApprox_Cutting& UCh
Standard_Real dec;
Standard_Boolean more, CritRel = (Crit.Type() == AdvApp2Var_Relative);
Standard_Integer ind1, ind2, NbPatch, NbU, NbV;
AdvApp2Var_Iso Is;
Standard_Integer indN1, indN2;
Standard_Integer iu = myConditions.UOrder(), iv = myConditions.VOrder();
AdvApp2Var_Node N1(iu,iv), N2(iu,iv);
while ( myConstraints.FirstNotApprox(ind1, ind2, Is) ) {
for (Handle(AdvApp2Var_Iso) anIso = myConstraints.FirstNotApprox(ind1, ind2); !anIso.IsNull(); anIso = myConstraints.FirstNotApprox(ind1, ind2))
{
// approximation of the iso and calculation of constraints at the extremities
indN1 = myConstraints.FirstNode(anIso->Type(),ind1,ind2);
N1 = *myConstraints.Node(indN1);
indN2 = myConstraints.LastNode(anIso->Type(),ind1,ind2);
N2 = *myConstraints.Node(indN2);
// approximation of the iso and calculation of constraints at the extremities
indN1 = myConstraints.FirstNode(Is.Type(),ind1,ind2);
N1 = myConstraints.Node(indN1);
indN2 = myConstraints.LastNode(Is.Type(),ind1,ind2);
N2 = myConstraints.Node(indN2);
// note that old code attempted to make copy of anIso here (but copy was incomplete)
anIso->MakeApprox (myConditions,
myFirstParInU, myLastParInU,
myFirstParInV, myLastParInV,
Func, N1 , N2);
Is.MakeApprox(myConditions,
myFirstParInU, myLastParInU,
myFirstParInV, myLastParInV,
Func, N1 , N2);
if (Is.IsApproximated()) {
// iso is approached at the required tolerance
myConstraints.ChangeIso(ind1,ind2,Is);
myConstraints.ChangeNode(indN1) = N1;
myConstraints.ChangeNode(indN2) = N2;
if (anIso->IsApproximated())
{
// iso is approached at the required tolerance
myConstraints.ChangeIso(ind1,ind2,anIso);
*myConstraints.Node(indN1) = N1;
*myConstraints.Node(indN2) = N2;
}
else
{
// Approximation is not satisfactory
NbU = myResult.NbPatchInU();
NbV = myResult.NbPatchInV();
if (anIso->Type()==GeomAbs_IsoV)
{
NbPatch = (NbU+1)*NbV;
more = UChoice.Value(anIso->T0(),anIso->T1(),dec);
}
else
{
NbPatch = (NbV+1)*NbU;
more = VChoice.Value(anIso->T0(),anIso->T1(),dec);
}
else {
// Approximation is not satisfactory
NbU = myResult.NbPatchInU();
NbV = myResult.NbPatchInV();
if (Is.Type()==GeomAbs_IsoV) {
NbPatch = (NbU+1)*NbV;
more = UChoice.Value(Is.T0(),Is.T1(),dec);
}
else {
NbPatch = (NbV+1)*NbU;
more = VChoice.Value(Is.T0(),Is.T1(),dec);
}
// To force Overwrite if the criterion is Absolute
more = more && (CritRel);
// To force Overwrite if the criterion is Absolute
more = more && (CritRel);
if (NbPatch<=myMaxPatches && more) {
// It is possible to cut iso
if (Is.Type()==GeomAbs_IsoV) {
myResult.UpdateInU(dec);
myConstraints.UpdateInU(dec);
}
else {
myResult.UpdateInV(dec);
myConstraints.UpdateInV(dec);
}
}
else {
// It is not possible to cut: the result is preserved
if (Is.HasResult()) {
Is.OverwriteApprox();
myConstraints.ChangeIso(ind1,ind2,Is);
myConstraints.ChangeNode(indN1) = N1;
myConstraints.ChangeNode(indN2) = N2;
}
else {
myHasResult = myDone = Standard_False;
throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
}
}
if (NbPatch<=myMaxPatches && more)
{
// It is possible to cut iso
if (anIso->Type()==GeomAbs_IsoV)
{
myResult.UpdateInU(dec);
myConstraints.UpdateInU(dec);
}
else
{
myResult.UpdateInV(dec);
myConstraints.UpdateInV(dec);
}
}
else
{
// It is not possible to cut: the result is preserved
if (anIso->HasResult())
{
anIso->OverwriteApprox();
myConstraints.ChangeIso(ind1,ind2,anIso);
*myConstraints.Node(indN1) = N1;
*myConstraints.Node(indN2) = N2;
}
else
{
myHasResult = myDone = Standard_False;
throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
}
}
}
}
}
//=======================================================================

332
src/AdvApp2Var/AdvApp2Var_Framework.cxx
View File

@ -57,43 +57,30 @@ AdvApp2Var_Framework::AdvApp2Var_Framework(const AdvApp2Var_SequenceOfNode& Fram
//purpose : return the first Iso not approximated
//==========================================================================================
Standard_Boolean AdvApp2Var_Framework::FirstNotApprox(Standard_Integer& IndexIso,
Standard_Integer& IndexStrip,
AdvApp2Var_Iso& anIso) const
Handle(AdvApp2Var_Iso) AdvApp2Var_Framework::FirstNotApprox(Standard_Integer& IndexIso,
Standard_Integer& IndexStrip) const
{
Standard_Boolean good = Standard_True;
Standard_Integer i,j;
AdvApp2Var_Strip S;
for (i = 1; i <= myUConstraints.Length() && good ; i++) {
S = myUConstraints.Value(i);
for (j = 1; j <= S.Length() && good ; j++) {
good = (S.Value(j)).IsApproximated();
if (!good) {
IndexIso = j;
IndexStrip = i;
anIso = S.Value(j);
for (int anUVIter = 0; anUVIter < 2; ++anUVIter)
{
const AdvApp2Var_SequenceOfStrip& aSeq = anUVIter == 0 ? myUConstraints : myVConstraints;
Standard_Integer i = 1;
for (AdvApp2Var_SequenceOfStrip::Iterator aConstIter (aSeq); aConstIter.More(); aConstIter.Next(), i++)
{
const AdvApp2Var_Strip& S = aConstIter.Value();
Standard_Integer j = 1;
for (AdvApp2Var_Strip::Iterator anIsoIter (S); anIsoIter.More(); anIsoIter.Next(), j++)
{
const Handle(AdvApp2Var_Iso)& anIso = anIsoIter.Value();
if (!anIso->IsApproximated())
{
IndexIso = j;
IndexStrip = i;
return anIso;
}
}
}
}
if (!good) {
goto FINISH;
}
for (i = 1; i <= myVConstraints.Length() && good; i++) {
S = myVConstraints.Value(i);
for (j = 1; j <= S.Length() && good ; j++) {
good = (S.Value(j)).IsApproximated();
if (!good) {
IndexIso = j;
IndexStrip = i;
anIso = S.Value(j);
}
}
}
FINISH:
return !good;
return Handle(AdvApp2Var_Iso)();
}
//==========================================================================================
@ -145,19 +132,12 @@ Standard_Integer AdvApp2Var_Framework::LastNode(const GeomAbs_IsoType Type,
void AdvApp2Var_Framework::ChangeIso(const Standard_Integer IndexIso,
const Standard_Integer IndexStrip,
const AdvApp2Var_Iso& anIso)
const Handle(AdvApp2Var_Iso)& theIso)
{
AdvApp2Var_Strip S0;
if (anIso.Type()==GeomAbs_IsoV) {
S0 = myUConstraints.Value(IndexStrip);
S0.SetValue(IndexIso,anIso);
myUConstraints.SetValue(IndexStrip,S0);
}
else {
S0 = myVConstraints.Value(IndexStrip);
S0.SetValue(IndexIso,anIso);
myVConstraints.SetValue(IndexStrip,S0);
}
AdvApp2Var_Strip& S0 = theIso->Type() == GeomAbs_IsoV
? myUConstraints.ChangeValue (IndexStrip)
: myVConstraints.ChangeValue (IndexStrip);
S0.SetValue (IndexIso, theIso);
}
//==========================================================================================
@ -165,16 +145,19 @@ void AdvApp2Var_Framework::ChangeIso(const Standard_Integer IndexIso,
//purpose : return the node of coordinates (U,V)
//==========================================================================================
const AdvApp2Var_Node& AdvApp2Var_Framework::Node(const Standard_Real U,
const Handle(AdvApp2Var_Node)& AdvApp2Var_Framework::Node(const Standard_Real U,
const Standard_Real V) const
{
Standard_Integer Index=1;
while ( ( ((myNodeConstraints.Value(Index)).Coord()).X() != U
|| ((myNodeConstraints.Value(Index)).Coord()).Y() != V )
&& (Index<myNodeConstraints.Length()) ) {
Index++;
for (AdvApp2Var_SequenceOfNode::Iterator aNodeIter (myNodeConstraints); aNodeIter.More(); aNodeIter.Next())
{
const Handle(AdvApp2Var_Node)& aNode = aNodeIter.Value();
if (aNode->Coord().X() == U
&& aNode->Coord().Y() == V)
{
return aNode;
}
}
return myNodeConstraints.Value(Index);
return myNodeConstraints.Last();
}
//==========================================================================================
@ -187,17 +170,20 @@ AdvApp2Var_Framework::IsoU(const Standard_Real U,
const Standard_Real V0,
const Standard_Real V1) const
{
Standard_Integer IndexStrip=1,IndexIso=1;
while ( ( ((myVConstraints.Value(IndexStrip)).Value(1)).T0() != V0
|| ((myVConstraints.Value(IndexStrip)).Value(1)).T1() != V1 )
&& (IndexStrip<myVConstraints.Length()) ) {
Standard_Integer IndexStrip = 1;
while (IndexStrip < myVConstraints.Length()
&& (myVConstraints.Value(IndexStrip).First()->T0() != V0
|| myVConstraints.Value(IndexStrip).First()->T1() != V1))
{
IndexStrip++;
}
while ( ( ((myVConstraints.Value(IndexStrip)).Value(IndexIso)).Constante() != U)
&& (IndexIso<=myUConstraints.Length()) ) {
Standard_Integer IndexIso = 1;
while (IndexIso<=myUConstraints.Length()
&& myVConstraints.Value(IndexStrip).Value(IndexIso)->Constante() != U)
{
IndexIso++;
}
return (myVConstraints.Value(IndexStrip)).Value(IndexIso);
return *(myVConstraints.Value(IndexStrip).Value(IndexIso));
}
//==========================================================================================
@ -210,17 +196,20 @@ AdvApp2Var_Framework::IsoV(const Standard_Real U0,
const Standard_Real U1,
const Standard_Real V) const
{
Standard_Integer IndexStrip=1,IndexIso=1;
while ( ( ((myUConstraints.Value(IndexStrip)).Value(1)).T0() != U0
|| ((myUConstraints.Value(IndexStrip)).Value(1)).T1() != U1 )
&& (IndexStrip<myUConstraints.Length()) ) {
Standard_Integer IndexStrip = 1;
while (IndexStrip < myUConstraints.Length()
&& (myUConstraints.Value(IndexStrip).First()->T0() != U0
|| myUConstraints.Value(IndexStrip).First()->T1() != U1))
{
IndexStrip++;
}
while ( ( ((myUConstraints.Value(IndexStrip)).Value(IndexIso)).Constante() != V)
&& (IndexIso<=myVConstraints.Length()) ) {
Standard_Integer IndexIso = 1;
while (IndexIso<=myVConstraints.Length()
&& myUConstraints.Value(IndexStrip).Value(IndexIso)->Constante() != V)
{
IndexIso++;
}
return (myUConstraints.Value(IndexStrip)).Value(IndexIso);
return *(myUConstraints.Value(IndexStrip).Value(IndexIso));
}
//==========================================================================================
@ -230,65 +219,74 @@ AdvApp2Var_Framework::IsoV(const Standard_Real U0,
void AdvApp2Var_Framework::UpdateInU(const Standard_Real CuttingValue)
{
Standard_Integer i=1,j;
while (((myUConstraints.Value(i)).Value(1)).U0()>CuttingValue
|| ((myUConstraints.Value(i)).Value(1)).U1()<CuttingValue) {
i++;
Standard_Integer i = 1;
for (AdvApp2Var_SequenceOfStrip::Iterator anUConstIter (myUConstraints); anUConstIter.More(); anUConstIter.Next(), ++i)
{
if (anUConstIter.Value().First()->U0() <= CuttingValue
&& anUConstIter.Value().First()->U1() >= CuttingValue)
{
break;
}
}
AdvApp2Var_Strip S0;
AdvApp2Var_Iso Is;
S0 = myUConstraints.Value(i);
Standard_Real Udeb = (S0.Value(1)).U0(), Ufin = (S0.Value(1)).U1();
// modification des Isos V de la bande en U d'indice i
for (j=1;j<=S0.Length();j++) {
Is = S0.Value(j);
Is.ChangeDomain(Udeb,CuttingValue);
Is.ResetApprox();
S0.SetValue(j,Is);
}
myUConstraints.SetValue(i,S0);
{
const AdvApp2Var_Strip& S0 = myUConstraints.Value(i);
const Standard_Real Udeb = S0.First()->U0(), Ufin = S0.First()->U1();
// insertion d'une nouvelle bande en U apres l'indice i
AdvApp2Var_Strip NewStrip;
for (j=1;j<=S0.Length();j++) {
AdvApp2Var_Iso NewIso((S0.Value(j)).Type(),(S0.Value(j)).Constante(),
CuttingValue,Ufin,(S0.Value(j)).V0(),(S0.Value(j)).V1(),
0,(S0.Value(j)).UOrder(),(S0.Value(j)).VOrder());
NewIso.ResetApprox();
NewStrip.Append(NewIso);
// modification des Isos V de la bande en U d'indice i
for (AdvApp2Var_Strip::Iterator aStripIter (S0); aStripIter.More(); aStripIter.Next())
{
const Handle(AdvApp2Var_Iso)& anIso = aStripIter.Value();
anIso->ChangeDomain (Udeb, CuttingValue);
anIso->ResetApprox();
}
// insertion d'une nouvelle bande en U apres l'indice i
AdvApp2Var_Strip aNewStrip;
for (AdvApp2Var_Strip::Iterator aStripIter (S0); aStripIter.More(); aStripIter.Next())
{
const Handle(AdvApp2Var_Iso)& anIso = aStripIter.Value();
Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), anIso->Constante(),
CuttingValue, Ufin, anIso->V0(), anIso->V1(),
0, anIso->UOrder(), anIso->VOrder());
aNewIso->ResetApprox();
aNewStrip.Append (aNewIso);
}
myUConstraints.InsertAfter (i, aNewStrip);
}
myUConstraints.InsertAfter(i,NewStrip);
// insertion d'une nouvelle Iso U=U* dans chaque bande en V apres l'indice i
// et restriction des paves des Isos adjacentes
for (j=1;j<=myVConstraints.Length();j++) {
S0 = myVConstraints.Value(j);
Is = S0.Value(i);
Is.ChangeDomain(Is.U0(),CuttingValue,Is.V0(),Is.V1());
S0.SetValue(i,Is);
AdvApp2Var_Iso NewIso(Is.Type(),CuttingValue,Is.U0(),CuttingValue,Is.V0(),Is.V1(),
0,Is.UOrder(),Is.VOrder());
NewIso.ResetApprox();
S0.InsertAfter(i,NewIso);
Is = S0.Value(i+2);
Is.ChangeDomain(CuttingValue,Is.U1(),Is.V0(),Is.V1());
S0.SetValue(i+2,Is);
myVConstraints.SetValue(j,S0);
for (Standard_Integer j = 1; j <= myVConstraints.Length(); j++)
{
AdvApp2Var_Strip& S0 = myVConstraints.ChangeValue(j);
Handle(AdvApp2Var_Iso) anIso = S0.Value(i);
anIso->ChangeDomain (anIso->U0(), CuttingValue, anIso->V0(), anIso->V1());
Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), CuttingValue, anIso->U0(), CuttingValue, anIso->V0(), anIso->V1(),
0, anIso->UOrder(), anIso->VOrder());
aNewIso->ResetApprox();
S0.InsertAfter (i, aNewIso);
anIso = S0.Value(i+2);
anIso->ChangeDomain (CuttingValue, anIso->U1(), anIso->V0(), anIso->V1());
}
// insertion des nouveaux noeuds (U*,Vj)
AdvApp2Var_Node Prev, Next;
Prev=myNodeConstraints.Value(1);
for (j=1;j<myNodeConstraints.Length();j++) {
Next=myNodeConstraints.Value(j+1);
if ((Prev.Coord()).X()<CuttingValue && ((Next.Coord()).X()>CuttingValue)
&& ((Prev.Coord()).Y()==(Next.Coord()).Y())) {
gp_XY NewUV(CuttingValue,(Prev.Coord()).Y());
AdvApp2Var_Node NewNode(NewUV,Prev.UOrder(),Prev.VOrder());
myNodeConstraints.InsertAfter(j,NewNode);
Handle(AdvApp2Var_Node) aNext;
Handle(AdvApp2Var_Node) aPrev = myNodeConstraints.First();
for (Standard_Integer j = 1; j < myNodeConstraints.Length(); j++)
{
aNext = myNodeConstraints.Value(j+1);
if (aPrev->Coord().X() < CuttingValue
&& aNext->Coord().X() > CuttingValue
&& aPrev->Coord().Y() == aNext->Coord().Y())
{
gp_XY aNewUV (CuttingValue, aPrev->Coord().Y());
Handle(AdvApp2Var_Node) aNewNode = new AdvApp2Var_Node (aNewUV, aPrev->UOrder(), aPrev->VOrder());
myNodeConstraints.InsertAfter (j, aNewNode);
}
Prev=Next;
aPrev = aNext;
}
}
@ -299,65 +297,69 @@ void AdvApp2Var_Framework::UpdateInU(const Standard_Real CuttingValue)
void AdvApp2Var_Framework::UpdateInV(const Standard_Real CuttingValue)
{
Standard_Integer i,j=1;
while (((myVConstraints.Value(j)).Value(1)).V0()>CuttingValue
|| ((myVConstraints.Value(j)).Value(1)).V1()<CuttingValue) {
Standard_Integer j=1;
while (myVConstraints.Value(j).First()->V0() > CuttingValue
|| myVConstraints.Value(j).First()->V1() < CuttingValue)
{
j++;
}
AdvApp2Var_Strip S0;
AdvApp2Var_Iso Is;
S0 = myVConstraints.Value(j);
Standard_Real Vdeb = (S0.Value(1)).V0(), Vfin = (S0.Value(1)).V1();
// modification des Isos U de la bande en V d'indice j
for (i=1;i<=S0.Length();i++) {
Is = S0.Value(i);
Is.ChangeDomain(Vdeb,CuttingValue);
Is.ResetApprox();
S0.SetValue(i,Is);
{
AdvApp2Var_Strip& S0 = myVConstraints.ChangeValue(j);
const Standard_Real Vdeb = S0.First()->V0(), Vfin = S0.First()->V1();
// modification des Isos U de la bande en V d'indice j
for (AdvApp2Var_Strip::Iterator anIsoIter (S0); anIsoIter.More(); anIsoIter.Next())
{
const Handle(AdvApp2Var_Iso)& anIso = anIsoIter.Value();
anIso->ChangeDomain (Vdeb, CuttingValue);
anIso->ResetApprox();
}
// insertion d'une nouvelle bande en V apres l'indice j
AdvApp2Var_Strip aNewStrip;
for (AdvApp2Var_Strip::Iterator anIsoIter (S0); anIsoIter.More(); anIsoIter.Next())
{
const Handle(AdvApp2Var_Iso)& anIso = anIsoIter.Value();
Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), anIso->Constante(),
anIso->U0(), anIso->U1(), CuttingValue, Vfin,
0, anIso->UOrder(), anIso->VOrder());
aNewIso->ResetApprox();
aNewStrip.Append (aNewIso);
}
myVConstraints.InsertAfter(j, aNewStrip);
}
myVConstraints.SetValue(j,S0);
// insertion d'une nouvelle bande en V apres l'indice j
AdvApp2Var_Strip NewStrip;
for (i=1;i<=S0.Length();i++) {
AdvApp2Var_Iso NewIso((S0.Value(i)).Type(),(S0.Value(i)).Constante(),
(S0.Value(i)).U0(),(S0.Value(i)).U1(),CuttingValue,Vfin,
0,(S0.Value(i)).UOrder(),(S0.Value(i)).VOrder());
NewIso.ResetApprox();
NewStrip.Append(NewIso);
}
myVConstraints.InsertAfter(j,NewStrip);
// insertion d'une nouvelle Iso V=V* dans chaque bande en U apres l'indice j
// et restriction des paves des Isos adjacentes
for (AdvApp2Var_SequenceOfStrip::Iterator anUConstIter (myUConstraints); anUConstIter.More(); anUConstIter.Next())
{
AdvApp2Var_Strip& S0 = anUConstIter.ChangeValue();
Handle(AdvApp2Var_Iso) anIso = S0.Value(j);
anIso->ChangeDomain (anIso->U0(), anIso->U1(), anIso->V0(), CuttingValue);
// insertion d'une nouvelle Iso V=V* dans chaque bande en U apres l'indice j
// et restriction des paves des Isos adjacentes
for (i=1;i<=myUConstraints.Length();i++) {
S0 = myUConstraints.Value(i);
Is = S0.Value(j);
Is.ChangeDomain(Is.U0(),Is.U1(),Is.V0(),CuttingValue);
S0.SetValue(j,Is);
AdvApp2Var_Iso NewIso(Is.Type(),CuttingValue,Is.U0(),Is.U1(),Is.V0(),CuttingValue,
0,Is.UOrder(),Is.VOrder());
NewIso.ResetApprox();
S0.InsertAfter(j,NewIso);
Is = S0.Value(j+2);
Is.ChangeDomain(Is.U0(),Is.U1(),CuttingValue,Is.V1());
S0.SetValue(j+2,Is);
myUConstraints.SetValue(i,S0);
Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), CuttingValue, anIso->U0(), anIso->U1(), anIso->V0(), CuttingValue,
0, anIso->UOrder(), anIso->VOrder());
aNewIso->ResetApprox();
S0.InsertAfter (j, aNewIso);
anIso = S0.Value (j + 2);
anIso->ChangeDomain (anIso->U0(), anIso->U1(), CuttingValue, anIso->V1());
}
// insertion des nouveaux noeuds (Ui,V*)
i = 1;
while ( i<=myNodeConstraints.Length()
&& ( ((myNodeConstraints.Value(i)).Coord()).Y()) < CuttingValue) {
i+=myUConstraints.Length()+1;
Standard_Integer i = 1;
while (i <= myNodeConstraints.Length()
&& myNodeConstraints.Value(i)->Coord().Y() < CuttingValue)
{
i += myUConstraints.Length() + 1;
}
for (j=1;j<=myUConstraints.Length()+1;j++) {
gp_XY NewUV(((myNodeConstraints.Value(j)).Coord()).X(),CuttingValue);
AdvApp2Var_Node NewNode(NewUV,
(myNodeConstraints.Value(j)).UOrder(),
(myNodeConstraints.Value(j)).VOrder());
myNodeConstraints.InsertAfter(i+j-2,NewNode);
for (j = 1; j <= myUConstraints.Length() + 1; j++)
{
const Handle(AdvApp2Var_Node)& aJNode = myNodeConstraints.Value(j);
gp_XY NewUV (aJNode->Coord().X(), CuttingValue);
Handle(AdvApp2Var_Node) aNewNode = new AdvApp2Var_Node (NewUV, aJNode->UOrder(), aJNode->VOrder());
myNodeConstraints.InsertAfter (i+j-2, aNewNode);
}
}
@ -370,7 +372,7 @@ const Handle(TColStd_HArray1OfReal)&
AdvApp2Var_Framework::UEquation(const Standard_Integer IndexIso,
const Standard_Integer IndexStrip) const
{
return ((myVConstraints.Value(IndexStrip)).Value(IndexIso)).Polynom();
return myVConstraints.Value(IndexStrip).Value(IndexIso)->Polynom();
}
//==========================================================================================
@ -382,6 +384,6 @@ const Handle(TColStd_HArray1OfReal)&
AdvApp2Var_Framework::VEquation(const Standard_Integer IndexIso,
const Standard_Integer IndexStrip) const
{
return myUConstraints.Value(IndexStrip).Value(IndexIso).Polynom();
return myUConstraints.Value(IndexStrip).Value(IndexIso)->Polynom();
}

33
src/AdvApp2Var/AdvApp2Var_Framework.hxx
View File

@ -44,27 +44,25 @@ public:
Standard_EXPORT AdvApp2Var_Framework();
Standard_EXPORT AdvApp2Var_Framework(const AdvApp2Var_SequenceOfNode& Frame, const AdvApp2Var_SequenceOfStrip& UFrontier, const AdvApp2Var_SequenceOfStrip& VFrontier);
//! search the Index of the first Iso not approximated,
//! if all Isos are approximated Standard_False is returned.
Standard_EXPORT Standard_Boolean FirstNotApprox (Standard_Integer& IndexIso, Standard_Integer& IndexStrip, AdvApp2Var_Iso& anIso) const;
//! if all Isos are approximated NULL is returned.
Standard_EXPORT Handle(AdvApp2Var_Iso) FirstNotApprox (Standard_Integer& IndexIso, Standard_Integer& IndexStrip) const;
Standard_EXPORT Standard_Integer FirstNode (const GeomAbs_IsoType Type, const Standard_Integer IndexIso, const Standard_Integer IndexStrip) const;
Standard_EXPORT Standard_Integer LastNode (const GeomAbs_IsoType Type, const Standard_Integer IndexIso, const Standard_Integer IndexStrip) const;
Standard_EXPORT void ChangeIso (const Standard_Integer IndexIso, const Standard_Integer IndexStrip, const AdvApp2Var_Iso& anIso);
Standard_EXPORT void ChangeIso (const Standard_Integer IndexIso, const Standard_Integer IndexStrip, const Handle(AdvApp2Var_Iso)& anIso);
const AdvApp2Var_Node& Node (const Standard_Integer IndexNode) const;
const Handle(AdvApp2Var_Node)& Node (const Standard_Integer IndexNode) const { return myNodeConstraints.Value(IndexNode); }
Standard_EXPORT const AdvApp2Var_Node& Node (const Standard_Real U, const Standard_Real V) const;
Standard_EXPORT const Handle(AdvApp2Var_Node)& Node (const Standard_Real U, const Standard_Real V) const;
Standard_EXPORT const AdvApp2Var_Iso& IsoU (const Standard_Real U, const Standard_Real V0, const Standard_Real V1) const;
Standard_EXPORT const AdvApp2Var_Iso& IsoV (const Standard_Real U0, const Standard_Real U1, const Standard_Real V) const;
AdvApp2Var_Node& ChangeNode (const Standard_Integer IndexNode);
Standard_EXPORT void UpdateInU (const Standard_Real CuttingValue);
Standard_EXPORT void UpdateInV (const Standard_Real CuttingValue);
@ -73,31 +71,12 @@ public:
Standard_EXPORT const Handle(TColStd_HArray1OfReal)& VEquation (const Standard_Integer IndexIso, const Standard_Integer IndexStrip) const;
protected:
private:
AdvApp2Var_SequenceOfNode myNodeConstraints;
AdvApp2Var_SequenceOfStrip myUConstraints;
AdvApp2Var_SequenceOfStrip myVConstraints;
};
#include <AdvApp2Var_Framework.lxx>
#endif // _AdvApp2Var_Framework_HeaderFile

27
src/AdvApp2Var/AdvApp2Var_Framework.lxx
View File

@ -1,27 +0,0 @@
// Created on: 1996-06-17
// Created by: Philippe MANGIN
// Copyright (c) 1996-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.
inline const AdvApp2Var_Node& AdvApp2Var_Framework::Node(
const Standard_Integer IndexNode) const
{
return myNodeConstraints.Value(IndexNode);
}
inline AdvApp2Var_Node& AdvApp2Var_Framework::ChangeNode(
const Standard_Integer IndexNode)
{
return myNodeConstraints.ChangeValue(IndexNode);
}

4
src/AdvApp2Var/AdvApp2Var_Iso.cxx
View File

@ -14,16 +14,18 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <AdvApp2Var_Iso.hxx>
#include <AdvApp2Var_ApproxF2var.hxx>
#include <AdvApp2Var_Context.hxx>
#include <AdvApp2Var_Iso.hxx>
#include <AdvApp2Var_Node.hxx>
#include <gp_Pnt.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Iso, Standard_Transient)
//=======================================================================
//function : AdvApp2Var_Iso
//purpose :

29
src/AdvApp2Var/AdvApp2Var_Iso.hxx
View File

@ -31,16 +31,12 @@
class AdvApp2Var_Context;
class AdvApp2Var_Node;
//! used to store constraints on a line U = Ui or V = Vj
class AdvApp2Var_Iso
class AdvApp2Var_Iso : public Standard_Transient
{
DEFINE_STANDARD_RTTIEXT(AdvApp2Var_Iso, Standard_Transient)
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT AdvApp2Var_Iso();
Standard_EXPORT AdvApp2Var_Iso(const GeomAbs_IsoType type, const Standard_Integer iu, const Standard_Integer iv);
@ -99,20 +95,12 @@ public:
Standard_EXPORT Handle(TColStd_HArray2OfReal) MoyErrors() const;
protected:
private:
Standard_EXPORT AdvApp2Var_Iso(const AdvApp2Var_Iso& Other);
AdvApp2Var_Iso(const AdvApp2Var_Iso& Other);
AdvApp2Var_Iso& operator= (const AdvApp2Var_Iso& theOther);
private:
GeomAbs_IsoType myType;
Standard_Real myConstPar;
@ -132,13 +120,6 @@ private:
Handle(TColStd_HArray1OfReal) mySomTab;
Handle(TColStd_HArray1OfReal) myDifTab;
};
#endif // _AdvApp2Var_Iso_HeaderFile

91
src/AdvApp2Var/AdvApp2Var_Network.cxx
View File

@ -52,15 +52,19 @@ AdvApp2Var_Network::AdvApp2Var_Network(const AdvApp2Var_SequenceOfPatch& Net,
//purpose : return the first Patch not approximated
//==========================================================================================
Standard_Boolean AdvApp2Var_Network::FirstNotApprox(Standard_Integer& Index) const
Standard_Boolean AdvApp2Var_Network::FirstNotApprox(Standard_Integer& theIndex) const
{
Standard_Boolean good = Standard_True;
Standard_Integer i;
for (i = 1; i <= myNet.Length() && good; i++) {
good = myNet.Value(i).IsApproximated();
if (!good) {Index = i;}
Standard_Integer anIndex = 1;
for (AdvApp2Var_SequenceOfPatch::Iterator aPatchIter (myNet); aPatchIter.More(); aPatchIter.Next(), ++anIndex)
{
const Handle(AdvApp2Var_Patch)& aPatch = aPatchIter.Value();
if (!aPatch->IsApproximated())
{
theIndex = anIndex;
return true;
}
}
return !good;
return false;
}
//==========================================================================================
@ -78,23 +82,20 @@ void AdvApp2Var_Network::UpdateInU(const Standard_Real CuttingValue)
}
myUParameters.InsertBefore(i,CuttingValue);
Standard_Integer indice;
for (j=1; j< myVParameters.Length() ; j++){
for (j=1; j< myVParameters.Length() ; j++)
{
// modification des patches concernes par la decoupe
AdvApp2Var_Patch Pat;
indice = (myUParameters.Length()-1) * (j-1) + i - 1;
Pat = myNet.Value(indice);
Pat.ChangeDomain(Pat.U0(), CuttingValue, Pat.V0(), Pat.V1());
Pat.ResetApprox();
myNet.SetValue(indice, Pat);
Standard_Integer indice = (myUParameters.Length()-1) * (j-1) + i - 1;
const Handle(AdvApp2Var_Patch)& aPat = myNet.Value(indice);
aPat->ChangeDomain (aPat->U0(), CuttingValue, aPat->V0(), aPat->V1());
aPat->ResetApprox();
// insertion des nouveaux patches
AdvApp2Var_Patch NewPat(CuttingValue,myUParameters.Value(i+1),
Handle(AdvApp2Var_Patch) aNewPat = new AdvApp2Var_Patch (CuttingValue,myUParameters.Value(i+1),
myVParameters.Value(j),myVParameters.Value(j+1),
Pat.UOrder(),Pat.VOrder());
NewPat.ResetApprox();
myNet.InsertAfter(indice, NewPat);
aPat->UOrder(), aPat->VOrder());
aNewPat->ResetApprox();
myNet.InsertAfter(indice, aNewPat);
}
}
@ -108,31 +109,32 @@ void AdvApp2Var_Network::UpdateInV(const Standard_Real CuttingValue)
{
// insertion du nouveau parametre de decoupe
Standard_Integer i,j=1;
AdvApp2Var_Patch Pat;
while (myVParameters.Value(j)<CuttingValue) {
Standard_Integer j = 1;
Handle(AdvApp2Var_Patch) Pat;
while (myVParameters.Value(j)<CuttingValue)
{
j++;
}
myVParameters.InsertBefore(j,CuttingValue);
// modification des patches concernes par la decoupe
Standard_Integer indice;
for (i=1; i< myUParameters.Length() ; i++){
indice = (myUParameters.Length()-1) * (j-2) + i;
for (Standard_Integer i = 1; i < myUParameters.Length(); i++)
{
const Standard_Integer indice = (myUParameters.Length()-1) * (j-2) + i;
Pat = myNet.Value(indice);
Pat.ChangeDomain(Pat.U0(), Pat.U1(), Pat.V0(), CuttingValue);
Pat.ResetApprox();
myNet.SetValue(indice,Pat);
Pat->ChangeDomain(Pat->U0(), Pat->U1(), Pat->V0(), CuttingValue);
Pat->ResetApprox();
}
// insertion des nouveaux patches
for (i=1; i< myUParameters.Length() ; i++){
indice = (myUParameters.Length()-1) * (j-1) + i-1;
AdvApp2Var_Patch NewPat(myUParameters.Value(i), myUParameters.Value(i+1),
for (Standard_Integer i = 1; i < myUParameters.Length(); i++)
{
const Standard_Integer indice = (myUParameters.Length()-1) * (j-1) + i-1;
Handle(AdvApp2Var_Patch) aNewPat = new AdvApp2Var_Patch (myUParameters.Value(i), myUParameters.Value(i+1),
CuttingValue,myVParameters.Value(j+1),
Pat.UOrder(),Pat.VOrder());
NewPat.ResetApprox();
myNet.InsertAfter(indice,NewPat);
Pat->UOrder(),Pat->VOrder());
aNewPat->ResetApprox();
myNet.InsertAfter (indice, aNewPat);
}
}
@ -146,22 +148,21 @@ void AdvApp2Var_Network::SameDegree(const Standard_Integer iu,
Standard_Integer& ncfu,
Standard_Integer& ncfv)
{
// calcul des coeff. max avec init selon l'ordre de continuite
Standard_Integer IndPat;
ncfu = 2*iu+2;
ncfv = 2*iv+2;
for (IndPat=1;IndPat<=myNet.Length();IndPat++) {
ncfu = Max(ncfu,myNet.Value(IndPat).NbCoeffInU());
ncfv = Max(ncfv,myNet.Value(IndPat).NbCoeffInV());
for (AdvApp2Var_SequenceOfPatch::Iterator aPatIter (myNet); aPatIter.More(); aPatIter.Next())
{
const Handle(AdvApp2Var_Patch)& aPat = aPatIter.Value();
ncfu = Max(ncfu, aPat->NbCoeffInU());
ncfv = Max(ncfv, aPat->NbCoeffInV());
}
// augmentation des nombres de coeff.
AdvApp2Var_Patch Pat;
for (IndPat=1;IndPat<=myNet.Length();IndPat++) {
Pat = myNet.Value(IndPat);
Pat.ChangeNbCoeff(ncfu,ncfv);
myNet.SetValue(IndPat,Pat);
for (AdvApp2Var_SequenceOfPatch::Iterator aPatIter (myNet); aPatIter.More(); aPatIter.Next())
{
const Handle(AdvApp2Var_Patch)& aPat = aPatIter.Value();
aPat->ChangeNbCoeff (ncfu, ncfv);
}
}

40
src/AdvApp2Var/AdvApp2Var_Network.hxx
View File

@ -46,11 +46,8 @@ public:
//! if all Patches are approximated Standard_False is returned
Standard_EXPORT Standard_Boolean FirstNotApprox (Standard_Integer& Index) const;
AdvApp2Var_Patch& ChangePatch (const Standard_Integer Index);
AdvApp2Var_Patch& operator() (const Standard_Integer Index)
{
return ChangePatch(Index);
}
AdvApp2Var_Patch& ChangePatch (const Standard_Integer Index) { return *myNet.Value(Index); }
AdvApp2Var_Patch& operator() (const Standard_Integer Index) { return ChangePatch(Index); }
Standard_EXPORT void UpdateInU (const Standard_Real CuttingValue);
@ -67,38 +64,23 @@ public:
Standard_EXPORT Standard_Real UParameter (const Standard_Integer Index) const;
Standard_EXPORT Standard_Real VParameter (const Standard_Integer Index) const;
const AdvApp2Var_Patch& Patch (const Standard_Integer UIndex, const Standard_Integer VIndex) const;
const AdvApp2Var_Patch& Patch (const Standard_Integer UIndex, const Standard_Integer VIndex) const
{
return *myNet.Value ((VIndex-1)*(myUParameters.Length()-1) + UIndex);
}
const AdvApp2Var_Patch& operator() (const Standard_Integer UIndex, const Standard_Integer VIndex) const
{
return Patch(UIndex,VIndex);
}
protected:
{
return Patch(UIndex,VIndex);
}
private:
AdvApp2Var_SequenceOfPatch myNet;
TColStd_SequenceOfReal myUParameters;
TColStd_SequenceOfReal myVParameters;
};
#include <AdvApp2Var_Network.lxx>
#endif // _AdvApp2Var_Network_HeaderFile

29
src/AdvApp2Var/AdvApp2Var_Network.lxx
View File

@ -1,29 +0,0 @@
// Created on: 1996-06-13
// Created by: Philippe MANGIN
// Copyright (c) 1996-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 <TColStd_HArray1OfReal.hxx>
inline AdvApp2Var_Patch& AdvApp2Var_Network::ChangePatch(const Standard_Integer Index)
{
return myNet(Index);
}
inline const AdvApp2Var_Patch& AdvApp2Var_Network::Patch(const Standard_Integer UIndex,
const Standard_Integer VIndex) const
{
return myNet( (VIndex-1)*(myUParameters.Length()-1) + UIndex);
}

155
src/AdvApp2Var/AdvApp2Var_Node.cxx
View File

@ -14,26 +14,23 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <AdvApp2Var_Node.hxx>
#include <gp_Pnt.hxx>
#include <gp_XY.hxx>
#include <TColgp_HArray2OfPnt.hxx>
#include <TColStd_HArray2OfReal.hxx>
IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Node, Standard_Transient)
//=======================================================================
//function : AdvApp2Var_Node
//purpose :
//=======================================================================
AdvApp2Var_Node::AdvApp2Var_Node() :
myOrdInU(2),
myOrdInV(2)
AdvApp2Var_Node::AdvApp2Var_Node()
: myTruePoints(0, 2, 0, 2),
myErrors (0, 2, 0, 2),
myOrdInU (2),
myOrdInV (2)
{
myTruePoints = new TColgp_HArray2OfPnt ( 0, 2, 0, 2);
gp_Pnt P0(0.,0.,0.);
myTruePoints->Init(P0);
myErrors = new TColStd_HArray2OfReal( 0, 2, 0, 2);
myErrors->Init(0.);
myTruePoints.Init(P0);
myErrors.Init(0.);
}
//=======================================================================
@ -42,15 +39,15 @@ myOrdInV(2)
//=======================================================================
AdvApp2Var_Node::AdvApp2Var_Node(const Standard_Integer iu,
const Standard_Integer iv) :
myOrdInU(iu),
myOrdInV(iv)
const Standard_Integer iv)
: myTruePoints(0, Max(0,iu), 0, Max(0,iv)),
myErrors (0, Max(0,iu), 0, Max(0,iv)),
myOrdInU (iu),
myOrdInV (iv)
{
myTruePoints = new TColgp_HArray2OfPnt ( 0, Max(0,iu), 0, Max(0,iv));
gp_Pnt P0(0.,0.,0.);
myTruePoints->Init(P0);
myErrors = new TColStd_HArray2OfReal( 0, Max(0,iu), 0, Max(0,iv));
myErrors->Init(0.);
myTruePoints.Init(P0);
myErrors.Init(0.);
}
//=======================================================================
@ -60,118 +57,14 @@ myOrdInV(iv)
AdvApp2Var_Node::AdvApp2Var_Node(const gp_XY& UV,
const Standard_Integer iu,
const Standard_Integer iv) :
myCoord(UV),
myOrdInU(iu),
myOrdInV(iv)
const Standard_Integer iv)
: myTruePoints(0, iu, 0, iv),
myErrors (0, iu, 0, iv),
myCoord (UV),
myOrdInU(iu),
myOrdInV(iv)
{
myTruePoints = new TColgp_HArray2OfPnt ( 0, iu, 0, iv);
gp_Pnt P0(0.,0.,0.);
myTruePoints->Init(P0);
myErrors = new TColStd_HArray2OfReal( 0, iu, 0, iv);
myErrors->Init(0.);
myTruePoints.Init(P0);
myErrors.Init(0.);
}
//=======================================================================
//function : Coord
//purpose : returns the coordinates (U,V) of the node
//=======================================================================
gp_XY AdvApp2Var_Node::Coord() const
{
return myCoord;
}
//=======================================================================
//function : SetCoord
//purpose : changes the coordinates (U,V) to (x1,x2)
//=======================================================================
void AdvApp2Var_Node::SetCoord(const Standard_Real x1,
const Standard_Real x2)
{
myCoord.SetX(x1);
myCoord.SetY(x2);
}
//=======================================================================
//function : UOrder
//purpose : returns the continuity order in U of the node
//=======================================================================
Standard_Integer AdvApp2Var_Node::UOrder() const
{
return myOrdInU;
}
//=======================================================================
//function : VOrder
//purpose : returns the continuity order in V of the node
//=======================================================================
Standard_Integer AdvApp2Var_Node::VOrder() const
{
return myOrdInV;
}
//=======================================================================
//function : SetPoint
//purpose : affects the value F(U,V) or its derivates on the node (U,V)
//=======================================================================
void AdvApp2Var_Node::SetPoint(const Standard_Integer iu,
const Standard_Integer iv,
const gp_Pnt& Pt)
{
myTruePoints->SetValue(iu, iv, Pt);
}
//=======================================================================
//function : Point
//purpose : returns the value F(U,V) or its derivates on the node (U,V)
//=======================================================================
gp_Pnt AdvApp2Var_Node::Point(const Standard_Integer iu,
const Standard_Integer iv) const
{
return myTruePoints->Value(iu, iv);
}
//=======================================================================
//function : SetError
//purpose : affects the error between F(U,V) and its approximation
//=======================================================================
void AdvApp2Var_Node::SetError(const Standard_Integer iu,
const Standard_Integer iv,
const Standard_Real error)
{
myErrors->SetValue(iu, iv, error);
}
//=======================================================================
//function : Error
//purpose : returns the error between F(U,V) and its approximation
//=======================================================================
Standard_Real AdvApp2Var_Node::Error(const Standard_Integer iu,
const Standard_Integer iv) const
{
return myErrors->Value(iu, iv);
}

95
src/AdvApp2Var/AdvApp2Var_Node.hxx
View File

@ -17,78 +17,85 @@
#ifndef _AdvApp2Var_Node_HeaderFile
#define _AdvApp2Var_Node_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <gp_XY.hxx>
#include <Standard_Integer.hxx>
#include <TColgp_HArray2OfPnt.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <Standard_Real.hxx>
class gp_XY;
class gp_Pnt;
#include <Standard.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Type.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TColStd_Array2OfReal.hxx>
//! used to store constraints on a (Ui,Vj) point
class AdvApp2Var_Node
class AdvApp2Var_Node : public Standard_Transient
{
DEFINE_STANDARD_RTTIEXT(AdvApp2Var_Node, Standard_Transient)
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT AdvApp2Var_Node();
Standard_EXPORT AdvApp2Var_Node(const Standard_Integer iu, const Standard_Integer iv);
Standard_EXPORT AdvApp2Var_Node(const gp_XY& UV, const Standard_Integer iu, const Standard_Integer iv);
Standard_EXPORT gp_XY Coord() const;
Standard_EXPORT void SetCoord (const Standard_Real x1, const Standard_Real x2);
Standard_EXPORT Standard_Integer UOrder() const;
Standard_EXPORT Standard_Integer VOrder() const;
Standard_EXPORT void SetPoint (const Standard_Integer iu, const Standard_Integer iv, const gp_Pnt& Cte);
Standard_EXPORT gp_Pnt Point (const Standard_Integer iu, const Standard_Integer iv) const;
Standard_EXPORT void SetError (const Standard_Integer iu, const Standard_Integer iv, const Standard_Real error);
Standard_EXPORT Standard_Real Error (const Standard_Integer iu, const Standard_Integer iv) const;
//! Returns the coordinates (U,V) of the node
const gp_XY& Coord() const { return myCoord; }
//! changes the coordinates (U,V) to (x1,x2)
void SetCoord (const Standard_Real x1, const Standard_Real x2)
{
myCoord.SetX(x1);
myCoord.SetY(x2);
}
//! returns the continuity order in U of the node
Standard_Integer UOrder() const { return myOrdInU; }
protected:
//! returns the continuity order in V of the node
Standard_Integer VOrder() const { return myOrdInV; }
//! affects the value F(U,V) or its derivates on the node (U,V)
void SetPoint (const Standard_Integer iu, const Standard_Integer iv, const gp_Pnt& Pt)
{
myTruePoints.SetValue(iu, iv, Pt);
}
//! returns the value F(U,V) or its derivates on the node (U,V)
const gp_Pnt& Point (const Standard_Integer iu, const Standard_Integer iv) const
{
return myTruePoints.Value(iu, iv);
}
//! affects the error between F(U,V) and its approximation
void SetError (const Standard_Integer iu, const Standard_Integer iv, const Standard_Real error)
{
myErrors.SetValue(iu, iv, error);
}
//! returns the error between F(U,V) and its approximation
Standard_Real Error (const Standard_Integer iu, const Standard_Integer iv) const { return myErrors.Value(iu, iv); }
//! Assign operator.
AdvApp2Var_Node& operator= (const AdvApp2Var_Node& theOther)
{
myTruePoints = theOther.myTruePoints;
myErrors = theOther.myErrors;
myCoord = theOther.myCoord;
myOrdInU = theOther.myOrdInU;
myOrdInV = theOther.myOrdInV;
return *this;
}
private:
Standard_EXPORT AdvApp2Var_Node(const AdvApp2Var_Node& Other);
AdvApp2Var_Node (const AdvApp2Var_Node& theOther);
private:
TColgp_Array2OfPnt myTruePoints;
TColStd_Array2OfReal myErrors;
gp_XY myCoord;
Standard_Integer myOrdInU;
Standard_Integer myOrdInV;
Handle(TColgp_HArray2OfPnt) myTruePoints;
Handle(TColStd_HArray2OfReal) myErrors;
};
#endif // _AdvApp2Var_Node_HeaderFile

58
src/AdvApp2Var/AdvApp2Var_Patch.cxx
View File

@ -40,6 +40,8 @@
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
//============================================================================
//function : AdvApp2Var_Patch
//purpose :
@ -144,35 +146,35 @@ void AdvApp2Var_Patch::Discretise(const AdvApp2Var_Context& Conditions,
rho = pow(du,iu)*pow(dv,iv);
// F(U0,V0) and its derivatives normalized on (-1,1)
valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).X();
valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
HCOINS->SetValue( 1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv , valnorm );
valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Y();
valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
HCOINS->SetValue( 2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Z();
valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
HCOINS->SetValue( 3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
// F(U1,V0) and its derivatives normalized on (-1,1)
valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).X();
valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
HCOINS->SetValue( SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Y();
valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
HCOINS->SetValue( SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Z();
valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
HCOINS->SetValue( SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
// F(U0,V1) and its derivatives normalized on (-1,1)
valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).X();
valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
HCOINS->SetValue( 2*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Y();
valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
HCOINS->SetValue( 2*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Z();
valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
HCOINS->SetValue( 2*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
// F(U1,V1) and its derivatives normalized on (-1,1)
valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).X();
valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
HCOINS->SetValue( 3*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Y();
valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
HCOINS->SetValue( 3*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Z();
valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
HCOINS->SetValue( 3*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
}
}
@ -543,38 +545,38 @@ void AdvApp2Var_Patch::AddConstraints(const AdvApp2Var_Context& Conditions,
// -F(U0,V0) and its derivatives normalized on (-1,1)
ideb = HCOINS->Lower() + NDIMEN*iu+NDIMEN*(IORDRU+2)*iv - 1;
valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).X();
valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
HCOINS->SetValue( 1+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Y();
valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
HCOINS->SetValue( 2+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Z();
valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
HCOINS->SetValue( 3+ideb , valnorm );
// -F(U1,V0) and its derivatives normalized on (-1,1)
ideb += SIZE;
valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).X();
valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
HCOINS->SetValue( 1+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Y();
valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
HCOINS->SetValue( 2+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Z();
valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
HCOINS->SetValue( 3+ideb , valnorm );
// -F(U0,V1) and its derivatives normalized on (-1,1)
ideb += SIZE;
valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).X();
valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
HCOINS->SetValue( 1+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Y();
valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
HCOINS->SetValue( 2+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Z();
valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
HCOINS->SetValue( 3+ideb , valnorm );
// -F(U1,V1) and its derivatives normalized on (-1,1)
ideb += SIZE;
valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).X();
valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
HCOINS->SetValue( 1+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Y();
valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
HCOINS->SetValue( 2+ideb , valnorm );
valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Z();
valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
HCOINS->SetValue( 3+ideb , valnorm );
}
}
@ -721,13 +723,13 @@ void AdvApp2Var_Patch::AddErrors(const AdvApp2Var_Framework& Constraints)
Standard_Real emax1=0.,emax2=0.,emax3=0.,emax4=0.,err1,err2,err3,err4;
for (iu=0;iu<=myOrdInU;iu++) {
for (iv=0;iv<=myOrdInV;iv++) {
error = (Constraints.Node(myU0,myV0)).Error(iu,iv);
error = (Constraints.Node(myU0,myV0))->Error(iu,iv);
emax1 = Max(emax1,error);
error = (Constraints.Node(myU1,myV0)).Error(iu,iv);
error = (Constraints.Node(myU1,myV0))->Error(iu,iv);
emax2 = Max(emax2,error);
error = (Constraints.Node(myU0,myV1)).Error(iu,iv);
error = (Constraints.Node(myU0,myV1))->Error(iu,iv);
emax3 = Max(emax3,error);
error = (Constraints.Node(myU1,myV1)).Error(iu,iv);
error = (Constraints.Node(myU1,myV1))->Error(iu,iv);
emax4 = Max(emax4,error);
}
}

20
src/AdvApp2Var/AdvApp2Var_Patch.hxx
View File

@ -35,12 +35,10 @@ class AdvApp2Var_Criterion;
//! used to store results on a domain [Ui,Ui+1]x[Vj,Vj+1]
class AdvApp2Var_Patch
class AdvApp2Var_Patch : public Standard_Transient
{
DEFINE_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT AdvApp2Var_Patch();
@ -102,20 +100,12 @@ public:
Standard_EXPORT void SetCritValue (const Standard_Real dist);
protected:
private:
Standard_EXPORT AdvApp2Var_Patch(const AdvApp2Var_Patch& P);
AdvApp2Var_Patch(const AdvApp2Var_Patch& P);
AdvApp2Var_Patch& operator= (const AdvApp2Var_Patch& theOther);
private:
Standard_Real myU0;
Standard_Real myU1;

3
src/AdvApp2Var/AdvApp2Var_SequenceOfNode.hxx
View File

@ -20,7 +20,6 @@
#include <AdvApp2Var_Node.hxx>
#include <NCollection_Sequence.hxx>
typedef NCollection_Sequence<AdvApp2Var_Node> AdvApp2Var_SequenceOfNode;
typedef NCollection_Sequence<Handle(AdvApp2Var_Node)> AdvApp2Var_SequenceOfNode;
#endif

2
src/AdvApp2Var/AdvApp2Var_SequenceOfPatch.hxx
View File

@ -20,7 +20,7 @@
#include <AdvApp2Var_Patch.hxx>
#include <NCollection_Sequence.hxx>
typedef NCollection_Sequence<AdvApp2Var_Patch> AdvApp2Var_SequenceOfPatch;
typedef NCollection_Sequence<Handle(AdvApp2Var_Patch)> AdvApp2Var_SequenceOfPatch;
#endif

2
src/AdvApp2Var/AdvApp2Var_Strip.hxx
View File

@ -22,6 +22,6 @@
//! Set of constraints along a same type of Iso on the same level
typedef NCollection_Sequence<AdvApp2Var_Iso> AdvApp2Var_Strip;
typedef NCollection_Sequence<Handle(AdvApp2Var_Iso)> AdvApp2Var_Strip;
#endif

2
src/AdvApp2Var/FILES
View File

@ -22,7 +22,6 @@ AdvApp2Var_Data_f2c.hxx
AdvApp2Var_EvaluatorFunc2Var.hxx
AdvApp2Var_Framework.cxx
AdvApp2Var_Framework.hxx
AdvApp2Var_Framework.lxx
AdvApp2Var_Iso.cxx
AdvApp2Var_Iso.hxx
AdvApp2Var_MathBase.cxx
@ -30,7 +29,6 @@ AdvApp2Var_MathBase.hxx
AdvApp2Var_MathBase_mathinit.cxx
AdvApp2Var_Network.cxx
AdvApp2Var_Network.hxx
AdvApp2Var_Network.lxx
AdvApp2Var_Node.cxx
AdvApp2Var_Node.hxx
AdvApp2Var_Patch.cxx

19
src/BOPTools/BOPTools_Set.cxx
View File

@ -51,6 +51,25 @@ BOPTools_Set::BOPTools_Set
mySum=0;
myUpper=432123;
}
//=======================================================================
//function : BOPTools_Set
//purpose :
//=======================================================================
BOPTools_Set::BOPTools_Set (const BOPTools_Set& theOther)
: myAllocator(theOther.myAllocator),
myShape (theOther.myShape),
myNbShapes (theOther.myNbShapes),
mySum (theOther.mySum),
myUpper (theOther.myUpper)
{
for (TopTools_ListIteratorOfListOfShape aIt (theOther.myShapes); aIt.More(); aIt.Next())
{
const TopoDS_Shape& aShape = aIt.Value();
myShapes.Append (aShape);
}
}
//=======================================================================
//function :~
//purpose :

5
src/BOPTools/BOPTools_Set.hxx
View File

@ -40,7 +40,10 @@ public:
Standard_EXPORT virtual ~BOPTools_Set();
Standard_EXPORT BOPTools_Set(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Copy constructor.
Standard_EXPORT BOPTools_Set (const BOPTools_Set& theOther);
Standard_EXPORT BOPTools_Set& Assign (const BOPTools_Set& Other);
BOPTools_Set& operator = (const BOPTools_Set& Other)
{

6
src/BVH/BVH_Box.hxx
View File

@ -118,12 +118,6 @@ public:
myMaxPoint (thePoint),
myIsInited (Standard_True) {}
//! Creates copy of another bounding box.
BVH_Box (const BVH_Box& theBox)
: myMinPoint (theBox.myMinPoint),
myMaxPoint (theBox.myMaxPoint),
myIsInited (theBox.myIsInited) {}
//! Creates bounding box from corner points.
BVH_Box (const BVH_VecNt& theMinPoint,
const BVH_VecNt& theMaxPoint)

10
src/Geom2dHatch/Geom2dHatch_Element.cxx
View File

@ -14,17 +14,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// Function : Geom2dHatch_Element
// Purpose : Magic Constructor.
//=======================================================================
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dHatch_Element.hxx>
Geom2dHatch_Element::Geom2dHatch_Element (const Geom2dHatch_Element& Other)
: myCurve(Other.myCurve), myOrientation(Other.myOrientation) {
}
#include <Geom2dAdaptor_Curve.hxx>
//=======================================================================
// Function : Geom2dHatch_Element

5
src/Geom2dHatch/Geom2dHatch_Element.hxx
View File

@ -35,10 +35,7 @@ public:
Standard_EXPORT Geom2dHatch_Element();
//! Magic constructor.
Standard_EXPORT Geom2dHatch_Element(const Geom2dHatch_Element& Other);
//! Creates an element.
Standard_EXPORT Geom2dHatch_Element(const Geom2dAdaptor_Curve& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD);

10
src/Graphic3d/Graphic3d_CubeMapOrder.hxx
View File

@ -138,6 +138,10 @@ public:
return &Order;
}
//! Copy constructor.
Graphic3d_ValidatedCubeMapOrder (const Graphic3d_ValidatedCubeMapOrder& theOther)
: Order (theOther.Order) {}
public:
const Graphic3d_CubeMapOrder Order; //!< Completely valid order
@ -146,13 +150,11 @@ private:
//! Only Graphic3d_CubeMapOrder can generate Graphic3d_ValidatedCubeMapOrder in 'Validated' method.
Graphic3d_ValidatedCubeMapOrder(const Graphic3d_CubeMapOrder theOrder)
:
Order(theOrder)
{}
: Order(theOrder) {}
//! Deleted 'operator='
Graphic3d_ValidatedCubeMapOrder& operator= (const Graphic3d_ValidatedCubeMapOrder&);
};
#endif // _Graphic3d_CubeMapOrder_HeaderFile
#endif // _Graphic3d_CubeMapOrder_HeaderFile

6
src/Graphic3d/Graphic3d_Vertex.hxx
View File

@ -35,12 +35,6 @@ public:
SetCoord (0.0f, 0.0f, 0.0f);
}
//! Creates a point with coordinates identical to thePoint.
Graphic3d_Vertex (const Graphic3d_Vertex& thePoint)
{
SetCoord (thePoint.X(), thePoint.Y(), thePoint.Z());
}
//! Creates a point with theX, theY and theZ coordinates.
Graphic3d_Vertex (const Standard_ShortReal theX,
const Standard_ShortReal theY,

9
src/Graphic3d/Graphic3d_WorldViewProjState.hxx
View File

@ -141,15 +141,6 @@ public:
&& myWorldViewState == theOther.myWorldViewState;
}
//! Copy world view projection state.
void operator = (const Graphic3d_WorldViewProjState& theOther)
{
myIsValid = theOther.myIsValid;
myCamera = theOther.myCamera;
myProjectionState = theOther.myProjectionState;
myWorldViewState = theOther.myWorldViewState;
}
private:
Standard_Boolean myIsValid;

17
src/HatchGen/HatchGen_PointOnElement.cxx
View File

@ -34,23 +34,6 @@ HatchGen_PointOnElement::HatchGen_PointOnElement () :
// Purpose : Constructor.
//=======================================================================
HatchGen_PointOnElement::HatchGen_PointOnElement (const HatchGen_PointOnElement& Point)
{
myIndex = Point.myIndex ;
myParam = Point.myParam ;
myPosit = Point.myPosit ;
myBefore = Point.myBefore ;
myAfter = Point.myAfter ;
mySegBeg = Point.mySegBeg ;
mySegEnd = Point.mySegEnd ;
myType = Point.myType ;
}
//=======================================================================
// Function : HatchGen_PointOnElement
// Purpose : Constructor.
//=======================================================================
HatchGen_PointOnElement::HatchGen_PointOnElement (const IntRes2d_IntersectionPoint& Point)
{
const IntRes2d_Transition& TrsH = Point.TransitionOfFirst() ;

3
src/HatchGen/HatchGen_PointOnElement.hxx
View File

@ -40,9 +40,6 @@ public:
//! ---Purpose; Creates an empty point on element
Standard_EXPORT HatchGen_PointOnElement();
//! Creates a point from an other.
Standard_EXPORT HatchGen_PointOnElement(const HatchGen_PointOnElement& Point);
//! Creates a point from an intersection point.
Standard_EXPORT HatchGen_PointOnElement(const IntRes2d_IntersectionPoint& Point);

17
src/HatchGen/HatchGen_PointOnHatching.cxx
View File

@ -39,23 +39,6 @@ HatchGen_PointOnHatching::HatchGen_PointOnHatching () :
// Purpose : Constructor.
//=======================================================================
HatchGen_PointOnHatching::HatchGen_PointOnHatching (const HatchGen_PointOnHatching& Point)
{
myIndex = Point.myIndex ;
myParam = Point.myParam ;
myPosit = Point.myPosit ;
myBefore = Point.myBefore ;
myAfter = Point.myAfter ;
mySegBeg = Point.mySegBeg ;
mySegEnd = Point.mySegEnd ;
myPoints = Point.myPoints ;
}
//=======================================================================
// Function : HatchGen_PointOnHatching
// Purpose : Constructor.
//=======================================================================
HatchGen_PointOnHatching::HatchGen_PointOnHatching (const IntRes2d_IntersectionPoint& Point)
{
myIndex = 0 ;

5
src/HatchGen/HatchGen_PointOnHatching.hxx
View File

@ -41,10 +41,7 @@ public:
//! Creates an empty point.
Standard_EXPORT HatchGen_PointOnHatching();
//! Creates a point from an other.
Standard_EXPORT HatchGen_PointOnHatching(const HatchGen_PointOnHatching& Point);
//! Creates a point from an intersection point.
Standard_EXPORT HatchGen_PointOnHatching(const IntRes2d_IntersectionPoint& Point);

28
src/IGESToBRep/IGESToBRep_CurveAndSurface.cxx
View File

@ -77,34 +77,6 @@ IGESToBRep_CurveAndSurface::IGESToBRep_CurveAndSurface()
UpdateMinMaxTol();
}
//=======================================================================
//function : IGESToBRep_CurveAndSurface
//purpose :
//=======================================================================
IGESToBRep_CurveAndSurface::IGESToBRep_CurveAndSurface
(const IGESToBRep_CurveAndSurface& other)
: myEps (other.myEps),
myEpsCoeff (other.myEpsCoeff),
myEpsGeom (other.myEpsGeom),
myMinTol (other.myMinTol),
myMaxTol (other.myMaxTol),
myModeIsTopo (other.myModeIsTopo),
myModeApprox (other.myModeApprox),
myContIsOpti (other.myContIsOpti),
myUnitFactor (other.myUnitFactor),
mySurfaceCurve(other.mySurfaceCurve),
myContinuity (other.myContinuity),
mySurface (other.mySurface),
myUVResolution(other.myUVResolution),
myIsResolCom (other.myIsResolCom),
myModel (other.myModel),
myTP (other.myTP)
{
}
//=======================================================================
//function : IGESToBRep_CurveAndSurface
//purpose :

4
src/IGESToBRep/IGESToBRep_CurveAndSurface.hxx
View File

@ -45,10 +45,6 @@ public:
//! optimization of the continuity to False.
Standard_EXPORT IGESToBRep_CurveAndSurface();
//! Creates a tool CurveAndSurface ready to run and sets its
//! fields as CS's.
Standard_EXPORT IGESToBRep_CurveAndSurface(const IGESToBRep_CurveAndSurface& CS);
//! Creates a tool CurveAndSurface ready to run.
Standard_EXPORT IGESToBRep_CurveAndSurface(const Standard_Real eps, const Standard_Real epsGeom, const Standard_Real epsCoeff, const Standard_Boolean mode, const Standard_Boolean modeapprox, const Standard_Boolean optimized);

14
src/IntPolyh/IntPolyh_Point.hxx
View File

@ -78,19 +78,7 @@ public:
{
return myPOC;
}
//! Assignment operator
void Equal (const IntPolyh_Point& Pt)
{
myX = Pt.myX;
myY = Pt.myY;
myZ = Pt.myZ;
myU = Pt.myU;
myV = Pt.myV;
}
void operator = (const IntPolyh_Point& Pt)
{
Equal(Pt);
}
//! Sets the point
void Set (const Standard_Real x,
const Standard_Real y,

22
src/IntRes2d/IntRes2d_Intersection.hxx
View File

@ -87,6 +87,16 @@ protected:
IntRes2d_Intersection(const IntRes2d_Intersection& Other);
//! Assignment
IntRes2d_Intersection& operator= (const IntRes2d_Intersection& theOther)
{
done = theOther.done;
reverse = theOther.reverse;
lpnt = theOther.lpnt;
lseg = theOther.lseg;
return *this;
}
//! Destructor is protected, for safe inheritance
~IntRes2d_Intersection () {}
@ -104,18 +114,12 @@ protected:
Standard_Boolean ReversedParameters() const;
protected:
Standard_Boolean done;
private:
Standard_Boolean reverse;
IntRes2d_SequenceOfIntersectionPoint lpnt;
IntRes2d_SequenceOfIntersectionSegment lseg;
Standard_Boolean done;
Standard_Boolean reverse;
};

20
src/Interface/Interface_Graph.cxx
View File

@ -102,6 +102,26 @@ Interface_Graph::Interface_Graph
theflags.Initialize(agraph.BitMap(),Standard_True);
}
Interface_Graph& Interface_Graph::operator= (const Interface_Graph& theOther)
{
themodel = theOther.Model();
thepresents = theOther.thepresents;
thesharings = theOther.SharingTable();
thestats.Nullify();
const Standard_Integer nb = theOther.NbStatuses();
if (nb != 0)
{
thestats = new TColStd_HArray1OfInteger(1, nb);
for (Standard_Integer i = 1; i <= nb; ++i)
{
thestats->SetValue (i, theOther.Status(i));
}
theflags.Initialize (theOther.BitMap(), Standard_True);
}
return *this;
}
void Interface_Graph::InitStats()
{
thestats = new TColStd_HArray1OfInteger(1,themodel->NbEntities()) ,

3
src/Interface/Interface_Graph.hxx
View File

@ -87,6 +87,9 @@ public:
//! Remark that status are copied from <agraph>, but the other
//! lists (sharing/shared) are copied only if <copied> = True
Standard_EXPORT Interface_Graph(const Interface_Graph& agraph, const Standard_Boolean copied = Standard_False);
//! Assignment
Standard_EXPORT Interface_Graph& operator= (const Interface_Graph& theOther);
//! Erases data, making graph ready to rebegin from void
//! (also resets Shared lists redefinitions)

9
src/Interface/Interface_STAT.hxx
View File

@ -97,7 +97,14 @@ public:
//! used when starting
Standard_EXPORT Interface_STAT(const Interface_STAT& other);
//! Assignment
Interface_STAT& operator= (const Interface_STAT& theOther)
{
theOther.Internals (thetitle, thetotal, thephnam, thephw, thephdeb,thephfin, thestw);
return *this;
}
//! Returns fields in once, without copying them, used for copy
//! when starting
Standard_EXPORT void Internals (Handle(TCollection_HAsciiString)& tit, Standard_Real& total, Handle(TColStd_HSequenceOfAsciiString)& phn, Handle(TColStd_HSequenceOfReal)& phw, Handle(TColStd_HSequenceOfInteger)& phdeb, Handle(TColStd_HSequenceOfInteger)& phfin, Handle(TColStd_HSequenceOfReal)& stw) const;

8
src/Intf/Intf_SectionLine.hxx
View File

@ -67,6 +67,14 @@ Standard_Boolean operator == (const Intf_SectionLine& Other) const
//! Copies a SectionLine.
Standard_EXPORT Intf_SectionLine(const Intf_SectionLine& Other);
//! Assignment
Intf_SectionLine& operator= (const Intf_SectionLine& theOther)
{
//closed = theOther.closed; // not copied as in copy constructor
myPoints = theOther.myPoints;
return *this;
}
//! Adds a point at the end of the SectionLine.
Standard_EXPORT void Append (const Intf_SectionPoint& Pi);

14
src/Intf/Intf_TangentZone.cxx
View File

@ -31,20 +31,6 @@ Intf_TangentZone::Intf_TangentZone ()
ParamOnFirstMax = ParamOnSecondMax = RealFirst();
}
//=======================================================================
//function : Intf_TangentZone
//purpose : Copy
//=======================================================================
Intf_TangentZone::Intf_TangentZone (const Intf_TangentZone& Other)
{
Result=Other.Result;
ParamOnFirstMin = Other.ParamOnFirstMin;
ParamOnFirstMax = Other.ParamOnFirstMax;
ParamOnSecondMin = Other.ParamOnSecondMin;
ParamOnSecondMax = Other.ParamOnSecondMax;
}
//=======================================================================
//function : Append
//purpose : Append the section point to the tangent zone.

5
src/Intf/Intf_TangentZone.hxx
View File

@ -81,10 +81,7 @@ Standard_Boolean operator == (const Intf_TangentZone& Other) const
//! Builds an empty tangent zone.
Standard_EXPORT Intf_TangentZone();
//! Copies a Tangent zone.
Standard_EXPORT Intf_TangentZone(const Intf_TangentZone& Other);
//! Adds a SectionPoint to the TangentZone.
Standard_EXPORT void Append (const Intf_SectionPoint& Pi);

8
src/Intrv/Intrv_Intervals.cxx
View File

@ -52,14 +52,6 @@ Intrv_Intervals::Intrv_Intervals ()
Intrv_Intervals::Intrv_Intervals (const Intrv_Interval& Int)
{ myInter.Append(Int); }
//=======================================================================
//function : Intrv_Intervals
//purpose :
//=======================================================================
Intrv_Intervals::Intrv_Intervals (const Intrv_Intervals& Int)
{ myInter = Int.myInter; }
//=======================================================================
//function : Intersect
//purpose :

6
src/Intrv/Intrv_Intervals.hxx
View File

@ -41,11 +41,7 @@ public:
//! Creates a sequence of one interval.
Standard_EXPORT Intrv_Intervals(const Intrv_Interval& Int);
//! Creates by copying an existing sequence of
//! intervals.
Standard_EXPORT Intrv_Intervals(const Intrv_Intervals& Int);
//! Intersects the intervals with the interval <Tool>.
Standard_EXPORT void Intersect (const Intrv_Interval& Tool);

8
src/NCollection/NCollection_Array1.hxx
View File

@ -88,14 +88,6 @@ public:
myPtrEnd = const_cast<TheItemType*> (&theArray.Last() + 1);
}
//! Assignment
Iterator& operator= (const Iterator& theOther)
{
myPtrCur = theOther.myPtrCur;
myPtrEnd = theOther.myPtrEnd;
return *this;
}
//! Check end
Standard_Boolean More (void) const
{ return myPtrCur < myPtrEnd; }

4
src/OSD/OSD_signal.cxx
View File

@ -1027,7 +1027,9 @@ void OSD::SetSignal (OSD_SignalMode theSignalMode,
}
if (theSignalMode == OSD_SignalMode_SetUnhandled && retcode == 0 && anActOld.sa_handler != SIG_DFL)
{
retcode = sigaction (aSignalTypes[i], &anActOld, &anActOld);
struct sigaction anActOld2;
sigemptyset(&anActOld2.sa_mask);
retcode = sigaction (aSignalTypes[i], &anActOld, &anActOld2);
}
Standard_ASSERT(retcode == 0, "sigaction() failed", std::cout << "OSD::SetSignal(): sigaction() failed for " << aSignalTypes[i] << std::endl);
}

5
src/OpenGl/OpenGl_Context.cxx
View File

@ -34,14 +34,13 @@
#include <OpenGl_TextureSetPairIterator.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_Aspects.hxx>
#include <Graphic3d_TransformUtils.hxx>
#include <Graphic3d_RenderingParams.hxx>
#include <Message_Messenger.hxx>
#include <NCollection_Vector.hxx>
#include <Standard_ProgramError.hxx>
#include <Standard_WarningDisableFunctionCast.hxx>
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Context,Standard_Transient)

6
src/Standard/Standard.cxx
View File

@ -30,7 +30,7 @@
#if defined(_MSC_VER) || defined(__ANDROID__) || defined(__QNX__)
#include <malloc.h>
#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && (defined(__i386) || defined(__x86_64)))
#include <mm_malloc.h>
#else
extern "C" int posix_memalign (void** thePtr, size_t theAlign, size_t theSize);
@ -283,7 +283,7 @@ Standard_Address Standard::AllocateAligned (const Standard_Size theSize,
return _aligned_malloc (theSize, theAlign);
#elif defined(__ANDROID__) || defined(__QNX__)
return memalign (theAlign, theSize);
#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && (defined(__i386) || defined(__x86_64)))
return _mm_malloc (theSize, theAlign);
#else
void* aPtr;
@ -306,7 +306,7 @@ void Standard::FreeAligned (Standard_Address thePtrAligned)
_aligned_free (thePtrAligned);
#elif defined(__ANDROID__) || defined(__QNX__)
free (thePtrAligned);
#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && (defined(__i386) || defined(__x86_64)))
_mm_free (thePtrAligned);
#else
free (thePtrAligned);

9
src/StepData/StepData_Field.hxx
View File

@ -57,7 +57,14 @@ public:
//! Gets the copy of the values of another field
Standard_EXPORT void CopyFrom (const StepData_Field& other);
//! Assignment
StepData_Field& operator= (const StepData_Field& theOther)
{
CopyFrom (theOther);
return *this;
}
//! Clears the field, to set it as "no value defined"
//! Just before SetList, predeclares it as "any"
//! A Kind can be directly set here to declare a type

2
src/TDF/TDF_CopyLabel.cxx
View File

@ -203,5 +203,5 @@ const Handle(TDF_RelocationTable)& TDF_CopyLabel::RelocationTable() const
void TDF_CopyLabel::UseFilter(const TDF_IDFilter& aFilter)
{
myFilter = aFilter;
myFilter.Assign (aFilter);
}

11
src/TDF/TDF_IDFilter.cxx
View File

@ -37,17 +37,6 @@ TDF_IDFilter::TDF_IDFilter(const Standard_Boolean ignoreMode) :
myIgnore(ignoreMode)
{}
//=======================================================================
//function : TDF_IDFilter
//purpose : Private, to forbid implicit or hidden accesses to
// the copy constructor.
//=======================================================================
TDF_IDFilter::TDF_IDFilter(const TDF_IDFilter& /*aFilter*/)
{}
//=======================================================================
//function : IgnoreAll
//purpose :

20
src/TDF/TDF_IDFilter.hxx
View File

@ -104,27 +104,25 @@ public:
//! Writes the contents of <me> to <OS>.
Standard_EXPORT void Dump (Standard_OStream& anOS) const;
protected:
//! Assignment
void Assign (const TDF_IDFilter& theFilter)
{
myIgnore = theFilter.myIgnore;
myIDMap = theFilter.myIDMap;
}
private:
//! Private, to forbid implicit or hidden accesses to
//! the copy constructor.
Standard_EXPORT TDF_IDFilter(const TDF_IDFilter& aFilter);
TDF_IDFilter(const TDF_IDFilter& aFilter);
TDF_IDFilter& operator= (const TDF_IDFilter& theOther);
private:
Standard_Boolean myIgnore;
TDF_IDMap myIDMap;
};

18
src/TDF/TDF_Transaction.cxx
View File

@ -41,20 +41,10 @@
TDF_Transaction::TDF_Transaction
(const TCollection_AsciiString& aName)
: myUntilTransaction(0),
myName(aName)
: myName(aName),
myUntilTransaction(0)
{}
//=======================================================================
//function : TDF_Transaction
//purpose : Private copy constructor.
//=======================================================================
TDF_Transaction::TDF_Transaction(const TDF_Transaction& /*aTrans*/)
{}
//=======================================================================
//function : TDF_Transaction
//purpose :
@ -64,8 +54,8 @@ TDF_Transaction::TDF_Transaction
(const Handle(TDF_Data)& aDF,
const TCollection_AsciiString& aName)
: myDF(aDF),
myUntilTransaction(0),
myName(aName)
myName(aName),
myUntilTransaction(0)
{}

19
src/TDF/TDF_Transaction.hxx
View File

@ -96,26 +96,17 @@ public:
//! Dumps the content of me into the stream
Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
private:
protected:
//! Private to avoid copy.
TDF_Transaction(const TDF_Transaction& aTrans);
TDF_Transaction& operator= (const TDF_Transaction& theOther);
private:
//! Private to avoid copy.
Standard_EXPORT TDF_Transaction(const TDF_Transaction& aTrans);
Handle(TDF_Data) myDF;
Standard_Integer myUntilTransaction;
TCollection_AsciiString myName;
Standard_Integer myUntilTransaction;
};

7
src/TDocStd/TDocStd_Document.cxx
View File

@ -76,12 +76,12 @@ TDocStd_Document::TDocStd_Document(const TCollection_ExtendedString& aStorageFor
myStorageFormat(aStorageFormat),
myData (new TDF_Data()),
myUndoLimit(0),
myUndoTransaction ("UNDO"),
mySaveTime(0),
myIsNestedTransactionMode(0),
mySaveEmptyLabels(Standard_False)
{
TDF_Transaction* pTr = new TDF_Transaction (myData,"UNDO");
myUndoTransaction = *pTr; delete pTr;
myUndoTransaction.Initialize (myData);
TDocStd_Owner::SetDocument(myData,this);
#ifdef SRN_DELTA_COMPACT
@ -131,8 +131,7 @@ TCollection_ExtendedString TDocStd_Document::GetPath () const
void TDocStd_Document::SetData (const Handle(TDF_Data)& D)
{
myData = D;
TDF_Transaction* pTr = new TDF_Transaction(myData,"UNDO");
myUndoTransaction = *pTr; delete pTr;
myUndoTransaction.Initialize (myData);
}
//=======================================================================

126
src/TopOpeBRepDS/TopOpeBRepDS_EXPORT.cxx
View File

@ -290,7 +290,7 @@ Standard_EXPORT Standard_Boolean FDS_SIisGIofIofSBAofTofI(const TopOpeBRepDS_Dat
if (I.IsNull()) return Standard_False;
Standard_Boolean ya = Standard_False;
TopAbs_ShapeEnum SB1,SA1;Standard_Integer IB1,IA1;TopOpeBRepDS_Kind GT1,ST1;Standard_Integer G1,S1;
TopAbs_ShapeEnum SB1 = TopAbs_SHAPE, SA1 = TopAbs_SHAPE; Standard_Integer IB1 = 0, IA1 = 0; TopOpeBRepDS_Kind GT1 = TopOpeBRepDS_UNKNOWN, ST1 = TopOpeBRepDS_UNKNOWN; Standard_Integer G1 = 0, S1 = 0;
FDS_Idata(I,SB1,IB1,SA1,IA1,GT1,G1,ST1,S1);
if (SB1 == TopAbs_FACE) {
@ -298,7 +298,7 @@ Standard_EXPORT Standard_Boolean FDS_SIisGIofIofSBAofTofI(const TopOpeBRepDS_Dat
TopOpeBRepDS_ListIteratorOfListOfInterference it(Bloi);
for(; it.More(); it.Next()) {
const Handle(TopOpeBRepDS_Interference)& IB = it.Value();
TopAbs_ShapeEnum SBB,SAB;Standard_Integer IBB,IAB;TopOpeBRepDS_Kind GTB,STB;Standard_Integer GB,SB;
TopAbs_ShapeEnum SBB = TopAbs_SHAPE, SAB = TopAbs_SHAPE; Standard_Integer IBB = 0, IAB = 0; TopOpeBRepDS_Kind GTB = TopOpeBRepDS_UNKNOWN, STB = TopOpeBRepDS_UNKNOWN; Standard_Integer GB = 0, SB = 0;
FDS_Idata(IB,SBB,IBB,SAB,IAB,GTB,GB,STB,SB);
if (GTB == TopOpeBRepDS_EDGE && GB == SI) {
// la face IB1 a une interference dont la geometrie est l'arete SI.
@ -312,7 +312,7 @@ Standard_EXPORT Standard_Boolean FDS_SIisGIofIofSBAofTofI(const TopOpeBRepDS_Dat
TopOpeBRepDS_ListIteratorOfListOfInterference it(Aloi);
for(; it.More(); it.Next()) {
const Handle(TopOpeBRepDS_Interference)& IA = it.Value();
TopAbs_ShapeEnum SBA,SAA;Standard_Integer IBA,IAA;TopOpeBRepDS_Kind GTA,STA;Standard_Integer GA,SA;
TopAbs_ShapeEnum SBA = TopAbs_SHAPE, SAA = TopAbs_SHAPE;Standard_Integer IBA = 0, IAA = 0; TopOpeBRepDS_Kind GTA = TopOpeBRepDS_UNKNOWN, STA = TopOpeBRepDS_UNKNOWN; Standard_Integer GA = 0, SA = 0;
FDS_Idata(IA,SBA,IBA,SAA,IAA,GTA,GA,STA,SA);
if (GTA == TopOpeBRepDS_EDGE && GA == SI) {
// la face IA1 a une interference dont la geometrie est l'arete IS.
@ -558,7 +558,7 @@ Standard_EXPORT void FUN_ds_PURGEforE9(const Handle(TopOpeBRepDS_HDataStructure)
TopOpeBRepDS_ListIteratorOfListOfInterference it(l3dF);
while (it.More()) {
const Handle(TopOpeBRepDS_Interference)& I = it.Value();
TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
TopAbs_ShapeEnum SB = TopAbs_SHAPE, SA = TopAbs_SHAPE;Standard_Integer IB = 0, IA = 0;TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0, S = 0;
FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S);
Standard_Boolean FhasGE = FDS_SIisGIofIofSBAofTofI(BDS,IE,I);
if (FhasGE) {removed = Standard_True; l3dF.Remove(it); continue;} // E has split ON F (cto904A3;e19,f14)
@ -610,7 +610,7 @@ Standard_EXPORT void FUN_ds_completeforSE1(const Handle(TopOpeBRepDS_HDataStruct
for (tki.Init(); tki.More(); tki.Next()) {
// ISE = (INTERNAL(FACE),G,EDGE) :
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
TopOpeBRepDS_ListOfInterference lI1; Standard_Boolean hasINT = ::FUN_selectTRAINTinterference(loicopy,lI1);
if (!hasINT) continue;
@ -636,8 +636,8 @@ Standard_EXPORT void FUN_ds_completeforSE1(const Handle(TopOpeBRepDS_HDataStruct
it.Initialize(lI3) ;
for ( ;it.More(); it.Next()){
const Handle(TopOpeBRepDS_Interference)& I = it.Value();
TopOpeBRepDS_Kind GT,ST;
Standard_Integer G1,S;
TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN;
Standard_Integer G1 = 0, S = 0;
FDS_data(I,GT,G1,ST,S);
TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
@ -735,8 +735,8 @@ Standard_EXPORT void FUN_ds_completeforSE2(const Handle(TopOpeBRepDS_HDataStruct
const Handle(TopOpeBRepDS_Interference)& I = lFE.First();
Standard_Real par = FDS_Parameter(I);
TopOpeBRepDS_Kind ST; Standard_Integer S; FDS_data(I,K,G,ST,S);
TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
TopOpeBRepDS_Kind ST = TopOpeBRepDS_UNKNOWN; Standard_Integer S = 0; FDS_data(I,K,G,ST,S);
TopAbs_ShapeEnum tsb = TopAbs_SHAPE, tsa = TopAbs_SHAPE; Standard_Integer isb = 0, isa = 0; FDS_Tdata(I,tsb,isb,tsa,isa);
const TopoDS_Face& FTRA= TopoDS::Face(BDS.Shape(isb));
const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
@ -795,7 +795,7 @@ Standard_EXPORT void FUN_ds_completeforSE2(const Handle(TopOpeBRepDS_HDataStruct
TopOpeBRepDS_Transition newT;
// -------
Standard_Boolean isonper; Standard_Real par1,par2; Standard_Real factor = 1.e-4;
Standard_Boolean isonper = false; Standard_Real par1 = 0.0, par2 = 0.0; Standard_Real factor = 1.e-4;
FDS_LOIinfsup(BDS,SE,par,K,G,
BDS.ShapeInterferences(SE),par1,par2,isonper);
@ -858,19 +858,19 @@ static Standard_Boolean FUN_ds_completeforSE3(const TopOpeBRepDS_DataStructure&
// Tr
//---
const Handle(TopOpeBRepDS_Interference)& I3 = l3d.First();
TopOpeBRepDS_Kind K3,ST3; Standard_Integer G3,S3; FDS_data(I3,K3,G3,ST3,S3);
TopAbs_ShapeEnum tsb3,tsa3; Standard_Integer isb3,isa3; FDS_Tdata(I3,tsb3,isb3,tsa3,isa3);
TopOpeBRepDS_Kind K3 = TopOpeBRepDS_UNKNOWN, ST3 = TopOpeBRepDS_UNKNOWN; Standard_Integer G3 = 0, S3 = 0; FDS_data(I3,K3,G3,ST3,S3);
TopAbs_ShapeEnum tsb3 = TopAbs_SHAPE, tsa3 = TopAbs_SHAPE; Standard_Integer isb3 = 0, isa3 = 0; FDS_Tdata(I3,tsb3,isb3,tsa3,isa3);
IES = S3; ITRASHA = isb3;
const TopoDS_Edge& Eline = TopoDS::Edge(BDS.Shape(IES));
const TopoDS_Face& F = TopoDS::Face(BDS.Shape(ITRASHA));
parE = FDS_Parameter(I3);
Standard_Real parline; Standard_Boolean ok = FUN_tool_parE(SE,parE,Eline,parline);
Standard_Real parline = 0.0; Standard_Boolean ok = FUN_tool_parE(SE,parE,Eline,parline);
if (!ok) {return Standard_False;}
gp_Pnt2d uv; ok = FUN_tool_paronEF(Eline,parline,F,uv);
if (!ok) {return Standard_False;}
Standard_Real par1,par2; FUN_tool_bounds(SE,par1,par2);
Standard_Real par1 = 0.0, par2 = 0.0; FUN_tool_bounds(SE,par1,par2);
Standard_Real factor = 1.e-4;
@ -910,8 +910,8 @@ Standard_EXPORT void FUN_ds_completeforSE3(const Handle(TopOpeBRepDS_HDataStruct
tki.FillOnGeometry(LI);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
Standard_Real parE; Standard_Integer IES=0, ITRASHA=0; TopOpeBRepDS_Transition Tr;
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
Standard_Real parE = 0.0; Standard_Integer IES=0, ITRASHA=0; TopOpeBRepDS_Transition Tr;
Standard_Boolean ok = FUN_ds_completeforSE3(BDS,SE,K,G,loi,parE,IES,ITRASHA,Tr);
TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
@ -953,12 +953,12 @@ Standard_EXPORT Standard_Boolean FUN_ds_shareG
const TopoDS_Edge& E2 = TopoDS::Edge(BDS.Shape(iE2));
Standard_Real tol = Precision::Confusion()*1.e3;
Standard_Real f,l; FUN_tool_bounds(Esp,f,l);
Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(Esp,f,l);
Standard_Real x = 0.45678; Standard_Real par = (1-x)*f + x*l;
gp_Pnt P; Standard_Boolean ok = FUN_tool_value(par,Esp,P);
if (!ok) return Standard_False;
Standard_Real d2,par2; ok = FUN_tool_projPonE(P,E2,par2,d2);
Standard_Real d2 = 0.0, par2 = 0.0; ok = FUN_tool_projPonE(P,E2,par2,d2);
if (!ok) return Standard_False;
if (d2 > tol) return Standard_False;
@ -975,7 +975,7 @@ Standard_EXPORT Standard_Boolean FUN_ds_shareG
Standard_Boolean isb = mE1.Contains(E1);
if (!isb) continue;
Standard_Real d1,par1; ok = FUN_tool_projPonE(P,E1,par1,d1);
Standard_Real d1 = 0.0, par1 = 0.0; ok = FUN_tool_projPonE(P,E1,par1,d1);
if (!ok) continue;
if (d1 > tol) continue;
@ -1026,11 +1026,11 @@ Standard_EXPORT Standard_Boolean FUN_ds_mkTonFsdm
// beafter :
// ---------
Standard_Boolean ok = Standard_False;
gp_Pnt P; Standard_Real parEG;
gp_Pnt P; Standard_Real parEG = 0.0;
if (pardef) parEG = paronEG;
else {
Standard_Real f,l; FUN_tool_bounds(Esp,f,l);
Standard_Real dEG; ok = FUN_tool_projPonE(P,EG,parEG,dEG);
Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(Esp,f,l);
Standard_Real dEG = 0.0; ok = FUN_tool_projPonE(P,EG,parEG,dEG);
if (!ok) return Standard_False;
if (dEG > tol) return Standard_False;
}
@ -1044,10 +1044,10 @@ Standard_EXPORT Standard_Boolean FUN_ds_mkTonFsdm
// nxx2 :
// ------
Standard_Real par2;
Standard_Real par2 = 0.0;
if (EGisE2) par2 = parEG;
else {
Standard_Real d2; ok = FUN_tool_projPonE(P,E2,par2,d2);
Standard_Real d2 = 0.0; ok = FUN_tool_projPonE(P,E2,par2,d2);
if (!ok) return Standard_False;
if (d2 > tol) return Standard_False;
}
@ -1160,7 +1160,7 @@ static Standard_Integer FUN_EisSE2(const TopOpeBRepDS_DataStructure& BDS,
{
const TopOpeBRepDS_Transition& T = I->Transition();
const TopAbs_Orientation O = T.Orientation(TopAbs_IN);
TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
TopAbs_ShapeEnum SB = TopAbs_SHAPE, SA = TopAbs_SHAPE;Standard_Integer IB = 0, IA = 0;TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0, S = 0;
FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S);
if (GT != TopOpeBRepDS_VERTEX) return NONE;
if (M_EXTERNAL(O)) return NONE;
@ -1172,7 +1172,7 @@ static Standard_Integer FUN_EisSE2(const TopOpeBRepDS_DataStructure& BDS,
Standard_Integer rkE = BDS.AncestorRank(E);
Standard_Integer rkG = BDS.AncestorRank(G);
const TopoDS_Vertex& VG = TopoDS::Vertex(BDS.Shape(G));
Standard_Integer Gsd; Standard_Boolean Ghsd = FUN_ds_getVsdm(BDS,G,Gsd);
Standard_Integer Gsd = 0; Standard_Boolean Ghsd = FUN_ds_getVsdm(BDS,G,Gsd);
Standard_Integer oGinE = 0;
if (Ghsd) {
const TopoDS_Vertex& VGsd = TopoDS::Vertex(BDS.Shape(Gsd));
@ -1286,14 +1286,14 @@ Standard_EXPORT Standard_Integer FUN_ds_hasI2d(
TopOpeBRepDS_ListIteratorOfListOfInterference itE(LIE);
for (; itE.More(); itE.Next()){
const Handle(TopOpeBRepDS_Interference)& IE = itE.Value();
TopOpeBRepDS_Kind GTE,STE; Standard_Integer GE,SE; FDS_data(IE,GTE,GE,STE,SE);
TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(IE,tsb,isb,tsa,isa);
TopOpeBRepDS_Kind GTE = TopOpeBRepDS_UNKNOWN, STE = TopOpeBRepDS_UNKNOWN; Standard_Integer GE = 0, SE = 0; FDS_data(IE,GTE,GE,STE,SE);
TopAbs_ShapeEnum tsb = TopAbs_SHAPE, tsa = TopAbs_SHAPE; Standard_Integer isb = 0, isa = 0; FDS_Tdata(IE,tsb,isb,tsa,isa);
TopOpeBRepDS_ListIteratorOfListOfInterference itF(LIF);
Standard_Boolean is3d = Standard_False;
for (; itF.More(); itF.Next()){
const Handle(TopOpeBRepDS_Interference)& IF = itF.Value();
TopOpeBRepDS_Kind GTF,STF;
TopOpeBRepDS_Kind GTF = TopOpeBRepDS_UNKNOWN, STF = TopOpeBRepDS_UNKNOWN;
Standard_Integer GF=0,SF=0;
FDS_data(IF,GTF,GF,STF,SF);
if (GE != GF) continue;
@ -1329,7 +1329,7 @@ Standard_EXPORT void FUN_ds_completeforSE4(const Handle(TopOpeBRepDS_HDataStruct
TopOpeBRepDS_TKI tki;
tki.FillOnGeometry(LI);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
if (K != TopOpeBRepDS_POINT) continue;
TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
@ -1339,8 +1339,8 @@ Standard_EXPORT void FUN_ds_completeforSE4(const Handle(TopOpeBRepDS_HDataStruct
if (n2 < 1) continue;
const Handle(TopOpeBRepDS_Interference)& I = l2.First();
TopOpeBRepDS_Kind GT,ST; Standard_Integer S; FDS_data(I,GT,G,ST,S);
TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer S = 0; FDS_data(I,GT,G,ST,S);
TopAbs_ShapeEnum tsb = TopAbs_SHAPE, tsa = TopAbs_SHAPE; Standard_Integer isb = 0, isa = 0; FDS_Tdata(I,tsb,isb,tsa,isa);
const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
const TopoDS_Face& FTRA = TopoDS::Face(BDS.Shape(isb));
@ -1350,8 +1350,8 @@ Standard_EXPORT void FUN_ds_completeforSE4(const Handle(TopOpeBRepDS_HDataStruct
Standard_Boolean hasFOR=Standard_False,hasREV=Standard_False;
for (TopOpeBRepDS_ListIteratorOfListOfInterference it(l2); it.More(); it.Next()){
const Handle(TopOpeBRepDS_Interference)& I2 = it.Value();
TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
TopAbs_ShapeEnum tsb2,tsa2; Standard_Integer isb2,isa2; FDS_Tdata(I2,tsb2,isb2,tsa2,isa2);
TopOpeBRepDS_Kind GT2 = TopOpeBRepDS_UNKNOWN, ST2 = TopOpeBRepDS_UNKNOWN; Standard_Integer G2 = 0, S2 = 0; FDS_data(I2,GT2,G2,ST2,S2);
TopAbs_ShapeEnum tsb2 = TopAbs_SHAPE, tsa2 = TopAbs_SHAPE; Standard_Integer isb2 = 0, isa2 = 0; FDS_Tdata(I2,tsb2,isb2,tsa2,isa2);
Standard_Boolean error = (S2 != S) || (isb2 != isb);
if (error) return; // nyi raise
TopAbs_Orientation O2 = I2->Transition().Orientation(TopAbs_IN);
@ -1402,7 +1402,7 @@ Standard_EXPORT void FUN_ds_completeforSE5(const Handle(TopOpeBRepDS_HDataStruct
TopOpeBRepDS_TKI tki;
tki.FillOnGeometry(LI);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
if (K != TopOpeBRepDS_POINT) {FDS_copy(loi,newLI); continue;}
TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
@ -1617,7 +1617,7 @@ Standard_EXPORT void FUN_ds_completeforE7(const Handle(TopOpeBRepDS_HDataStructu
TopOpeBRepDS_ListOfInterference lFSE; Standard_Integer nFSE = FUN_selectITRASHAinterference(loicopy,IFS,lFSE);
Standard_Real par = FDS_Parameter(IFOR);
Standard_Boolean isonper; Standard_Real par1,par2; Standard_Real factor = 1.e-4;
Standard_Boolean isonper = false; Standard_Real par1 = 0.0, par2 = 0.0; Standard_Real factor = 1.e-4;
FDS_LOIinfsup(BDS,E,par,K,G,BDS.ShapeInterferences(E),par1,par2,isonper);
TopOpeBRepDS_Transition newT;
@ -1678,7 +1678,7 @@ Standard_EXPORT void FUN_ds_completeforE7(const Handle(TopOpeBRepDS_HDataStructu
TopOpeBRepDS_ListOfInterference& LII = BDS.ChangeShapeInterferences(E);
LII.Clear();
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
FDS_copy(loi,LII);
}
} //i = 1..ns
@ -1743,7 +1743,7 @@ Standard_EXPORT void FUN_ds_completeforSE8(const Handle(TopOpeBRepDS_HDataStruct
TopOpeBRepDS_ListOfInterference& LII = BDS.ChangeShapeInterferences(SE);
LII.Clear();
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind KK; Standard_Integer GG; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);
TopOpeBRepDS_Kind KK = TopOpeBRepDS_UNKNOWN; Standard_Integer GG = 0; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);
LII.Append(loi);
}
}// i=1..nse
@ -1782,8 +1782,8 @@ Standard_EXPORT void FUN_ds_completeforSE9(const Handle(TopOpeBRepDS_HDataStruct
TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LISE);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K;
Standard_Integer G;
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN;
Standard_Integer G = 0;
// const TopOpeBRepDS_ListOfInterference& loi =
tki.Value(K,G);
const TopoDS_Vertex& vG = TopoDS::Vertex(BDS.Shape(G));
@ -1835,14 +1835,14 @@ Standard_EXPORT void FUN_ds_PointToVertex(const Handle(TopOpeBRepDS_HDataStructu
TopOpeBRepDS_TKI tki;
tki.FillOnGeometry(LI);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
if (K == TopOpeBRepDS_VERTEX) continue;
Standard_Integer Scur = 0; Standard_Boolean Gfaulty = Standard_False;
for (TopOpeBRepDS_ListIteratorOfListOfInterference it(loi); it.More(); it.Next()){
const Handle(TopOpeBRepDS_Interference)& I = it.Value();
TopOpeBRepDS_Kind GT,ST;
Standard_Integer G1,S;
TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN;
Standard_Integer G1 = 0, S = 0;
FDS_data(I,GT,G1,ST,S);
if (ST != TopOpeBRepDS_EDGE) continue;
if (Scur == 0) {
@ -1882,8 +1882,8 @@ Standard_EXPORT void FUN_ds_PointToVertex(const Handle(TopOpeBRepDS_HDataStructu
TopOpeBRepDS_TKI tki;
tki.FillOnGeometry(LI);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K;
Standard_Integer G;
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN;
Standard_Integer G = 0;
const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
Standard_Boolean Gisbound = iPiV.IsBound(G);
if (!Gisbound) {
@ -1902,11 +1902,11 @@ Standard_EXPORT void FUN_ds_PointToVertex(const Handle(TopOpeBRepDS_HDataStructu
if (CPI.IsNull()) continue;
Standard_Real par = CPI->Parameter();
TopOpeBRepDS_Kind GT,ST;
Standard_Integer G1,S;
TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN;
Standard_Integer G1 = 0, S = 0;
FDS_data(I,GT,G1,ST,S);
const TopOpeBRepDS_Transition& T = I->Transition();
Standard_Real parvG; Standard_Boolean ok = FUN_tool_parVonE(vG,TopoDS::Edge(s),parvG);
Standard_Real parvG = 0.0; Standard_Boolean ok = FUN_tool_parVonE(vG,TopoDS::Edge(s),parvG);
// modified by NIZHNY-MKK Mon Apr 2 15:39:59 2001.BEGIN
// if (!ok) par = parvG;
if (!ok)
@ -1932,13 +1932,13 @@ static Standard_Boolean FUN_redusamshaonE(const TopOpeBRepDS_DataStructure& BDS,
// attached to edge(EIX) : IFOR=(FORWARD(ES),G,ES) + IREV=(REVERSED(ES),G,ES)
{
newI.Nullify();
TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
TopAbs_ShapeEnum SB = TopAbs_SHAPE, SA = TopAbs_SHAPE;Standard_Integer IB = 0, IA = 0; TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0, S = 0;
FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S);
const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(EIX));
Standard_Real parE = FDS_Parameter(I); Standard_Real f,l; FUN_tool_bounds(E,f,l);
const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
const TopoDS_Face& FTRA = TopoDS::Face(BDS.Shape(IB));
Standard_Real parES; Standard_Boolean ok = FUN_tool_parE(E,parE,ES,parES);
Standard_Real parES = 0.0; Standard_Boolean ok = FUN_tool_parE(E,parE,ES,parES);
if (!ok) return Standard_False;
gp_Pnt2d uv; ok = FUN_tool_paronEF(ES,parES,FTRA,uv);
if (!ok) return Standard_False;
@ -1979,7 +1979,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
const TopOpeBRepDS_ListOfInterference& LI = BDS.ShapeInterferences(i);
tki.FillOnGeometry(LI);
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
TopOpeBRepDS_ListOfInterference loicopy; FDS_copy(loi,loicopy); // loi -> l1+l2
TopOpeBRepDS_ListOfInterference l0;
FUN_selectTRASHAinterference(loicopy,TopAbs_EDGE,l0);//xpu091198(cylcong)
@ -1991,7 +1991,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
//***
TopOpeBRepDS_TKI tkis; tkis.FillOnSupport(l2);
for (tkis.Init(); tkis.More(); tkis.Next()) {
TopOpeBRepDS_Kind k; Standard_Integer s; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,s);
TopOpeBRepDS_Kind k = TopOpeBRepDS_UNKNOWN; Standard_Integer s = 0; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,s);
Standard_Integer nli = li.Extent();
if (nli < 2) continue;
@ -2002,7 +2002,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
const TopOpeBRepDS_Transition& T1 = I1->Transition();
TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN);
if (!M_FORWARD(O1) && !M_REVERSED(O1)) {it1.Next(); continue;}
TopAbs_ShapeEnum SB1,SA1;Standard_Integer IB1,IA1;TopOpeBRepDS_Kind GT1,ST1;Standard_Integer G1,S1;
TopAbs_ShapeEnum SB1 = TopAbs_SHAPE, SA1 = TopAbs_SHAPE; Standard_Integer IB1 = 0, IA1 = 0; TopOpeBRepDS_Kind GT1 = TopOpeBRepDS_UNKNOWN, ST1 = TopOpeBRepDS_UNKNOWN; Standard_Integer G1 = 0, S1 = 0;
FDS_Idata(I1,SB1,IB1,SA1,IA1,GT1,G1,ST1,S1);
if (IB1 != IA1) {it1.Next(); continue;}
@ -2012,7 +2012,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
const TopOpeBRepDS_Transition& T2 = I2->Transition();
TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN);
TopAbs_ShapeEnum SB2,SA2;Standard_Integer IB2,IA2;TopOpeBRepDS_Kind GT2,ST2;Standard_Integer G2,S2;
TopAbs_ShapeEnum SB2 = TopAbs_SHAPE, SA2 = TopAbs_SHAPE; Standard_Integer IB2 = 0, IA2 = 0; TopOpeBRepDS_Kind GT2 = TopOpeBRepDS_UNKNOWN, ST2 = TopOpeBRepDS_UNKNOWN; Standard_Integer G2 = 0, S2 = 0;
FDS_Idata(I2,SB2,IB2,SA2,IA2,GT2,G2,ST2,S2);
if (IB2 != IA2) {it2.Next(); continue;}
if (IB1 != IB2) {it2.Next(); continue;} // same fTRASHA
@ -2034,7 +2034,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
TopOpeBRepDS_ListOfInterference& newloi = tki.ChangeValue(K,G); newloi.Clear();
for (tkis.Init(); tkis.More(); tkis.Next()) {
TopOpeBRepDS_Kind k; Standard_Integer g; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,g);
TopOpeBRepDS_Kind k = TopOpeBRepDS_UNKNOWN; Standard_Integer g = 0; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,g);
newloi.Append(li);
}
newloi.Append(l0); newloi.Append(l1);
@ -2043,7 +2043,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
TopOpeBRepDS_ListOfInterference& newLI = BDS.ChangeShapeInterferences(E);
newLI.Clear();
for (tki.Init(); tki.More(); tki.Next()) {
TopOpeBRepDS_Kind KK; Standard_Integer GG; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);
TopOpeBRepDS_Kind KK = TopOpeBRepDS_UNKNOWN; Standard_Integer GG = 0; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);
newLI.Append(loi);
}
}// i=1..nse
@ -2069,7 +2069,7 @@ Standard_EXPORT Standard_Boolean FUN_ds_ONesd(const TopOpeBRepDS_DataStructure&
{
const TopoDS_Shape& E = BDS.Shape(IE);
TopTools_ListIteratorOfListOfShape it(BDS.ShapeSameDomain(E));
Standard_Real f,l; FUN_tool_bounds(TopoDS::Edge(EspON),f,l);
Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(TopoDS::Edge(EspON),f,l);
Standard_Real x = 0.456789; Standard_Real par = (1-x)*f + x*l;
gp_Pnt p3d; Standard_Boolean ok = FUN_tool_value(par,TopoDS::Edge(EspON),p3d);
if (!ok) return Standard_False;
@ -2179,7 +2179,7 @@ Standard_EXPORT Standard_Boolean FDS_LOIinfsup(
Standard_Real& paft,
Standard_Boolean& isonboundper)
{
Standard_Real f,l; FUN_tool_bounds(E,f,l);
Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(E,f,l);
pbef = f; paft = l;
Standard_Integer n = LOI.Extent();
if (n == 0) return Standard_True;
@ -2280,9 +2280,9 @@ Standard_EXPORT Standard_Boolean FDS_stateEwithF2d(const TopOpeBRepDS_DataStruct
TopOpeBRepDS_Transition& TrmemeS)
{
const TopOpeBRepDS_ListOfInterference& LOI = BDS.ShapeInterferences(E);
Standard_Real pbef,paft; Standard_Boolean isonper; Standard_Boolean ok = FDS_LOIinfsup(BDS,E,pE,KDS,GDS,LOI,pbef,paft,isonper);
Standard_Real pbef = 0.0, paft = 0.0; Standard_Boolean isonper = false; Standard_Boolean ok = FDS_LOIinfsup(BDS,E,pE,KDS,GDS,LOI,pbef,paft,isonper);
if (!ok) return Standard_False;
Standard_Real t1,t2; ok = FDS_parbefaft(BDS,E,pE,pbef,paft,isonper,t1,t2);
Standard_Real t1 = 0.0, t2 = 0.0; ok = FDS_parbefaft(BDS,E,pE,pbef,paft,isonper,t1,t2);
gp_Pnt P1; Standard_Boolean ok1 = FUN_tool_value(t1,E,P1);
gp_Pnt P2; Standard_Boolean ok2 = FUN_tool_value(t2,E,P2);
if (!ok1 || !ok2) return Standard_False;
@ -2363,7 +2363,7 @@ Standard_EXPORT void FUN_ds_FEIGb1TO0(Handle(TopOpeBRepDS_HDataStructure)& HDS,
// nothing's done
}
else {
Standard_Integer conf; Standard_Boolean ok = TopOpeBRepDS_TOOL::GetConfig(HDS,MEspON,G,Gsd,conf);
Standard_Integer conf = 0; Standard_Boolean ok = TopOpeBRepDS_TOOL::GetConfig(HDS,MEspON,G,Gsd,conf);
if (!ok) {it.Next(); continue;}
if (conf == DIFFORIENTED) newO = TopAbs::Complement(newO);
}
@ -2422,7 +2422,7 @@ Standard_EXPORT void FUN_ds_complete1dForSESDM(const Handle(TopOpeBRepDS_HDataSt
if (rkEsd == rkSE) continue;
if (BRep_Tool::Degenerated(Esd)) continue;
Standard_Boolean isSO;
Standard_Boolean isSO = false;
Standard_Boolean ok = FUN_tool_curvesSO(Esd,SE,isSO);
if (!ok) continue;
@ -2475,7 +2475,7 @@ Standard_EXPORT void FUN_ds_complete1dForSESDM(const Handle(TopOpeBRepDS_HDataSt
}
// make new interference
Standard_Real par;
Standard_Real par = 0.0;
Standard_Real tol = Max (BRep_Tool::Tolerance(aV), tolEsd);
Standard_Real parEsd = BRep_Tool::Parameter(aV,Esd);
ok = FUN_tool_parE (Esd,parEsd,SE,par,tol);

3
src/gp/gp_Quaternion.hxx
View File

@ -48,9 +48,6 @@ public:
//! Creates quaternion directly from component values
gp_Quaternion(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real w);
//! Creates copy of another quaternion
gp_Quaternion(const gp_Quaternion& theToCopy);
//! Creates quaternion representing shortest-arc rotation
//! operator producing vector theVecTo from vector theVecFrom.
gp_Quaternion(const gp_Vec& theVecFrom, const gp_Vec& theVecTo);

10
src/gp/gp_Quaternion.lxx
View File

@ -37,16 +37,6 @@ inline gp_Quaternion::gp_Quaternion (const Standard_Real theX, const Standard_Re
//purpose :
//=======================================================================
inline gp_Quaternion::gp_Quaternion (const gp_Quaternion& theToCopy)
: x(theToCopy.x), y(theToCopy.y), z(theToCopy.z), w(theToCopy.w)
{
}
//=======================================================================
//function : gp_Quaternion
//purpose :
//=======================================================================
inline gp_Quaternion::gp_Quaternion (const gp_Vec& theVecFrom, const gp_Vec& theVecTo)
{
SetRotation (theVecFrom, theVecTo);