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.
{
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);
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);
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) ) {
-
-// 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;
+ 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);
+
+ // 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");
+ }
}
}
}
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) ) {
-
-// 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);
-
- 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;
+ 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);
+
+ // 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
+ 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);
-
- 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);
- }
- }
+ // To force Overwrite if the criterion is Absolute
+ more = more && (CritRel);
- 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");
+ }
}
}
+ }
}
//=======================================================================
//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)();
}
//==========================================================================================
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);
}
//==========================================================================================
//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();
}
//==========================================================================================
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));
}
//==========================================================================================
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));
}
//==========================================================================================
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++;
- }
- 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);
+ 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;
+ }
}
- myUConstraints.SetValue(i,S0);
-
-// 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);
+
+ {
+ const AdvApp2Var_Strip& S0 = myUConstraints.Value(i);
+ const Standard_Real Udeb = S0.First()->U0(), Ufin = S0.First()->U1();
+
+ // 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;
}
}
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);
- }
- 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);
+
+ {
+ 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.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 (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);
+ // 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);
+
+ 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);
}
}
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();
}
//==========================================================================================
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();
}
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);
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
+++ /dev/null
-// 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);
-}
// 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 :
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);
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;
Handle(TColStd_HArray1OfReal) mySomTab;
Handle(TColStd_HArray1OfReal) myDifTab;
-
};
-
-
-
-
-
-
#endif // _AdvApp2Var_Iso_HeaderFile
//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;
}
//==========================================================================================
}
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);
}
}
{
// 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);
}
}
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);
}
}
//! 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);
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& operator() (const Standard_Integer UIndex, const Standard_Integer VIndex) const
-{
- return Patch(UIndex,VIndex);
-}
-
-
-
-
-protected:
-
-
+ 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);
+ }
private:
-
-
AdvApp2Var_SequenceOfPatch myNet;
TColStd_SequenceOfReal myUParameters;
TColStd_SequenceOfReal myVParameters;
-
};
-
-#include <AdvApp2Var_Network.lxx>
-
-
-
-
-
#endif // _AdvApp2Var_Network_HeaderFile
+++ /dev/null
-// 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);
-}
-
// 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.);
}
//=======================================================================
//=======================================================================
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.);
}
//=======================================================================
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.);
-}
-
-
-//=======================================================================
-//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);
+ myTruePoints.Init(P0);
+ myErrors.Init(0.);
}
-
-
-//=======================================================================
-//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);
-}
-
-
-
-
-
-
-
-
-
-
-
#ifndef _AdvApp2Var_Node_HeaderFile
#define _AdvApp2Var_Node_HeaderFile
+#include <gp_XY.hxx>
#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_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;
-
-
-
-
-protected:
-
-
-
+ //! 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; }
+
+ //! 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
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
+
//============================================================================
//function : AdvApp2Var_Patch
//purpose :
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 );
}
}
// -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 );
}
}
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);
}
}
//! 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();
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;
#include <AdvApp2Var_Node.hxx>
#include <NCollection_Sequence.hxx>
-typedef NCollection_Sequence<AdvApp2Var_Node> AdvApp2Var_SequenceOfNode;
-
+typedef NCollection_Sequence<Handle(AdvApp2Var_Node)> AdvApp2Var_SequenceOfNode;
#endif
#include <AdvApp2Var_Patch.hxx>
#include <NCollection_Sequence.hxx>
-typedef NCollection_Sequence<AdvApp2Var_Patch> AdvApp2Var_SequenceOfPatch;
+typedef NCollection_Sequence<Handle(AdvApp2Var_Patch)> AdvApp2Var_SequenceOfPatch;
#endif
//! 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
AdvApp2Var_EvaluatorFunc2Var.hxx
AdvApp2Var_Framework.cxx
AdvApp2Var_Framework.hxx
-AdvApp2Var_Framework.lxx
AdvApp2Var_Iso.cxx
AdvApp2Var_Iso.hxx
AdvApp2Var_MathBase.cxx
AdvApp2Var_MathBase_mathinit.cxx
AdvApp2Var_Network.cxx
AdvApp2Var_Network.hxx
-AdvApp2Var_Network.lxx
AdvApp2Var_Node.cxx
AdvApp2Var_Node.hxx
AdvApp2Var_Patch.cxx
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 :
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)
{
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)
// 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
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);
return &Order;
}
+ //! Copy constructor.
+ Graphic3d_ValidatedCubeMapOrder (const Graphic3d_ValidatedCubeMapOrder& theOther)
+ : Order (theOther.Order) {}
+
public:
const Graphic3d_CubeMapOrder Order; //!< Completely valid order
//! 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
\ No newline at end of file
+#endif // _Graphic3d_CubeMapOrder_HeaderFile
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,
&& 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;
// 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() ;
//! ---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);
// 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 ;
//! 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);
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 :
//! 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);
{
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,
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 () {}
Standard_Boolean ReversedParameters() const;
+protected:
- Standard_Boolean done;
-
-
-private:
-
-
-
- Standard_Boolean reverse;
IntRes2d_SequenceOfIntersectionPoint lpnt;
IntRes2d_SequenceOfIntersectionSegment lseg;
-
+ Standard_Boolean done;
+ Standard_Boolean reverse;
};
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()) ,
//! 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)
//! 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;
//! 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);
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.
//! 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);
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 :
//! 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);
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; }
}
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);
}
#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)
#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);
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;
_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);
//! 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
void TDF_CopyLabel::UseFilter(const TDF_IDFilter& aFilter)
{
- myFilter = aFilter;
+ myFilter.Assign (aFilter);
}
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 :
//! 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;
-
};
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 :
(const Handle(TDF_Data)& aDF,
const TCollection_AsciiString& aName)
: myDF(aDF),
- myUntilTransaction(0),
- myName(aName)
+ myName(aName),
+ myUntilTransaction(0)
{}
//! Dumps the content of me into the stream
Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
//! Private to avoid copy.
- Standard_EXPORT TDF_Transaction(const TDF_Transaction& aTrans);
+ TDF_Transaction(const TDF_Transaction& aTrans);
+ TDF_Transaction& operator= (const TDF_Transaction& theOther);
+private:
Handle(TDF_Data) myDF;
- Standard_Integer myUntilTransaction;
TCollection_AsciiString myName;
-
+ Standard_Integer myUntilTransaction;
};
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
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);
}
//=======================================================================
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) {
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.
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.
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)
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;
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));
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));
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);
// 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;
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);
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;
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;
// 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;
}
// 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;
}
{
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;
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));
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;
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);
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));
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);
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);
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;
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
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
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));
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) {
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) {
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)
// 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;
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)
//***
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;
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;}
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
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);
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
{
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;
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;
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;
// 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);
}
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;
}
// 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);
//! 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);
//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);
projects / occt-copy.git / commitdiff