private bool showLine()
{
ArrayList usableCurves = new ArrayList();
double mindist = double.MaxValue;
if (tangCurves == null)
{
return(false);
}
for (int i = 0; i < tangCurves.Length; ++i)
{
Plane pl; // Element hat eine Ebene:
if (tangCurves[i].GetPlanarState() == PlanarState.Planar)
{
pl = tangCurves[i].GetPlane();
}
else
{ // Element hat keine Ebene: Eine machen, falls möglich!
try { pl = new Plane(tangCurves[i].StartPoint, tangCurves[i].EndPoint, circlePoint); }
catch (PlaneException) { break; }
}
if (Precision.IsPointOnPlane(circlePoint, pl))
{
ICurve2D l2D1 = tangCurves[i].GetProjectedCurve(pl);
GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, pl.Project(circlePoint), circRad);
if (tangentPoints.Length > 0)
{ // eine gültige Lösung ist gefunden
usableCurves.Add(tangCurves[i]); // zur lokalen Liste zufügen
for (int k = 0; k < tangentPoints.Length; k += 2)
{
double dist = Geometry.Dist(tangentPoints[k + 1], pl.Project(radiusPoint));
if (dist < mindist)
{
mindist = dist;
selected = usableCurves.Count - 1; // merken, welche Kurve die aktuell benutzte ist
// (/ 2) und (* 2), da pro Lösung zwei Punkte geliefert werden
int l = (k + 2 * (Math.Abs(selSol) % (tangentPoints.Length / 2))) % tangentPoints.Length;
center = tangentPoints[l];
}
}
}
if (mindist < double.MaxValue)
{
circRadCalc = (Math.Abs(l2D1.Distance(pl.Project(radiusPoint))) + Math.Abs(Geometry.Dist(circlePoint, radiusPoint))) / 2.0;
// base.MultiSolution = true;
base.MultiSolutionCount = tangentPoints.Length / 2;
circ.SetCirclePlaneCenterRadius(pl, pl.ToGlobal(center), circRad);
tangCurves = (ICurve[])usableCurves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
base.ShowActiveObject = true;
return(true);
}
}
}
base.MultiSolutionCount = 0;
// base.MultiSolution = false;
base.ShowActiveObject = false;
return(false);
}
/// <summary>
/// Determines the commomn plane of a point and a curve. Returns the common plane in the
/// parameter and true if there is such a plane. Returns false, if the point lies not
/// in the plane. <seealso cref="Precision"/>
/// </summary>
/// <param name="p">The point</param>
/// <param name="c2">The curve</param>
/// <param name="CommonPlane">The common plane</param>
/// <returns>true, if there is a common plane, else false</returns>
public static bool GetCommonPlane(GeoPoint p, ICurve c2, out Plane CommonPlane)
{ // kommt erstaunlicherweise ohne Zugriff auf die konkreten Kurven aus
PlanarState ps2 = c2.GetPlanarState();
if (ps2 == PlanarState.NonPlanar)
{
CommonPlane = new Plane(Plane.StandardPlane.XYPlane, 0.0); // braucht leider ein Ergebnis
return(false);
}
if (ps2 == PlanarState.Planar)
{
Plane p2 = c2.GetPlane();
if (Precision.IsPointOnPlane(p, p2))
{
CommonPlane = p2;
return(true);
}
}
else
{ // UnderDetermined, also Linie oder so
GeoVector v1 = p - c2.StartPoint;
GeoVector v2 = c2.StartDirection;
if (!Precision.SameDirection(v1, v2, false) && !Precision.IsNullVector(v1))
{
Plane pl = new Plane(p, v1, v2);
if (c2.IsInPlane(pl))
{
CommonPlane = pl;
return(true);
}
}
}
CommonPlane = new Plane(Plane.StandardPlane.XYPlane, 0.0); // braucht leider ein Ergebnis
return(false);
}
private bool showLine()
{
ArrayList usableCurves = new ArrayList();
double mindist = double.MaxValue;
double arcRadLoc;
if (tangCurves == null)
{
return(false);
}
arcRadLoc = arcRad;
for (int i = 0; i < tangCurves.Length; ++i)
{
Plane pl;
if (tangCurves[i].GetPlanarState() == PlanarState.Planar)
{
pl = tangCurves[i].GetPlane();
}
else
{
try { pl = new Plane(tangCurves[i].StartPoint, tangCurves[i].EndPoint, circlePoint); }
catch (PlaneException) { break; }
}
if (Precision.IsPointOnPlane(circlePoint, pl))
{
ICurve2D l2D1 = tangCurves[i].GetProjectedCurve(pl);
if (l2D1 is Path2D)
{
(l2D1 as Path2D).Flatten();
}
GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, pl.Project(circlePoint), arcRad);
if (tangentPoints.Length > 0)
{ // eine gültige Linie ist gefunden
usableCurves.Add(tangCurves[i]); // zur lokalen Liste zufügen
for (int k = 0; k < tangentPoints.Length; k += 2)
{
double dist = Geometry.Dist(tangentPoints[k + 1], pl.Project(objectPoint));
if (dist < mindist)
{
mindist = dist;
selected = usableCurves.Count - 1; // merken, welche Kurve die aktuell benutzte ist
// die Punkte werden als sortiert erwartet!! Hier nur über modulo (%) den Index bestimmen
// selSol / 2 shifted nach rechts, um 3 Zeilen tiefer weitere Möglichkeiten auswählen zu können
// (/ 3) und (* 3), da pro Lösung drei Punkte geliefert werden
int l = (k + 2 * ((Math.Abs(selSol) / 2) % (tangentPoints.Length / 2))) % tangentPoints.Length;
center = tangentPoints[l];
if ((Math.Abs(selSol) & 0x1) == 0) // 0 und 1 dienen zur Unterscheidung der Kreisbogenausrichtung
{
startAngle = new Angle(tangentPoints[l + 1], center);
endAngle = new Angle(pl.Project(circlePoint), center);
}
else
{
startAngle = new Angle(pl.Project(circlePoint), center);
endAngle = new Angle(tangentPoints[l + 1], center);
}
}
}
}
if (mindist < double.MaxValue)
{
arcRadCalc = (Math.Abs(l2D1.Distance(pl.Project(radiusPoint))) + Math.Abs(Geometry.Dist(circlePoint, radiusPoint))) / 2.0;
// base.MultiSolution = true;
base.MultiSolutionCount = tangentPoints.Length; // /2 *2
arc.SetArcPlaneCenterRadiusAngles(pl, pl.ToGlobal(center), arcRadLoc, startAngle, new SweepAngle(startAngle, endAngle, arcDir));
tangCurves = (ICurve[])usableCurves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
base.ShowActiveObject = true;
return(true);
}
}
}
base.MultiSolutionCount = 0;
// base.MultiSolution = false;
base.ShowActiveObject = false;
return(false);
}
private bool showLineDiam()
{
ArrayList usable1Curves = new ArrayList();
Plane pl;
double mindist = double.MaxValue;
if (tangCurves == null)
{
return(false);
}
for (int i = 0; i < tangCurves.Length; ++i)
{
if (tangCurves[i].GetPlanarState() == PlanarState.Planar)
{
pl = tangCurves[i].GetPlane();
}
else
{ // Element hat keine Ebene: Eine machen, falls möglich!
try { pl = new Plane(tangCurves[i].StartPoint, tangCurves[i].EndPoint, circlePoint); }
catch (PlaneException) { break; }
}
if (Precision.IsPointOnPlane(radiusPoint, pl))
{
ICurve2D l2D1 = tangCurves[i].GetProjectedCurve(pl);
ICurve2D l2D2 = new Circle2D(pl.Project(circlePoint), 0.0);
ICurve2D l2D3 = new Circle2D(pl.Project(radiusPoint), 0.0);
GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, l2D2, l2D3, pl.Project(objectPoint), pl.Project(circlePoint), pl.Project(radiusPoint));
if (tangentPoints.Length > 0)
{ // eine gültige Linie ist gefunden
usable1Curves.Add(tangCurves[i]); // zur lokalen Liste zufügen
for (int l = 0; l < tangentPoints.Length; l += 4)
{
double dist = Geometry.Dist(tangentPoints[l + 1], pl.Project(objectPoint)) +
Geometry.Dist(tangentPoints[l + 2], pl.Project(circlePoint)) +
Geometry.Dist(tangentPoints[l + 3], pl.Project(radiusPoint));
if (dist < mindist)
{
mindist = dist;
selected = usable1Curves.Count - 1; // merken, welche Kurven die aktuell benutzten sind
// selSol / 6 entspricht div 6, um einige Zeilen tiefer weitere 6 Möglichkeiten auswählen zu können
// (/ 4) und (* 4), da pro Lösung vier Punkte geliefert werden
int m = (l + 4 * (Math.Abs(selSol) % (tangentPoints.Length / 4))) % tangentPoints.Length;
center = tangentPoints[m];
arcRadCalc = Geometry.Dist(tangentPoints[m + 1], center) * 2.0;
}
}
if (mindist < double.MaxValue)
{
// base.MultiSolution = true;
base.MultiSolutionCount = tangentPoints.Length / 4;
arc.SetCirclePlaneCenterRadius(pl, pl.ToGlobal(center), arcRad);
tangCurves = (ICurve[])usable1Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
base.ShowActiveObject = true;
return(true);
}
}
}
}
base.ShowActiveObject = false;
base.MultiSolutionCount = 0;
// base.MultiSolution = false;
return(false);
}
private bool showLineDiam()
{
ArrayList usable1Curves = new ArrayList();
ArrayList usable2Curves = new ArrayList();
Plane pl;
double mindist = double.MaxValue;
if (tangCurves == null)
{
return(false);
}
if (tang2Curves == null)
{
return(false);
}
// if (tang3Curves == null) return false;
for (int i = 0; i < tangCurves.Length; ++i)
{
for (int j = 0; j < tang2Curves.Length; ++j)
{
if (Curves.GetCommonPlane(tangCurves[i], tang2Curves[j], out pl))
{
if (Precision.IsPointOnPlane(radiusPoint, pl))
{
ICurve2D l2D1 = tangCurves[i].GetProjectedCurve(pl);
ICurve2D l2D2 = tang2Curves[j].GetProjectedCurve(pl);
ICurve2D l2D3 = new Circle2D(pl.Project(radiusPoint), 0.0);
GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, l2D2, l2D3, pl.Project(objectPoint), pl.Project(object2Point), pl.Project(radiusPoint));
if (tangentPoints.Length > 0)
{ // eine gültige Linie ist gefunden
//if (curve1Input.Fixed & curve2Input.Fixed & (tangentPoints.Length > 4))
//{
// int debug = 0;
//}
usable1Curves.Add(tangCurves[i]); // zur lokalen Liste zufügen
usable2Curves.Add(tang2Curves[j]); // zur lokalen Liste zufügen
for (int l = 0; l < tangentPoints.Length; l += 4)
{
double dist = Geometry.Dist(tangentPoints[l + 1], pl.Project(objectPoint)) +
Geometry.Dist(tangentPoints[l + 2], pl.Project(object2Point)) +
Geometry.Dist(tangentPoints[l + 3], pl.Project(radiusPoint));
if (dist < mindist)
{
mindist = dist;
selected = usable1Curves.Count - 1; // merken, welche Kurven die aktuell benutzten sind
selected2 = usable2Curves.Count - 1;
// selSol / 6 entspricht div 6, um einige Zeilen tiefer weitere 6 Möglichkeiten auswählen zu können
// (/ 4) und (* 4), da pro Lösung vier Punkte geliefert werden
int m = (l + 4 * (Math.Abs(selSol) % (tangentPoints.Length / 4))) % tangentPoints.Length;
center = tangentPoints[m];
circRadCalc = Geometry.Dist(tangentPoints[m + 1], center) * 2.0;
}
}
}
if (mindist < double.MaxValue)
{
// base.MultiSolution = true;
base.MultiSolutionCount = tangentPoints.Length / 4;
circ.SetCirclePlaneCenterRadius(pl, pl.ToGlobal(center), circRad);
tangCurves = (ICurve[])usable1Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
tang2Curves = (ICurve[])usable2Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
base.ShowActiveObject = true;
return(true);
}
}
}
}
}
base.ShowActiveObject = false;
base.MultiSolutionCount = 0;
// base.MultiSolution = false;
return(false);
}
private bool showLine()
{
ArrayList usable1Curves = new ArrayList();
ArrayList usable2Curves = new ArrayList();
Plane pl;
int selSolLoc;
double mindist = double.MaxValue;
if (tang1Curves == null)
{
return(false);
}
if (tang2Curves == null)
{
return(false);
}
// if (tang3Curves == null) return false;
for (int i = 0; i < tang1Curves.Length; ++i)
{
for (int j = 0; j < tang2Curves.Length; ++j)
{
if (Curves.GetCommonPlane(tang1Curves[i], tang2Curves[j], out pl))
{
if (Precision.IsPointOnPlane(circlePoint, pl))
{
ICurve2D l2D1 = tang1Curves[i].GetProjectedCurve(pl);
if (l2D1 is Path2D)
{
(l2D1 as Path2D).Flatten();
}
ICurve2D l2D2 = tang2Curves[j].GetProjectedCurve(pl);
if (l2D2 is Path2D)
{
(l2D2 as Path2D).Flatten();
}
// der Trick, den OpenCascade mitmacht: 3. Kreis mit Radius 0!!
ICurve2D l2D3 = new Circle2D(pl.Project(circlePoint), 0.0);
GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, l2D2, l2D3, pl.Project(object1Point), pl.Project(object2Point), pl.Project(circlePoint));
if (tangentPoints.Length > 0)
{ // eine gültige lösung ist gefunden
usable1Curves.Add(tang1Curves[i]); // zur lokalen Liste zufügen
usable2Curves.Add(tang2Curves[j]); // zur lokalen Liste zufügen
for (int l = 0; l < tangentPoints.Length; l += 4)
{ // mittlerer Abstand zu den Klickpunkten als Ausscheidungskriterium
double dist = Geometry.Dist(tangentPoints[l + 1], pl.Project(object1Point)) +
Geometry.Dist(tangentPoints[l + 2], pl.Project(object2Point)) +
Geometry.Dist(tangentPoints[l + 3], pl.Project(circlePoint));
if (dist < mindist)
{
mindist = dist;
selected1 = usable1Curves.Count - 1; // merken, welche Kurven die aktuell benutzten sind
selected2 = usable2Curves.Count - 1;
// selSol / 6 entspricht div 6, um einige Zeilen tiefer weitere 6 Möglichkeiten auswählen zu können
// (/ 4) und (* 4), da pro Lösung vier Punkte geliefert werden
int m = (l + 4 * ((Math.Abs(selSol) / 6) % (tangentPoints.Length / 4))) % tangentPoints.Length;
selSolLoc = (Math.Abs(selSol) % 6) / 2; // liefert 0, 1, oder 2, "/2" um unten die Orientierung umschalten zu können
center = tangentPoints[m];
arcRad = Geometry.Dist(tangentPoints[m + selSolLoc + 1], center);
if ((Math.Abs(selSol) & 0x1) == 0) // 0 und 1 dienen zur Unterscheidung der Kreisbogenausrichtung
{
startAngle = new Angle(tangentPoints[m + selSolLoc + 1], center);
endAngle = new Angle(tangentPoints[m + ((selSolLoc + 1) % 3) + 1], center); // "%3", also modulo 3, da der Index läuft: 2,3,1
}
else
{
endAngle = new Angle(tangentPoints[m + selSolLoc + 1], center);
startAngle = new Angle(tangentPoints[m + ((selSolLoc + 1) % 3) + 1], center); // "%3", also modulo 3, da der Index läuft: 2,3,1
}
}
}
}
if (mindist < double.MaxValue)
{
base.MultiSolutionCount = (tangentPoints.Length / 4) * 6;
arc.SetArcPlaneCenterRadiusAngles(pl, pl.ToGlobal(center), arcRad, startAngle, new SweepAngle(startAngle, endAngle, arcDir));
base.ShowActiveObject = true;
tang1Curves = (ICurve[])usable1Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
tang2Curves = (ICurve[])usable2Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
return(true);
}
}
}
}
}
base.ShowActiveObject = false;
base.MultiSolutionCount = 0;
// base.MultiSolution = false;
return(false);
}
private bool showLine()
{
ArrayList usable1Curves = new ArrayList();
ArrayList usable2Curves = new ArrayList();
Plane pl;
double mindist = double.MaxValue;
if (tang1Curves == null)
{
return(false);
}
if (tang2Curves == null)
{
return(false);
}
for (int i = 0; i < tang1Curves.Length; ++i)
{
for (int j = 0; j < tang2Curves.Length; ++j)
{
if (Curves.GetCommonPlane(tang1Curves[i], tang2Curves[j], out pl))
{
if (Precision.IsPointOnPlane(circlePoint, pl))
{
ICurve2D l2D1 = tang1Curves[i].GetProjectedCurve(pl);
if (l2D1 is Path2D)
{
(l2D1 as Path2D).Flatten();
}
ICurve2D l2D2 = tang2Curves[j].GetProjectedCurve(pl);
if (l2D2 is Path2D)
{
(l2D2 as Path2D).Flatten();
}
// der Trick, den OpenCascade mitmacht: 3. Kreis mit Radius 0!!
ICurve2D l2D3 = new Circle2D(pl.Project(circlePoint), 0.0);
GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, l2D2, l2D3, pl.Project(object1Point), pl.Project(object2Point), pl.Project(circlePoint));
if (tangentPoints.Length > 0)
{ // eine gültige Lösung ist gefunden
usable1Curves.Add(tang1Curves[i]); // zur lokalen Liste zufügen
usable2Curves.Add(tang2Curves[j]); // zur lokalen Liste zufügen
for (int l = 0; l < tangentPoints.Length; l += 4)
{ // mittlerer Abstand zu den Klickpunkten als Ausscheidungskriterium
double dist = Geometry.Dist(tangentPoints[l + 1], pl.Project(object1Point)) +
Geometry.Dist(tangentPoints[l + 2], pl.Project(object2Point)) +
Geometry.Dist(tangentPoints[l + 3], pl.Project(circlePoint));
if (dist < mindist)
{
mindist = dist;
selected1 = usable1Curves.Count - 1; // merken, welche Kurven die aktuell benutzten sind
selected2 = usable2Curves.Count - 1;
// selSol / 6 entspricht div 6, um einige Zeilen tiefer weitere 6 Möglichkeiten auswählen zu können
// (/ 4) und (* 4), da pro Lösung vier Punkte geliefert werden
int m = (l + 4 * (Math.Abs(selSol) % (tangentPoints.Length / 4))) % tangentPoints.Length;
center = tangentPoints[m];
circRad = Geometry.Dist(tangentPoints[m + 1], center);
}
}
}
if (mindist < double.MaxValue)
{
// base.MultiSolution = true;
base.MultiSolutionCount = tangentPoints.Length / 4;
circ.SetCirclePlaneCenterRadius(pl, pl.ToGlobal(center), circRad);
tang1Curves = (ICurve[])usable1Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
tang2Curves = (ICurve[])usable2Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
base.ShowActiveObject = true;
return(true);
}
}
}
}
}
base.ShowActiveObject = false;
base.MultiSolutionCount = 0;
// base.MultiSolution = false;
return(false);
}
/// <summary>
/// Implements <see cref="CADability.GeoObject.ICurve.IsInPlane (Plane)"/>
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public bool IsInPlane(Plane p)
{
return(Precision.IsPointOnPlane(startPoint, p) && Precision.IsPointOnPlane(endPoint, p));
}
