public Curve involute(Circle baseCircle, double Angle, Circle max, Circle min)
{
List <Point3d> points = new List <Point3d>();
double r = baseCircle.Radius;
for (double i = 0; i < 500; i += 2)
{
double t = toRadian(i);
double x = r * (Math.Cos(t) + t * Math.Sin(t));
double y = r * (Math.Sin(t) - t * Math.Cos(t));
Point3d p = new Point3d(x, y, 0);
points.Add(p);
if (p.DistanceTo(new Point3d(0, 0, 0)) > max.Radius)
{
break;
}
}
Curve profile = Curve.CreateInterpolatedCurve(points, 3);
profile = profile.Extend(CurveEnd.Start, (baseCircle.Radius - min.Radius) * 2, CurveExtensionStyle.Smooth);
ArcCurve maxCircle = new ArcCurve(max);
ArcCurve minCircle = new ArcCurve(min);
Transform xform = Transform.PlaneToPlane(Plane.WorldXY, baseCircle.Plane);
profile.Transform(xform);
var ccxA = Rhino.Geometry.Intersect.Intersection.CurveCurve(profile, minCircle, 0.1, 0.1);
var ccxB = Rhino.Geometry.Intersect.Intersection.CurveCurve(profile, maxCircle, 0.1, 0.1);
List <double> ts = new List <double> {
ccxA[0].ParameterA, ccxB[0].ParameterA
};
return(profile.Split(ts)[1]);
}
static IEnumerable <NXOpen.Arc> ToEdgeCurveMany(ArcCurve curve)
{
NXOpen.Point3d ToXYZ(Point3d p) => new NXOpen.Point3d(p.X, p.Y, p.Z);
if (curve.IsClosed(DistanceTolerance * 1.01))
{
var interval = curve.Domain;
double min = interval.Min, mid = interval.Mid, max = interval.Max;
var points = new NXOpen.Point3d[]
{
ToXYZ(curve.PointAt(min)),
ToXYZ(curve.PointAt(min + (mid - min) * 0.5)),
ToXYZ(curve.PointAt(mid)),
ToXYZ(curve.PointAt(mid + (max - mid) * 0.5)),
ToXYZ(curve.PointAt(max)),
};
yield return(WorkPart.Curves.CreateArc(points[0], points[2], points[1], false, out _));
yield return(WorkPart.Curves.CreateArc(points[2], points[4], points[3], false, out _));
}
else
{
yield return(WorkPart.Curves.CreateArc(ToXYZ(curve.Arc.StartPoint), ToXYZ(curve.Arc.EndPoint), ToXYZ(curve.Arc.MidPoint), false, out _));
}
}
// Arc
// Rh Capture can be a circle OR an arc
public Base ArcToSpeckle(ArcCurve a, string units = null)
{
var u = units ?? ModelUnits;
if (a.IsClosed)
{
RH.Circle preCircle;
a.TryGetCircle(out preCircle);
Circle myCircle = CircleToSpeckle(preCircle, u);
myCircle.domain = IntervalToSpeckle(a.Domain);
myCircle.length = a.GetLength();
myCircle.bbox = BoxToSpeckle(new RH.Box(a.GetBoundingBox(true)), u);
return(myCircle);
}
else
{
RH.Arc preArc;
a.TryGetArc(out preArc);
Arc myArc = ArcToSpeckle(preArc, u);
myArc.domain = IntervalToSpeckle(a.Domain);
myArc.length = a.GetLength();
myArc.bbox = BoxToSpeckle(new RH.Box(a.GetBoundingBox(true)), u);
return(myArc);
}
}
/***************************************************/
// Get profile curves in Rhino format.
public override Curve[] ToRhinoProfile()
{
Curve[] curves = new Curve[2];
curves[0] = new ArcCurve(new Circle(this._diameter * 0.5));
curves[1] = new ArcCurve(new Circle(this._diameter * 0.5 - this._thickness));
return(curves);
}
public static Curve RatchetCover(Circle C, double D, double pRad)
{
ArcCurve co = new ArcCurve(new Circle(C.Plane, C.Radius - (D + pRad)));
ArcCurve ci = new ArcCurve(new Circle(C.Plane, C.Radius - ((D + pRad) * 2)));
co.Domain = ci.Domain = new Interval(0, 1);
List <double> ts = new List <double>();
for (double i = 0; i < 8; i++)
{
ts.Add(i / 8);
}
Curve[] shatterCo = co.Split(ts);
Curve[] shatterCi = ci.Split(ts);
List <Curve> shatter = new List <Curve>();
for (int i = 0; i < 8; i += 2)
{
shatter.Add(shatterCo[i]);
shatter.Add(shatterCi[i + 1]);
shatter.Add(new LineCurve(shatterCo[i].PointAtEnd, shatterCi[i + 1].PointAtStart));
Vector3d v = shatterCi[i + 1].PointAtEnd - C.Center; v.Unitize();
shatter.Add(new LineCurve(shatterCi[i + 1].PointAtEnd, shatterCi[i + 1].PointAtEnd + (v * (D + pRad))));
}
Curve covers = Curve.JoinCurves(shatter)[0];
Curve cover = Curve.CreateFilletCornersCurve(covers, (D + pRad) * 0.48, 0.001, 0.001);
return(cover);
}
public static ArcCurve ToNative(this SpeckleArc a)
{
Arc arc = new Arc(a.Plane.ToNative(), ( double )a.Radius, ( double )a.AngleRadians);
var myArc = new ArcCurve(arc);
myArc.UserDictionary.ReplaceContentsWith(a.Properties.ToNative());
return(myArc);
}
public static ArcCurve ToNative(this SpeckleCircle circ)
{
Circle circle = new Circle(new Plane(circ.Center.ToNative().Location, circ.Normal.ToNative()), ( double )circ.Radius);
var myCircle = new ArcCurve(circle);
myCircle.UserDictionary.ReplaceContentsWith(circ.Properties.ToNative());
return(myCircle);
}
public static Edge ToTopologic(this ArcCurve arcCurve)
{
if (arcCurve == null)
{
return(null);
}
global::Rhino.Geometry.NurbsCurve nurbsCurve = arcCurve.ToNurbsCurve();
return(ToTopologic(nurbsCurve));
}
public ArcCurve CircleToNative(Circle circ)
{
RH.Circle circle = new RH.Circle(PlaneToNative(circ.plane), ScaleToNative((double)circ.radius, circ.units));
var myCircle = new ArcCurve(circle);
if (circ.domain != null)
{
myCircle.Domain = IntervalToNative(circ.domain);
}
return(myCircle);
}
private void AppendArcDefinition(StringBuilder sb, ArcCurve ar)
{
Point3d pa = ar.PointAtStart;
Point3d pe = ar.PointAtEnd;
Point3d pm = ar.Arc.Center;
Vector3d n = ar.Arc.Plane.Normal;
sb.AppendFormat(" GAXB X1 {0:F8} {1:F8} {2:F8} ", pa.X, pa.Y, pa.Z);
sb.AppendFormat(" X2 {0:F8} {1:F8} {2:F8} ", pe.X, pe.Y, pe.Z);
sb.AppendFormat(" XM {0:F8} {1:F8} {2:F8} ", pm.X, pm.Y, pm.Z);
sb.AppendFormat(" NX {0:F8} {1:F8} {2:F8} ", n.X, n.Y, n.Z);
sb.AppendLine();
}
public static DB.Arc ToHost(ArcCurve value)
{
var arc = value.Arc;
if (value.Arc.IsCircle)
{
return(DB.Arc.Create(AsPlane(arc.Plane), value.Radius, 0.0, 2.0 * Math.PI));
}
else
{
return(DB.Arc.Create(AsXYZ(arc.StartPoint), AsXYZ(arc.EndPoint), AsXYZ(arc.MidPoint)));
}
}
private void AppendCurveGeometry(StringBuilder sb, ArcCurve a)
{
Point3d pa = a.PointAtStart;
Point3d pe = a.PointAtEnd;
Point3d pm = a.Arc.Center;
Vector3d n = a.Arc.Plane.Normal;
sb.AppendFormat(" SLNB X1 {0:F8} {1:F8} {2:F8} ", pa.X, pa.Y, pa.Z);
sb.AppendFormat(" X2 {0:F8} {1:F8} {2:F8} ", pe.X, pe.Y, pe.Z);
sb.AppendFormat(" XM {0:F8} {1:F8} {2:F8} ", pm.X, pm.Y, pm.Z);
sb.AppendFormat(" NX {0:F8} {1:F8} {2:F8} ", n.X, n.Y, n.Z);
sb.AppendLine();
}
bool IGH_TypeHint.Cast(object data, out object target)
{
bool toReturn = base.Cast(data, out target);
if (m_component.DocStorageMode == DocReplacement.DocStorage.AutomaticMarshal && target != null)
{
Type t = target.GetType();
if (t == typeof(Line))
{
target = new LineCurve((Line)target);
}
else if (t == typeof(Arc))
{
target = new ArcCurve((Arc)target);
}
else if (t == typeof(Circle))
{
target = new ArcCurve((Circle)target);
}
else if (t == typeof(Ellipse))
{
target = ((Ellipse)target).ToNurbsCurve();
}
else if (t == typeof(Box))
{
target = Brep.CreateFromBox((Box)target);
}
else if (t == typeof(BoundingBox))
{
target = Brep.CreateFromBox((BoundingBox)target);
}
else if (t == typeof(Rectangle3d))
{
target = ((Rectangle3d)target).ToNurbsCurve();
}
else if (t == typeof(Polyline))
{
target = new PolylineCurve((Polyline)target);
}
}
return(toReturn);
}
private Topologic.Topology ByCurve(Curve ghCurve)
{
LineCurve ghLine = ghCurve as LineCurve;
if (ghLine != null)
{
return(ByLine(ghLine.Line));
}
Rhino.Geometry.NurbsCurve ghNurbsCurve = ghCurve as Rhino.Geometry.NurbsCurve;
if (ghNurbsCurve != null)
{
return(ByNurbsCurve(ghNurbsCurve));
}
ArcCurve ghArcCurve = ghCurve as ArcCurve;
if (ghArcCurve != null)
{
return(ByArcCurve(ghArcCurve));
}
BrepEdge ghBrepEdge = ghCurve as BrepEdge;
if (ghBrepEdge != null)
{
return(ByBrepEdge(ghBrepEdge));
}
//BrepTrim ghBrepTrim = ghCurve as BrepTrim;
//if (ghBrepTrim != null)
//{
// return ByBrepTrim(ghBrepTrim);
//}
PolylineCurve ghPolylineCurve = ghCurve as PolylineCurve;
if (ghPolylineCurve != null)
{
return(ByPolylineCurve(ghPolylineCurve));
}
PolyCurve ghPolyCurve = ghCurve as PolyCurve;
if (ghPolyCurve != null)
{
return(ByPolyCurve(ghPolyCurve));
}
throw new Exception("This type of curve is not yet supported.");
}
bool IGH_TypeHint.Cast(object data, out object target)
{
bool toReturn = base.Cast(data, out target);
if (toReturn && target != null)
{
Type t = target.GetType();
if (t == typeof(Line))
{
target = new LineCurve((Line)target);
}
else if (t == typeof(Arc))
{
target = new ArcCurve((Arc)target);
}
else if (t == typeof(Circle))
{
target = new ArcCurve((Circle)target);
}
else if (t == typeof(Ellipse))
{
target = ((Ellipse)target).ToNurbsCurve();
}
else if (t == typeof(Box))
{
target = Brep.CreateFromBox((Box)target);
}
else if (t == typeof(BoundingBox))
{
target = Brep.CreateFromBox((BoundingBox)target);
}
else if (t == typeof(Rectangle3d))
{
target = ((Rectangle3d)target).ToNurbsCurve();
}
else if (target is Polyline)
{
target = new PolylineCurve((Polyline)target);
}
}
return(toReturn);
}
public static Topology ToTopologic(this Curve curve)
{
if (curve == null)
{
return(null);
}
LineCurve lineCurve = curve as LineCurve;
if (lineCurve != null)
{
return(lineCurve.Line.ToTopologic());
}
Rhino.Geometry.NurbsCurve nurbsCurve = curve as Rhino.Geometry.NurbsCurve;
if (nurbsCurve != null)
{
return(nurbsCurve.ToTopologic());
}
ArcCurve arcCurve = curve as ArcCurve;
if (arcCurve != null)
{
return(arcCurve.ToTopologic());
}
BrepEdge brepEdge = curve as BrepEdge;
if (brepEdge != null)
{
return(brepEdge.ToTopologic());
}
PolylineCurve ghPolylineCurve = curve as PolylineCurve;
if (ghPolylineCurve != null)
{
return(ghPolylineCurve.ToTopologic());
}
PolyCurve ghPolyCurve = curve as PolyCurve;
if (ghPolyCurve != null)
{
return(ghPolyCurve.ToTopologic());
}
return(null);
}
public static ArcCurve ToNative(this SpeckleCircle circ)
{
Circle circle = new Circle(circ.Plane.ToNative(), ( double )circ.Radius);
var myCircle = new ArcCurve(circle);
if (circ.Domain != null)
{
myCircle.Domain = circ.Domain.ToNative();
}
myCircle.UserDictionary.ReplaceContentsWith(circ.Properties.ToNative());
return(myCircle);
}
/// <summary>
/// Determines whether the specified curve is outside.
/// </summary>
/// <param name="curve">The curve.</param>
/// <param name="distance">The distance.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override bool isOutside(Point3d point3d, Curve curve, double distance)
{
Curve currentToolCurve = new ArcCurve(new Circle(point3d, (X / 2) + distance));
RegionContainment result = Curve.PlanarClosedCurveRelationship(curve, currentToolCurve, Plane.WorldXY, Properties.Settings.Default.Tolerance);
if (result == RegionContainment.Disjoint)
{
return(true);
}
else
{
return(false);
}
}
public ArcCurve ArcToNative(Arc a)
{
RH.Arc arc = new RH.Arc(PlaneToNative(a.plane), ScaleToNative((double)a.radius, a.units), (double)a.angleRadians);
arc.StartAngle = (double)a.startAngle;
arc.EndAngle = (double)a.endAngle;
var myArc = new ArcCurve(arc);
if (a.domain != null)
{
myArc.Domain = IntervalToNative(a.domain);
}
return(myArc);
}
public static ArcCurve ToNative(this SpeckleArc a)
{
Arc arc = new Arc(a.Plane.ToNative(), ( double )a.Radius, ( double )a.AngleRadians);
arc.StartAngle = ( double )a.StartAngle;
arc.EndAngle = ( double )a.EndAngle;
var myArc = new ArcCurve(arc);
if (a.Domain != null)
{
myArc.Domain = a.Domain.ToNative();
}
myArc.UserDictionary.ReplaceContentsWith(a.Properties.ToNative());
return(myArc);
}
public Result drawDotMatrix(Point3d pt, string text, double textHeight)
{
TextEntity dotMatrixText = new TextEntity();
Vector3d normalVector = new Vector3d(0, 0, 1);
Plane textPlane = new Plane(pt, normalVector);
dotMatrixText.Plane = textPlane;
dotMatrixText.Text = text;
dotMatrixText.Justification = TextJustification.BottomRight;
dotMatrixText.TextHeight = textHeight;
dotMatrixText.FontIndex = RhinoDoc.ActiveDoc.Fonts.FindOrCreate("Dot-Matrix", false, false);
dotMatrixText.DrawForward = false;
Rhino.Geometry.Curve[] curves = dotMatrixText.Explode();
Rhino.Geometry.Curve[] newCurves = new Curve[curves.Length];
// Get each centre of the curves
for (int i = 0; i < curves.Length; i++)
{
// Find the centre
BoundingBox bbox = curves[i].GetBoundingBox(true);
newCurves[i] = new ArcCurve(new Circle(bbox.Center, 0.5));
}
if (newCurves != null)
{
foreach (Curve curve in newCurves)
{
Guid guid = RhinoDoc.ActiveDoc.Objects.AddCurve(curve);
int idx = RhinoDoc.ActiveDoc.Groups.Find(text, false);
if (idx < 0)
{
idx = RhinoDoc.ActiveDoc.Groups.Add(text);
}
RhinoDoc.ActiveDoc.Groups.AddToGroup(idx, guid);
}
}
return(Result.Success);
}
public HbCurve Hb(ArcCurve arcCurveRhino)
{
HbCurve hbCurve = new HbCurve();
Point3d xyzRhinoStart = arcCurveRhino.PointAtStart;
Point3d xyzRhinoEnd = arcCurveRhino.PointAtEnd;
Point3d xyzRhinoMid = arcCurveRhino.PointAtNormalizedLength(0.5);
if (arcCurveRhino.IsArc())
{
HbArc hbArcRevit = new HbArc();
hbArcRevit.PointStart = new HbXYZ(xyzRhinoStart.X, xyzRhinoStart.Y, xyzRhinoStart.Z);
hbArcRevit.PointEnd = new HbXYZ(xyzRhinoEnd.X, xyzRhinoEnd.Y, xyzRhinoEnd.Z);
hbArcRevit.PointMid = new HbXYZ(xyzRhinoMid.X, xyzRhinoMid.Y, xyzRhinoMid.Z);
hbCurve = hbArcRevit;
}
return(hbCurve);
}
/// <summary>
/// Test for a curve that is an arc (or looks like an arc).
/// </summary>
private bool IsArc(Curve curve, ref bool bCircle)
{
if (null == curve)
{
return(false);
}
// Is the curve an arc curve?
ArcCurve arc_curve = curve as ArcCurve;
if (null != arc_curve)
{
bCircle = arc_curve.IsCompleteCircle;
return(true);
}
// Is the curve a polycurve that looks like an arc?
// (Should never need to test for this...)
PolyCurve poly_curve = curve as PolyCurve;
if (null != poly_curve)
{
Arc arc;
if (poly_curve.TryGetArc(out arc))
{
bCircle = arc.IsCircle;
return(true);
}
}
// Is the curve a NURBS curve that looks like an arc?
NurbsCurve nurbs_curve = curve as NurbsCurve;
if (null != nurbs_curve)
{
Arc arc;
if (nurbs_curve.TryGetArc(out arc))
{
bCircle = arc.IsCircle;
return(true);
}
}
return(false);
}
public ArcCurve ArcToNative(Arc a)
{
RH.Arc arc = new RH.Arc(PlaneToNative(a.plane), ScaleToNative((double)a.radius, a.units), (double)a.angleRadians);
arc.StartAngle = (double)a.startAngle;
arc.EndAngle = (double)a.endAngle;
if (!arc.IsValid) // try with different method if not valid
{
arc = new RH.Arc(PointToNative(a.startPoint).Location, PointToNative(a.midPoint).Location, PointToNative(a.endPoint).Location);
}
var myArc = new ArcCurve(arc);
if (a.domain != null)
{
myArc.Domain = IntervalToNative(a.domain);
}
return(myArc);
}
bool IGH_TypeHint.Cast(object data, out object target)
{
bool toReturn = base.Cast(data, out target);
if (toReturn &&
_component.DocStorageMode == DocReplacement.DocStorage.AutomaticMarshal &&
target != null)
{
Type t = target.GetType();
if (t == typeof(Circle))
{
target = new ArcCurve((Circle)target);
}
}
return(toReturn);
}
// Arc
// Rh Capture can be a circle OR an arc, because f**k you
public static SpeckleObject ToSpeckle(this ArcCurve a)
{
if (a.IsClosed)
{
Circle preCircle;
a.TryGetCircle(out preCircle);
SpeckleCircle myCircle = preCircle.ToSpeckle();
myCircle.Properties = a.UserDictionary.ToSpeckle();
return(myCircle);
}
else
{
Arc preArc;
a.TryGetArc(out preArc);
SpeckleArc myArc = preArc.ToSpeckle();
myArc.Properties = a.UserDictionary.ToSpeckle();
return(myArc);
}
}
// Arc
// Rh Capture can be a circle OR an arc
public Base ArcToSpeckle(ArcCurve a)
{
if (a.IsClosed)
{
RH.Circle preCircle;
a.TryGetCircle(out preCircle);
Circle myCircle = CircleToSpeckle(preCircle);
myCircle.domain = IntervalToSpeckle(a.Domain);
return(myCircle);
}
else
{
RH.Arc preArc;
a.TryGetArc(out preArc);
Arc myArc = ArcToSpeckle(preArc);
myArc.domain = IntervalToSpeckle(a.Domain);
return(myArc);
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// Create a circle curve
var circle = new Circle(Plane.WorldXY, 5.0);
var curve0 = new ArcCurve(circle);
// Add an instance defintion that uses the circle curve
var attrib = doc.CreateDefaultAttributes();
var idef0_index = doc.InstanceDefinitions.Add("Circle", "Circle", Point3d.Origin, curve0, attrib);
// Create a reference to the instance definition
var idef0_id = doc.InstanceDefinitions[idef0_index].Id;
var iref0 = new InstanceReferenceGeometry(idef0_id, Transform.Identity);
// Create a polyline curve
var rect = new Point3d[5];
rect[0] = new Point3d(-5.0, -5.0, 0.0);
rect[1] = new Point3d(5.0, -5.0, 0.0);
rect[2] = new Point3d(5.0, 5.0, 0.0);
rect[3] = new Point3d(-5.0, 5.0, 0.0);
rect[4] = rect[0];
var curve1 = new PolylineCurve(rect);
// Add another instance definition that uses the polyline curve
// and the instance reference
var geometry = new GeometryBase[] { curve1, iref0 };
var attributes = new[] { attrib, attrib };
var idef1_index = doc.InstanceDefinitions.Add("Rectangle and Circle", "Rectangle and Circle", Point3d.Origin, geometry, attributes);
// Add an instace of the new defintion to the document and redraw
doc.Objects.AddInstanceObject(idef1_index, Transform.Identity);
doc.Views.Redraw();
return(Result.Success);
}
private Topologic.Edge ByArcCurve(ArcCurve ghArcCurve)
{
Rhino.Geometry.NurbsCurve ghNurbsCurve = ghArcCurve.ToNurbsCurve();
return(ByNurbsCurve(ghNurbsCurve));
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// TODO: complete command.
GetObject go = new GetObject();
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
go.EnableSelPrevious(true);
go.EnablePreSelect(true, false);
go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve;
go.SetCommandPrompt("Select All circles you want to filter:");
GetResult result = go.GetMultiple(1, 0);
if (go.CommandResult() != Rhino.Commands.Result.Success)
{
return(go.CommandResult());
}
int fixingHoleCounter = go.ObjectCount;
RhinoApp.WriteLine("circle selection counter = {0}", fixingHoleCounter);
int i = 0;
Point3d[] fixingHole = new Point3d[fixingHoleCounter];
double[] fixingHoleD = new double[fixingHoleCounter];
RhinoObject[] references = new RhinoObject[fixingHoleCounter];
for (i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
Curve curve = (new ObjRef(rhinoObject)).Curve();
if (curve == null)
{
continue;
}
if (curve.IsClosed == false)
{
continue;
}
if (curve.IsPlanar() == false)
{
continue;
}
if (curve.IsCircle())
{
BoundingBox boundingBox = curve.GetBoundingBox(true);
fixingHoleD[i] = boundingBox.Max.X - boundingBox.Min.X;
fixingHole[i] = boundingBox.Center;
references[i] = rhinoObject;
}
}
//Get the gap clearance offset
go.SetCommandPrompt("Enter detection radius:");
go.AcceptNumber(true, false);
go.Get();
double offset = go.Number();
double perforationHoldD;
string layerName = "";
//for testing purpose, draw the hole with offset using red color
/*Curve[] circles = new Curve[fixingHole.Length];
* for (i = 0; i < circles.Length; i++)
* {
*
* circles[i] = new ArcCurve(new Circle(fixingHole[i], offset));
* }
*
*
* if (circles != null)
* {
* layerName = offset + "mm GAP CLEARANCE";
* RhinoUtilities.SetActiveLayer(layerName, System.Drawing.Color.Red);
*
* foreach (Curve cv in circles)
* {
* Guid guid = RhinoDoc.ActiveDoc.Objects.AddCurve(cv);
* }
* }*/
string clashHoleLayerName = "HOLES CLASHED";
Layer clashHoleLayer = new Layer();
clashHoleLayer.Name = clashHoleLayerName;
clashHoleLayer.Color = System.Drawing.Color.Red;
int clashHoleLayerIndex = doc.Layers.Add(clashHoleLayer);
int currentHoleCounter;
int flag;
bool[] deletedCircles = new bool[fixingHole.Length];
for (i = 0; i < deletedCircles.Length; i++)
{
deletedCircles[i] = false;
}
Curve circles;
RhinoUtilities.SetActiveLayer(clashHoleLayerName, System.Drawing.Color.Red);
for (i = 0; i < fixingHole.Length - 1; i++)
{
currentHoleCounter = 0;
flag = 0;
for (int j = i + 1; j < fixingHole.Length; j++)
{
if (deletedCircles[j] == true)
{
continue;
}
if (fixingHole[i].DistanceTo(fixingHole[j]) < fixingHoleD[i] + offset)
{
if (currentHoleCounter == 0)
{
flag = j;
currentHoleCounter++;
}
else
{
currentHoleCounter++;
break;
}
}
if (currentHoleCounter == 1)
{
circles = new ArcCurve(new Circle(fixingHole[flag], fixingHoleD[flag] / 2));
Guid guid = RhinoDoc.ActiveDoc.Objects.AddCurve(circles);
RhinoDoc.ActiveDoc.Objects.Delete(references[flag], false);
deletedCircles[flag] = true;
}
else if (currentHoleCounter == 2)
{
circles = new ArcCurve(new Circle(fixingHole[i], fixingHoleD[i] / 2));
Guid guid = RhinoDoc.ActiveDoc.Objects.AddCurve(circles);
RhinoDoc.ActiveDoc.Objects.Delete(references[i], false);
deletedCircles[i] = true;
}
}
}
RhinoUtilities.setLayerVisibility("HOLES CLASHED", true);
RhinoUtilities.setLayerVisibility(layerName, false);
doc.Views.Redraw();
return(Result.Success);
}
