public static bool AuxIntersectBB(DegenD degen, SegD seg,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
if (linters == null)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(degen,seg)", "Null argument");
}
// no reduction
bool connectAB = ((icAB != null) && (icAB.IsConnect));
if (connectAB)
{
return(true);
}
Param param;
VecD pnt;
degen.Cp.Project(seg, out param, out pnt);
if (degen.Cp.Dist(pnt) < MConsts.EPS_DEC)
{
IntersD0 inters = new IntersD0(Param.Degen, param, pnt, false);
linters.Add(inters);
}
return(true);
}
public static bool AuxIntersectBB(DegenD degen, Bez2D bez,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
if (linters == null)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(degen,bez)", "Null argument");
}
// no reduction !!
bool connectAB = ((icAB != null) && (icAB.IsConnect));
bool connectBA = ((icBA != null) && (icBA.IsConnect));
bool connect = connectAB || connectBA;
if (connect)
{
return(true);
}
// bbox check
if (!bez.BBox.Contains(degen.Cp))
{
return(true);
}
Param[] pars;
VecD pnt;
if (!degen.Cp.ProjectGeneral(bez, out pars, out pnt))
{
return(false);
}
if (degen.Cp.Dist(pnt) < MConsts.EPS_DEC)
{
Param parM;
bool isSelfInters = bez.IsSelfInters(out parM);
for (int iPar = 0; iPar < pars.Length; iPar++)
{
IntersD0 inters = new IntersD0(Param.Degen, pars[iPar], pnt, isSelfInters);
linters.Add(inters);
}
}
return(true);
}
public bool InfoConnectByPozPoz(int pozA, int pozB,
out InfoConnect icAB)
{
/* curveA and curveB are connected if
* - they follow one another or
* - they are separated by a sequence of degenerated curves
*
* ASSUMPTIONS:
* pozA!=pozB
*/
icAB = null;
bool areConj;
if (!this.AreConjByPozPoz(pozA, pozB, out areConj))
{
return(false);
}
if (!areConj)
{
return(true);
}
// are conjunctive
int pozNextA;
if (!this.PozStartNextByPoz(pozA, out pozNextA))
{
return(false);
}
if (pozNextA != pozB)
{
icAB = new InfoConnect(true, false);
}
// curveB is next after curveA
Knot knotNextA = this.KnotByPoz(this.PozNext(pozA));
Knot knotNextNextA = this.KnotByPoz(this.PozNext(this.PozNext(pozA)));
bool isTang = ((!knotNextA.On) && (!knotNextNextA.On));
icAB = new InfoConnect(true, isTang);
return(true);
}
/*
* INTERSECTIONS: (BCurve,BCurve)
* - ORDER is IMPORTANT
* order: if infoConnect are not nulls, =>
* it is supposed that curveA(1)=curveB(0)
*
* NOTES: - InfoConnect are supposed to be CORRECT
* - Curves are maximally reduced in AuxIntersectBB
* - Self/intersecting Bezier is NOT a reduction
* from bezier
*/
public static bool AuxIntersectBB(DegenD degenA, DegenD degenB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
if (linters==null)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(degen,degen)","Null argument");
}
bool connectAB = ((icAB!=null)&&(icAB.IsConnect));
bool connectBA = ((icBA!=null)&&(icBA.IsConnect));
bool connect = connectAB||connectBA;
if (connect) // connect,=> no "real" intersections
{
return true;
}
if (degenA.Cp==degenB.Cp) // coincide but are not known to be connected
{
IntersD0 inters=new IntersD0(Param.Degen,Param.Degen,
0.5*(degenA.Cp+degenB.Cp),false);
linters.Add(inters);
}
return true;
}
public static bool AuxIntersectBB(DegenD degen, Bez2D bez,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
if (linters==null)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(degen,bez)","Null argument");
}
// no reduction !!
bool connectAB = ((icAB!=null)&&(icAB.IsConnect));
bool connectBA = ((icBA!=null)&&(icBA.IsConnect));
bool connect=connectAB||connectBA;
if (connect)
{
return true;
}
// bbox check
if (!bez.BBox.Contains(degen.Cp))
return true;
Param[] pars;
VecD pnt;
if (!degen.Cp.ProjectGeneral(bez,out pars, out pnt))
return false;
if (degen.Cp.Dist(pnt)<MConsts.EPS_DEC)
{
Param parM;
bool isSelfInters=bez.IsSelfInters(out parM);
for (int iPar=0; iPar<pars.Length; iPar++)
{
IntersD0 inters=new IntersD0(Param.Degen,pars[iPar],pnt,isSelfInters);
linters.Add(inters);
}
}
return true;
}
/*
* INTERSECTIONS: (BCurve,BCurve)
* - ORDER is IMPORTANT
* order: if infoConnect are not nulls, =>
* it is supposed that curveA(1)=curveB(0)
*
* NOTES: - InfoConnect are supposed to be CORRECT
* - Curves are maximally reduced in AuxIntersectBB
* - Self/intersecting Bezier is NOT a reduction
* from bezier
*/
public static bool AuxIntersectBB(DegenD degenA, DegenD degenB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
if (linters == null)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(degen,degen)", "Null argument");
}
bool connectAB = ((icAB != null) && (icAB.IsConnect));
bool connectBA = ((icBA != null) && (icBA.IsConnect));
bool connect = connectAB || connectBA;
if (connect) // connect,=> no "real" intersections
{
return(true);
}
if (degenA.Cp == degenB.Cp) // coincide but are not known to be connected
{
IntersD0 inters = new IntersD0(Param.Degen, Param.Degen,
0.5 * (degenA.Cp + degenB.Cp), false);
linters.Add(inters);
}
return(true);
}
public static bool AuxIntersectBB(DegenD degen, SegD seg,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
if (linters==null)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(degen,seg)","Null argument");
}
// no reduction
bool connectAB = ((icAB!=null)&&(icAB.IsConnect));
if (connectAB)
{
return true;
}
Param param;
VecD pnt;
degen.Cp.Project(seg,out param, out pnt);
if (degen.Cp.Dist(pnt)<MConsts.EPS_DEC)
{
IntersD0 inters=new IntersD0(Param.Degen,param,pnt,false);
linters.Add(inters);
}
return true;
}
public static bool AuxIntersectBB(SegD segA, SegD segB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
bool connectAB = ((icAB != null) && (icAB.IsConnect));
bool connectBA = ((icBA != null) && (icBA.IsConnect));
bool connect = connectAB || connectBA;
InfoInters inters;
if (!Inters.IntersectLL(segA, segB, out inters))
{
return(false);
}
if (inters != null)
{
if ((!connect) ||
((connect) && (inters.Dim == InfoInters.TypeDim.Dim1)))
{
linters.Add(inters);
}
}
return(true);
}
public static bool IntersectBB(BCurve curveA, BCurve curveB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
BoxD bboxA = curveA.BBox;
BoxD bboxB = curveB.BBox;
if (!bboxA.HasInters(bboxB))
{
return(true);
}
int numIntersBefore = linters.Count;
bool connectAB = (icAB != null) && (icAB.IsConnect);
bool connectBA = (icBA != null) && (icBA.IsConnect);
bool toReverseByConnection = (connectBA) && (!connectAB);
if (toReverseByConnection)
{
if (!Inters.IntersectBB(curveB, curveA, icBA, icAB, linters))
{
return(false);
}
linters.ParamSwap(numIntersBefore);
return(false);
}
BCurve redA = curveA.Reduced;
BCurve redB = curveB.Reduced;
bool toReverseByComplexity = (redA.BComplexity > redB.BComplexity);
object[] pars = { redA, redB, icAB, icBA, linters };
if (toReverseByComplexity)
{
// TODO: check !!!
// TODO: what happens with connection info ???
pars[0] = redB.Reversed;
pars[1] = redA.Reversed;
}
Type[] types = { pars[0].GetType(), pars[1].GetType(),
typeof(InfoConnect), typeof(InfoConnect), typeof(ListInfoInters) };
MethodInfo infoMethod = typeof(Inters).GetMethod("AuxIntersectBB", types);
bool res;
try
{
res = (bool)infoMethod.Invoke(null, pars);
}
catch (System.Reflection.TargetInvocationException TIException)
{
throw TIException.InnerException;
}
if (toReverseByComplexity)
{
linters.ParamReverse(1, 0, numIntersBefore);
linters.ParamReverse(1, 1, numIntersBefore);
linters.ParamSwap(numIntersBefore);
}
if ((object)redA != (object)curveA)
{
linters.ParamFromReduced(curveA, 0, numIntersBefore);
}
if ((object)redB != (object)curveB)
{
linters.ParamFromReduced(curveB, 1, numIntersBefore);
}
// clean-up end-point intersections
linters.CleanEndPointInters(connectAB, connectBA, numIntersBefore);
return(res);
}
public static bool AuxIntersectBB(Bez2D bezA, Bez2D bezB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
// bezA and bezB are irreducable !!!
bool connectAB = ((icAB != null) && (icAB.IsConnect));
bool connectBA = ((icBA != null) && (icBA.IsConnect));
if ((connectBA) && (!connectAB))
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
}
bool connect = connectAB || connectBA;
Param parM;
bool isSelfIntersA = bezA.IsSelfInters(out parM);
bool isSelfIntersB = bezB.IsSelfInters(out parM);
if (isSelfIntersA || isSelfIntersB)
{
BCurve curveA = bezA;
if (isSelfIntersA)
{
curveA = bezA.SupportFlat();
}
BCurve curveB = bezB;
if (isSelfIntersB)
{
curveB = bezB.SupportFlat();
}
int numIntersBefore = linters.Count;
Inters.IntersectBB(curveA, curveB, null, null, linters);
/*
* CLEAN END-POINT if the curve does not return to it
*/
if ((connectAB) && (!connectBA))
{
bool coversA1 = false;
bool coversB0 = false;
if (isSelfIntersA)
{
coversA1 = bezA.CoversEndPoint(false);
}
if (isSelfIntersB)
{
coversB0 = bezB.CoversEndPoint(true);
}
if ((!coversA1) && (!coversB0))
{
linters.CleanEndPointBezSI(bezA.End, numIntersBefore);
}
}
linters.ParamInvalidateBezSI(numIntersBefore);
return(true);
}
// test for 1-dimensional intersection of supports
bool isB0OnA, isB2OnA;
Param paramAInvB0, paramAInvB2;
if (!bezB.Cp(0).InverseOn(bezA, out isB0OnA, out paramAInvB0))
{
return(false);
}
if (!bezB.Cp(2).InverseOn(bezA, out isB2OnA, out paramAInvB2))
{
return(false);
}
if ((isB0OnA) && (isB2OnA))
{
bool areCoincide = true;
Param par;
for (int i = 1; i <= 3; i++)
{
// evaluate bezB at paramaters 1/4, 1/2, 3/4 and check
// whether the points lie on bezA [-Infinity,Infinity]
VecD pnt = bezB.Evaluate(0.25 * i);
if (!pnt.InverseOn(bezA, out areCoincide, out par))
{
return(false);
}
if (!areCoincide)
{
break;
}
}
if (areCoincide)
{
Param.TypeParam typeB0 = bezA.ParamClassify(paramAInvB0);
Param.TypeParam typeB2 = bezA.ParamClassify(paramAInvB2);
int mult = (int)typeB0 * (int)typeB2;
if (mult == 4)
{
return(true); // no intersections
}
else if (mult == 1)
{
// bezB is degenerated
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
else if (mult == 2)
{
// 0-dimentional connection at the end point
if ((typeB0 == Param.TypeParam.Start) &&
(typeB2 == Param.TypeParam.Before))
{
if (connect)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
IntersD0 inters = new IntersD0(0, 0, bezB.Start, false);
linters.Add(inters);
return(true);
}
if ((typeB0 == Param.TypeParam.Before) &&
(typeB2 == Param.TypeParam.Start))
{
if (connect)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
IntersD0 inters = new IntersD0(1, 0, bezB.End, false);
linters.Add(inters);
return(true);
}
if ((typeB0 == Param.TypeParam.End) &&
(typeB2 == Param.TypeParam.After))
{
if (!connect)
{
IntersD0 inters = new IntersD0(0, 1, bezB.Start, false);
linters.Add(inters);
return(true);
}
return(true);
}
if ((typeB0 == Param.TypeParam.After) &&
(typeB2 == Param.TypeParam.End))
{
if (connect)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
IntersD0 inters = new IntersD0(1, 1, bezB.End, false);
linters.Add(inters);
return(true);
}
}
else if (mult <= 0)
{
InfoInters inters;
Inters.RefineIntersBBD1(bezA, bezB, out inters);
linters.Add(inters);
return(true);
}
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
}
/*
* INTERSECTION IS 0-DIMENTIONAL AT MOST
*/
VecD[] cfA, cfB;
bezA.PowerCoeff(out cfA);
bezB.PowerCoeff(out cfB);
Param parA, parB;
int numRootB;
double[] rootsB;
double kappa = cfA[2].Cross(cfA[1]);
// bezA and bezB are non-degenerated and consequent
if (connectAB)
{
if (bezA.End != bezB.Start)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
if (connectBA)
{
// both ends are connected
if (bezA.Start != bezB.End)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
if (icAB.IsTangent || icBA.IsTangent)
{
// tangent connection - no additional intersections
return(true);
}
double crossA2B2 = cfA[2].Cross(cfB[2]);
double[] cfEqn = { kappa *(kappa + 2 * crossA2B2 + cfA[1].Cross(cfB[2])),
-crossA2B2 * (2 * kappa + crossA2B2),
crossA2B2 *crossA2B2 };
Equation.RootsReal(cfEqn[2], cfEqn[1], cfEqn[0],
out numRootB, out rootsB);
if (numRootB == Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
if (rootsB != null)
{
for (int iRoot = 0; iRoot < numRootB; iRoot++)
{
parB = rootsB[iRoot];
if (bezB.IsEvaluableStrict(parB))
{
parA = 1.0 +
parB.Val * (cfA[2].Cross(cfB[2]) * parB.Val +
cfA[2].Cross(cfB[1])) / kappa;
if (bezA.IsEvaluableStrict(parA) /*&& (parA!=1.)*/)
{
IntersD0 inters = new IntersD0(parA, parB,
0.5 * (bezA.Evaluate(parA) + bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
}
return(true);
}
// consequent Bezier with one connection
if (icAB.IsTangent)
{
// tangent connection - at most 2 additional intersections
double[] cfEqn = { kappa *(kappa - cfB[2].Cross(cfB[1])),
2 * cfA[2].Cross(cfB[2]) * kappa,
cfA[2].Cross(cfB[2]) * cfA[2].Cross(cfB[2]) };
Equation.RootsReal(cfEqn[2], cfEqn[1], cfEqn[0],
out numRootB, out rootsB);
if (numRootB == Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
if (rootsB != null)
{
for (int iRoot = 0; iRoot < numRootB; iRoot++)
{
parB = rootsB[iRoot];
if (bezB.IsEvaluableStrict(parB))
{
parA = 1 +
parB.Val * (cfA[2].Cross(cfB[2]) * parB.Val +
cfA[2].Cross(cfB[1])) / kappa;
if (bezA.IsEvaluableStrict(parA) /*&&(parA!=1)*/)
{
IntersD0 inters = new IntersD0(parA, parB,
0.5 * (bezA.Evaluate(parA) + bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
}
return(true);
}
else
{
// non-tangent connection - at most 3 additional intersections
double[] cfEqn = { kappa *(2 * cfA[2].Cross(cfB[1]) + cfA[1].Cross(cfB[1])),
cfA[2].Cross(cfB[1]) * cfA[2].Cross(cfB[1]) +
kappa * (2 * cfA[2].Cross(cfB[2]) + cfA[1].Cross(cfB[2])),
2 * cfA[2].Cross(cfB[2]) * cfA[2].Cross(cfB[1]),
cfA[2].Cross(cfB[2]) * cfA[2].Cross(cfB[2]) };
Equation.RootsReal(cfEqn[3], cfEqn[2], cfEqn[1], cfEqn[0],
out numRootB, out rootsB);
if (numRootB == Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
if (rootsB != null)
{
for (int iRoot = 0; iRoot < numRootB; iRoot++)
{
parB = rootsB[iRoot];
if (bezB.IsEvaluableStrict(parB))
{
parA = 1 +
parB.Val * (cfA[2].Cross(cfB[2]) * parB +
cfA[2].Cross(cfB[1])) / kappa;
if (bezA.IsEvaluableStrict(parA) /*&&(parA!=1)*/)
{
IntersD0 inters = new IntersD0(parA, parB,
0.5 * (bezA.Evaluate(parA) + bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
}
return(true);
}
}
// bezA and bezB are non-degenerated, non-consequent curves
bool isSwappedAB = false;
if (Math.Abs(cfA[2].Cross(cfA[1])) < Math.Abs(cfB[2].Cross(cfB[1])))
{
kappa = cfB[2].Cross(cfB[1]);
isSwappedAB = true;
VecD tmp;
for (int i = 0; i < 3; i++)
{
tmp = cfA[i]; cfA[i] = cfB[i]; cfB[i] = tmp;
}
}
double[] e = { cfA[2].Cross(cfB[0] - cfA[0]),
cfA[2].Cross(cfB[1]),
cfA[2].Cross(cfB[2]) };
double[] f = { (cfB[0] - cfA[0]).Cross(cfA[1]),
cfB[1].Cross(cfA[1]),
cfB[2].Cross(cfA[1]) };
Equation.RootsReal(e[2] * e[2],
2 * e[2] * e[1],
e[1] * e[1] + 2 * e[2] * e[0] - kappa * f[2],
2 * e[1] * e[0] - kappa * f[1],
e[0] * e[0] - kappa * f[0],
out numRootB, out rootsB);
if (numRootB == Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(bez,bez)", null);
//return false;
}
if (rootsB != null)
{
for (int iRoot = 0; iRoot < numRootB; iRoot++)
{
parB = rootsB[iRoot];
parA = Equation.Evaluate(parB.Val, e[2], e[1], e[0]) / kappa;
if (isSwappedAB)
{
Param parTmp;
parTmp = parA;
parA = parB;
parB = parTmp;
}
if (bezA.IsEvaluableStrict(parA) && bezB.IsEvaluableStrict(parB))
{
IntersD0 inters = new IntersD0(parA, parB,
0.5 * (bezA.Evaluate(parA) + bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
return(true);
}
public static bool AuxIntersectBB(SegD seg, Bez2D bez,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
// both seg & bez are irreducable !!!
if (linters == null)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(seg,bez)", "Null argument");
}
bool connectAB = ((icAB != null) && (icAB.IsConnect));
bool connectBA = ((icBA != null) && (icBA.IsConnect));
if ((connectBA) && (!connectAB))
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(seg,bez)", null);
//return false;
}
bool connect = connectAB || connectBA;
if (!connect)
{
int numIntersBefore = linters.Count;
if (!Inters.AuxIntersectBL(bez, seg, linters))
{
return(false);
}
linters.ParamSwap(numIntersBefore);
return(true);
}
// bez and seg are connected, => connectAB=true
Param parM;
if (bez.IsSelfInters(out parM))
{
if (connectBA) // both ends are connected
{
// parM!=Infinity - otherwise the seg is degenerated
double valM = parM.Val;
IntersD1 inters;
if (valM > 1)
{
inters = new IntersD1(0, 1,
1, 1 / (2 * valM - 1), seg, true);
}
else
{
inters = new IntersD1(0, 1,
1, (2 * valM) / (2 * valM - 1), seg, true);
}
linters.Add(inters);
return(true);
}
if (icAB.IsTangent)
{
return(true); // no additional intersections
}
else
{
SegD segSupp = bez.SupportFlat();
InfoInters inters;
if (!Inters.IntersectLL(seg, segSupp, out inters))
{
return(false);
}
if (inters == null)
{
return(true);
}
inters.ParamInvalidateBezSI();
int numIntersBefore = linters.Count;
linters.Add(inters);
/*
* CLEAN END-POINT if the Bezier does not return to it
*/
bool coversBezStart = bez.CoversEndPoint(true);
if (!coversBezStart)
{
linters.CleanEndPointBezSI(bez.Start, numIntersBefore);
}
return(true);
}
}
// bezier is NOT self-intersecting
if (connectBA)
{
return(true); // no additional intersections
}
if (icAB.IsTangent)
{
return(true); // no additional intersections
}
// seg & bez are connected and not-tangent,=>
// at most one additional point of intersection
VecD[] cfSeg, cfBez;
seg.PowerCoeff(out cfSeg);
bez.PowerCoeff(out cfBez);
VecD tang = (seg as LCurve).DirTang;
VecD norm = (seg as LCurve).DirNorm;
// connected but not-tangent: one
double[] rootsBez;
int numRootBez;
Equation.RootsReal(cfBez[2].Dot(norm), cfBez[1].Dot(norm),
out numRootBez, out rootsBez);
if (numRootBez == Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect", "AuxIntersectBB(seg,bez)", null);
//return false;
}
if (rootsBez == null)
{
return(true);
}
Param parBez = rootsBez[0];
if (bez.IsEvaluableStrict(parBez))
{
double valBez = parBez.Val;
Param parSeg = 1 + valBez * (cfBez[2].Dot(tang) * valBez + cfBez[1].Dot(tang)) / cfSeg[1].Dot(tang);
if (seg.IsEvaluableStrict(parSeg)) // ??? && (parSeg!=1)
{
IntersD0 inters = new IntersD0(parSeg, parBez,
0.5 * (seg.Evaluate(parSeg) + bez.Evaluate(parBez)), false);
linters.Add(inters);
}
}
return(true);
}
public static bool IntersectBB(BCurve curveA, BCurve curveB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
BoxD bboxA=curveA.BBox;
BoxD bboxB=curveB.BBox;
if (!bboxA.HasInters(bboxB))
return true;
int numIntersBefore=linters.Count;
bool connectAB=(icAB!=null)&&(icAB.IsConnect);
bool connectBA=(icBA!=null)&&(icBA.IsConnect);
bool toReverseByConnection=(connectBA)&&(!connectAB);
if (toReverseByConnection)
{
if (!Inters.IntersectBB(curveB,curveA,icBA,icAB,linters))
return false;
linters.ParamSwap(numIntersBefore);
return false;
}
BCurve redA = curveA.Reduced;
BCurve redB = curveB.Reduced;
bool toReverseByComplexity=(redA.BComplexity>redB.BComplexity);
object[] pars={redA,redB,icAB,icBA,linters};
if (toReverseByComplexity)
{
// TODO: check !!!
// TODO: what happens with connection info ???
pars[0]=redB.Reversed;
pars[1]=redA.Reversed;
}
Type[] types={pars[0].GetType(),pars[1].GetType(),
typeof(InfoConnect),typeof(InfoConnect),typeof(ListInfoInters)};
MethodInfo infoMethod=typeof(Inters).GetMethod("AuxIntersectBB",types);
bool res;
try
{
res=(bool)infoMethod.Invoke(null,pars);
}
catch(System.Reflection.TargetInvocationException TIException)
{
throw TIException.InnerException;
}
if (toReverseByComplexity)
{
linters.ParamReverse(1,0,numIntersBefore);
linters.ParamReverse(1,1,numIntersBefore);
linters.ParamSwap(numIntersBefore);
}
if ((object)redA!=(object)curveA)
{
linters.ParamFromReduced(curveA,0,numIntersBefore);
}
if ((object)redB!=(object)curveB)
{
linters.ParamFromReduced(curveB,1,numIntersBefore);
}
// clean-up end-point intersections
linters.CleanEndPointInters(connectAB,connectBA,numIntersBefore);
return res;
}
public static bool AuxIntersectBB(Bez2D bezA, Bez2D bezB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
// bezA and bezB are irreducable !!!
bool connectAB = ((icAB!=null)&&(icAB.IsConnect));
bool connectBA = ((icBA!=null)&&(icBA.IsConnect));
if ((connectBA)&&(!connectAB))
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
}
bool connect = connectAB||connectBA;
Param parM;
bool isSelfIntersA=bezA.IsSelfInters(out parM);
bool isSelfIntersB=bezB.IsSelfInters(out parM);
if (isSelfIntersA||isSelfIntersB)
{
BCurve curveA=bezA;
if (isSelfIntersA)
curveA=bezA.SupportFlat();
BCurve curveB=bezB;
if (isSelfIntersB)
curveB=bezB.SupportFlat();
int numIntersBefore=linters.Count;
Inters.IntersectBB(curveA,curveB,null,null,linters);
/*
* CLEAN END-POINT if the curve does not return to it
*/
if ((connectAB)&&(!connectBA))
{
bool coversA1=false;
bool coversB0=false;
if (isSelfIntersA)
{
coversA1=bezA.CoversEndPoint(false);
}
if (isSelfIntersB)
{
coversB0=bezB.CoversEndPoint(true);
}
if ((!coversA1)&&(!coversB0))
{
linters.CleanEndPointBezSI(bezA.End,numIntersBefore);
}
}
linters.ParamInvalidateBezSI(numIntersBefore);
return true;
}
// test for 1-dimensional intersection of supports
bool isB0OnA, isB2OnA;
Param paramAInvB0, paramAInvB2;
if (!bezB.Cp(0).InverseOn(bezA,out isB0OnA,out paramAInvB0))
return false;
if (!bezB.Cp(2).InverseOn(bezA,out isB2OnA,out paramAInvB2))
return false;
if ((isB0OnA)&&(isB2OnA))
{
bool areCoincide=true;
Param par;
for (int i=1;i<=3;i++)
{
// evaluate bezB at paramaters 1/4, 1/2, 3/4 and check
// whether the points lie on bezA [-Infinity,Infinity]
VecD pnt=bezB.Evaluate(0.25*i);
if (!pnt.InverseOn(bezA,out areCoincide,out par))
return false;
if (!areCoincide)
break;
}
if (areCoincide)
{
Param.TypeParam typeB0 = bezA.ParamClassify(paramAInvB0);
Param.TypeParam typeB2 = bezA.ParamClassify(paramAInvB2);
int mult = (int)typeB0*(int)typeB2;
if (mult==4)
{
return true; // no intersections
}
else if (mult==1)
{
// bezB is degenerated
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
else if (mult==2)
{
// 0-dimentional connection at the end point
if ((typeB0==Param.TypeParam.Start)&&
(typeB2==Param.TypeParam.Before))
{
if (connect)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
IntersD0 inters=new IntersD0(0,0,bezB.Start,false);
linters.Add(inters);
return true;
}
if ((typeB0==Param.TypeParam.Before)&&
(typeB2==Param.TypeParam.Start))
{
if (connect)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
IntersD0 inters=new IntersD0(1,0,bezB.End,false);
linters.Add(inters);
return true;
}
if ((typeB0==Param.TypeParam.End)&&
(typeB2==Param.TypeParam.After))
{
if (!connect)
{
IntersD0 inters=new IntersD0(0,1,bezB.Start,false);
linters.Add(inters);
return true;
}
return true;
}
if ((typeB0==Param.TypeParam.After)&&
(typeB2==Param.TypeParam.End))
{
if (connect)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
IntersD0 inters=new IntersD0(1,1,bezB.End,false);
linters.Add(inters);
return true;
}
}
else if (mult<=0)
{
InfoInters inters;
Inters.RefineIntersBBD1(bezA,bezB,out inters);
linters.Add(inters);
return true;
}
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
}
/*
* INTERSECTION IS 0-DIMENTIONAL AT MOST
*/
VecD[] cfA, cfB;
bezA.PowerCoeff(out cfA);
bezB.PowerCoeff(out cfB);
Param parA, parB;
int numRootB;
double[] rootsB;
double kappa=cfA[2].Cross(cfA[1]);
// bezA and bezB are non-degenerated and consequent
if (connectAB)
{
if (bezA.End!=bezB.Start)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
if (connectBA)
{
// both ends are connected
if (bezA.Start!=bezB.End)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
if (icAB.IsTangent||icBA.IsTangent)
{
// tangent connection - no additional intersections
return true;
}
double crossA2B2=cfA[2].Cross(cfB[2]);
double[] cfEqn= { kappa*(kappa+2*crossA2B2+cfA[1].Cross(cfB[2])),
-crossA2B2*(2*kappa+crossA2B2),
crossA2B2*crossA2B2};
Equation.RootsReal(cfEqn[2],cfEqn[1],cfEqn[0],
out numRootB, out rootsB);
if (numRootB==Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
if (rootsB!=null)
{
for (int iRoot=0; iRoot<numRootB; iRoot++)
{
parB=rootsB[iRoot];
if (bezB.IsEvaluableStrict(parB))
{
parA=1.0+
parB.Val*(cfA[2].Cross(cfB[2])*parB.Val+
cfA[2].Cross(cfB[1]))/kappa;
if (bezA.IsEvaluableStrict(parA) /*&& (parA!=1.)*/)
{
IntersD0 inters=new IntersD0(parA,parB,
0.5*(bezA.Evaluate(parA)+bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
}
return true;
}
// consequent Bezier with one connection
if (icAB.IsTangent)
{
// tangent connection - at most 2 additional intersections
double[] cfEqn={kappa*(kappa-cfB[2].Cross(cfB[1])),
2*cfA[2].Cross(cfB[2])*kappa,
cfA[2].Cross(cfB[2])*cfA[2].Cross(cfB[2])};
Equation.RootsReal(cfEqn[2],cfEqn[1],cfEqn[0],
out numRootB, out rootsB);
if (numRootB==Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
if (rootsB!=null)
{
for (int iRoot=0; iRoot<numRootB; iRoot++)
{
parB=rootsB[iRoot];
if (bezB.IsEvaluableStrict(parB))
{
parA=1+
parB.Val*(cfA[2].Cross(cfB[2])*parB.Val+
cfA[2].Cross(cfB[1]))/kappa;
if (bezA.IsEvaluableStrict(parA)/*&&(parA!=1)*/)
{
IntersD0 inters=new IntersD0(parA,parB,
0.5*(bezA.Evaluate(parA)+bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
}
return true;
}
else
{
// non-tangent connection - at most 3 additional intersections
double[] cfEqn={kappa*(2*cfA[2].Cross(cfB[1])+cfA[1].Cross(cfB[1])),
cfA[2].Cross(cfB[1])*cfA[2].Cross(cfB[1])+
kappa*(2*cfA[2].Cross(cfB[2])+cfA[1].Cross(cfB[2])),
2*cfA[2].Cross(cfB[2])*cfA[2].Cross(cfB[1]),
cfA[2].Cross(cfB[2])*cfA[2].Cross(cfB[2])};
Equation.RootsReal(cfEqn[3],cfEqn[2],cfEqn[1],cfEqn[0],
out numRootB, out rootsB);
if (numRootB==Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
if (rootsB!=null)
{
for (int iRoot=0; iRoot<numRootB; iRoot++)
{
parB=rootsB[iRoot];
if (bezB.IsEvaluableStrict(parB))
{
parA=1+
parB.Val*(cfA[2].Cross(cfB[2])*parB+
cfA[2].Cross(cfB[1]))/kappa;
if (bezA.IsEvaluableStrict(parA)/*&&(parA!=1)*/)
{
IntersD0 inters=new IntersD0(parA,parB,
0.5*(bezA.Evaluate(parA)+bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
}
return true;
}
}
// bezA and bezB are non-degenerated, non-consequent curves
bool isSwappedAB=false;
if (Math.Abs(cfA[2].Cross(cfA[1]))<Math.Abs(cfB[2].Cross(cfB[1])))
{
kappa = cfB[2].Cross(cfB[1]);
isSwappedAB = true;
VecD tmp;
for (int i=0; i<3; i++)
{
tmp=cfA[i]; cfA[i]=cfB[i]; cfB[i]=tmp;
}
}
double[] e={cfA[2].Cross(cfB[0]-cfA[0]),
cfA[2].Cross(cfB[1]),
cfA[2].Cross(cfB[2])};
double[] f={(cfB[0]-cfA[0]).Cross(cfA[1]),
cfB[1].Cross(cfA[1]),
cfB[2].Cross(cfA[1])};
Equation.RootsReal(e[2]*e[2],
2*e[2]*e[1],
e[1]*e[1]+2*e[2]*e[0]-kappa*f[2],
2*e[1]*e[0]-kappa*f[1],
e[0]*e[0]-kappa*f[0],
out numRootB, out rootsB);
if (numRootB==Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(bez,bez)",null);
//return false;
}
if (rootsB!=null)
{
for (int iRoot=0; iRoot<numRootB; iRoot++)
{
parB=rootsB[iRoot];
parA=Equation.Evaluate(parB.Val, e[2], e[1], e[0])/kappa;
if (isSwappedAB)
{
Param parTmp;
parTmp=parA;
parA=parB;
parB=parTmp;
}
if (bezA.IsEvaluableStrict(parA)&&bezB.IsEvaluableStrict(parB))
{
IntersD0 inters=new IntersD0(parA,parB,
0.5*(bezA.Evaluate(parA)+bezB.Evaluate(parB)),
false);
linters.Add(inters);
}
}
}
return true;
}
public static bool AuxIntersectBB(SegD seg, Bez2D bez,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
// both seg & bez are irreducable !!!
if (linters==null)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(seg,bez)","Null argument");
}
bool connectAB = ((icAB!=null)&&(icAB.IsConnect));
bool connectBA = ((icBA!=null)&&(icBA.IsConnect));
if ((connectBA)&&(!connectAB))
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(seg,bez)",null);
//return false;
}
bool connect=connectAB||connectBA;
if (!connect)
{
int numIntersBefore=linters.Count;
if (!Inters.AuxIntersectBL(bez,seg,linters))
return false;
linters.ParamSwap(numIntersBefore);
return true;
}
// bez and seg are connected, => connectAB=true
Param parM;
if (bez.IsSelfInters(out parM))
{
if (connectBA) // both ends are connected
{
// parM!=Infinity - otherwise the seg is degenerated
double valM=parM.Val;
IntersD1 inters;
if (valM>1)
{
inters=new IntersD1(0,1,
1,1/(2*valM-1),seg,true);
}
else
{
inters=new IntersD1(0,1,
1,(2*valM)/(2*valM-1),seg,true);
}
linters.Add(inters);
return true;
}
if (icAB.IsTangent)
{
return true; // no additional intersections
}
else
{
SegD segSupp=bez.SupportFlat();
InfoInters inters;
if (!Inters.IntersectLL(seg,segSupp,out inters))
return false;
if (inters==null)
return true;
inters.ParamInvalidateBezSI();
int numIntersBefore=linters.Count;
linters.Add(inters);
/*
* CLEAN END-POINT if the Bezier does not return to it
*/
bool coversBezStart=bez.CoversEndPoint(true);
if (!coversBezStart)
{
linters.CleanEndPointBezSI(bez.Start,numIntersBefore);
}
return true;
}
}
// bezier is NOT self-intersecting
if (connectBA)
return true; // no additional intersections
if (icAB.IsTangent)
return true; // no additional intersections
// seg & bez are connected and not-tangent,=>
// at most one additional point of intersection
VecD[] cfSeg, cfBez;
seg.PowerCoeff(out cfSeg);
bez.PowerCoeff(out cfBez);
VecD tang=(seg as LCurve).DirTang;
VecD norm=(seg as LCurve).DirNorm;
// connected but not-tangent: one
double[] rootsBez;
int numRootBez;
Equation.RootsReal(cfBez[2].Dot(norm),cfBez[1].Dot(norm),
out numRootBez, out rootsBez);
if (numRootBez==Equation.NumRootInfinite)
{
throw new ExceptionGMath("Intersect","AuxIntersectBB(seg,bez)",null);
//return false;
}
if (rootsBez==null)
return true;
Param parBez=rootsBez[0];
if (bez.IsEvaluableStrict(parBez))
{
double valBez=parBez.Val;
Param parSeg=1+valBez*(cfBez[2].Dot(tang)*valBez+cfBez[1].Dot(tang))/cfSeg[1].Dot(tang);
if (seg.IsEvaluableStrict(parSeg)) // ??? && (parSeg!=1)
{
IntersD0 inters=new IntersD0(parSeg,parBez,
0.5*(seg.Evaluate(parSeg)+bez.Evaluate(parBez)),false);
linters.Add(inters);
}
}
return true;
}
public static bool AuxIntersectBB(SegD segA, SegD segB,
InfoConnect icAB, InfoConnect icBA, ListInfoInters linters)
{
bool connectAB = ((icAB!=null)&&(icAB.IsConnect));
bool connectBA = ((icBA!=null)&&(icBA.IsConnect));
bool connect=connectAB||connectBA;
InfoInters inters;
if (!Inters.IntersectLL(segA,segB,out inters))
return false;
if (inters!=null)
{
if ((!connect)||
((connect)&&(inters.Dim==InfoInters.TypeDim.Dim1)))
{
linters.Add(inters);
}
}
return true;
}
public InfoConnect(InfoConnect ic)
{
this.isConnect=ic.IsConnect;
this.isTangent=ic.IsTangent;
}
public bool InfoConnectByPozPoz(int pozA, int pozB,
out InfoConnect icAB)
{
/* curveA and curveB are connected if
* - they follow one another or
* - they are separated by a sequence of degenerated curves
*
* ASSUMPTIONS:
* pozA!=pozB
*/
icAB=null;
bool areConj;
if (!this.AreConjByPozPoz(pozA, pozB, out areConj))
return false;
if (!areConj)
return true;
// are conjunctive
int pozNextA;
if (!this.PozStartNextByPoz(pozA,out pozNextA))
return false;
if (pozNextA!=pozB)
{
icAB=new InfoConnect(true,false);
}
// curveB is next after curveA
Knot knotNextA=this.KnotByPoz(this.PozNext(pozA));
Knot knotNextNextA=this.KnotByPoz(this.PozNext(this.PozNext(pozA)));
bool isTang=((!knotNextA.On)&&(!knotNextNextA.On));
icAB=new InfoConnect(true,isTang);
return true;
}
public InfoConnect(InfoConnect ic)
{
this.isConnect = ic.IsConnect;
this.isTangent = ic.IsTangent;
}
