/// <summary>
/// Converts a point into a GH_Point
/// </summary>
/// <param name="pt">The point to convert</param>
/// <returns>The GH_Point</returns>
public static GH_Point ConvertToGHPoint(Point3d pt)
{
GH_Point ghp = new GH_Point();
bool c = GH_Convert.ToGHPoint(pt, GH_Conversion.Both, ref ghp);
return(ghp);
}
///Projection engines
public static GH_Point ProjectPointToTopo(Mesh topoMesh, Point3d pt)
{
GH_Point ghPoint = new GH_Point();
Ray3d ray = new Ray3d(pt, moveDir);
double t = Rhino.Geometry.Intersect.Intersection.MeshRay(topoMesh, ray);
if (t >= 0.0)
{
GH_Convert.ToGHPoint(ray.PointAt(t), GH_Conversion.Primary, ref ghPoint);
}
else
{
Ray3d rayOpp = new Ray3d(pt, -moveDir);
double tOpp = Rhino.Geometry.Intersect.Intersection.MeshRay(topoMesh, rayOpp);
if (tOpp >= 0.0)
{
GH_Convert.ToGHPoint(rayOpp.PointAt(tOpp), GH_Conversion.Primary, ref ghPoint);
}
else
{
return(null);
}
}
return(ghPoint);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
string path = "";
int lineSkip = 1;
if (!DA.GetData(0, ref path))
{
return;
}
DA.GetData(1, ref recursive);
DA.GetData(2, ref asMesh);
DA.GetData(3, ref lineSkip);
if (lineSkip < 1)
{
lineSkip = 1;
}
try
{
if (oldPath != path)
{
oldPath = path;
geometry = GetGeometricData(path);
}
DataTree <IGH_GeometricGoo> geo = new DataTree <IGH_GeometricGoo>();
foreach (Tuple <int, ConcurrentQueue <IGH_GeometricGoo>, FileTypes> tuple in geometry)
{
switch (tuple.Item3)
{
case FileTypes.XYZ:
if (asMesh)
{
ConcurrentQueue <Point3d> pp = new ConcurrentQueue <Point3d>();
Parallel.ForEach(tuple.Item2, (item, _, iNum) =>
{
if (iNum % lineSkip == 0)
{
GH_Point p = new GH_Point();
if (GH_Convert.ToGHPoint(item, GH_Conversion.Both, ref p))
{
pp.Enqueue(p.Value);
}
}
});
Mesh mesh = new Mesh();
mesh.Vertices.AddVertices(pp);
try
{
Node2List nodes = new Node2List(pp);
List <Face> faces = Solver.Solve_Faces(nodes, 1);
IEnumerable <MeshFace> meshFaces = faces.Select(x => new MeshFace(x.A, x.B, x.C));
mesh.Faces.AddFaces(meshFaces);
ConcurrentQueue <IGH_GeometricGoo> goo = new ConcurrentQueue <IGH_GeometricGoo>();
goo.Enqueue(GH_Convert.ToGeometricGoo(mesh));
geo.AddRange(goo, new GH_Path(tuple.Item1));
}
catch (Exception e)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
}
}
else
{
ConcurrentQueue <IGH_GeometricGoo> goo = new ConcurrentQueue <IGH_GeometricGoo>();
Parallel.ForEach(tuple.Item2, (item, _, iNum) =>
{
if (iNum % lineSkip == 0)
{
goo.Enqueue(item);
}
});
geo.AddRange(goo, new GH_Path(tuple.Item1));
}
break;
}
}
DA.SetDataTree(0, geo);
}
catch (Exception e)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
}
}
public override bool CastTo <Q>(ref Q target)
{
// This function is called when Grasshopper needs to convert this
// instance of GsaLoad into some other type Q.
if (typeof(Q).IsAssignableFrom(typeof(GsaLoad)))
{
if (Value == null)
{
target = default;
}
else
{
target = (Q)(object)Value.Duplicate();
}
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GsaGridPlaneSurfaceGoo)))
{
if (Value == null)
{
target = default;
}
else
{
if (Value.AreaLoad != null)
{
GsaGridPlaneSurface gridplane = Value.AreaLoad.GridPlaneSurface;
GsaGridPlaneSurfaceGoo gpgoo = new GsaGridPlaneSurfaceGoo(gridplane);
target = (Q)(object)gpgoo;
return(true);
}
if (Value.LineLoad != null)
{
GsaGridPlaneSurface gridplane = Value.LineLoad.GridPlaneSurface;
GsaGridPlaneSurfaceGoo gpgoo = new GsaGridPlaneSurfaceGoo(gridplane);
target = (Q)(object)gpgoo;
return(true);
}
if (Value.PointLoad != null)
{
GsaGridPlaneSurface gridplane = Value.PointLoad.GridPlaneSurface;
GsaGridPlaneSurfaceGoo gpgoo = new GsaGridPlaneSurfaceGoo(gridplane);
target = (Q)(object)gpgoo;
return(true);
}
}
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Plane)))
{
if (Value == null)
{
target = default;
}
else
{
if (Value.LoadType == GsaLoad.LoadTypes.GridArea)
{
GH_Plane ghpln = new GH_Plane();
GH_Convert.ToGHPlane(Value.AreaLoad.GridPlaneSurface.Plane, GH_Conversion.Both, ref ghpln);
target = (Q)(object)ghpln;
return(true);
}
if (Value.LoadType == GsaLoad.LoadTypes.GridLine)
{
GH_Plane ghpln = new GH_Plane();
GH_Convert.ToGHPlane(Value.LineLoad.GridPlaneSurface.Plane, GH_Conversion.Both, ref ghpln);
target = (Q)(object)ghpln;
return(true);
}
if (Value.LoadType == GsaLoad.LoadTypes.GridPoint)
{
GH_Plane ghpln = new GH_Plane();
GH_Convert.ToGHPlane(Value.PointLoad.GridPlaneSurface.Plane, GH_Conversion.Both, ref ghpln);
target = (Q)(object)ghpln;
return(true);
}
}
return(false);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Point)))
{
if (Value == null)
{
target = default;
}
else
{
if (Value.LoadType == GsaLoad.LoadTypes.GridPoint)
{
Point3d point = new Point3d
{
X = Value.PointLoad.GridPointLoad.X,
Y = Value.PointLoad.GridPointLoad.Y,
Z = Value.PointLoad.GridPlaneSurface.Plane.OriginZ
};
GH_Point ghpt = new GH_Point();
GH_Convert.ToGHPoint(point, GH_Conversion.Both, ref ghpt);
target = (Q)(object)ghpt;
return(true);
}
}
return(false);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Curve)))
{
if (Value == null)
{
target = default;
}
else
{
if (Value.LoadType == GsaLoad.LoadTypes.GridLine)
{
List <Point3d> pts = new List <Point3d>();
string def = Value.LineLoad.GridLineLoad.PolyLineDefinition; //implement converter
// to be done
//target = (Q)(object)ghpt;
//return true;
}
}
return(false);
}
target = default;
return(false);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
bool IsPointData = false;
GH_Structure <IGH_Goo> data = new GH_Structure <IGH_Goo>();
List <double> eps = new List <double>();
List <int> minP = new List <int>();
if (!DA.GetDataTree(0, out data))
{
return;
}
if (!DA.GetDataList(1, eps))
{
return;
}
if (!DA.GetDataList(2, minP))
{
return;
}
data.Simplify(GH_SimplificationMode.CollapseAllOverlaps);
List <DataSetItemPoint[]> points = new List <DataSetItemPoint[]>();
for (int i = 0; i < data.Branches.Count; i++)
{
DataSetItemPoint[] pp = new DataSetItemPoint[data.Branches[i].Count];
for (int j = 0; j < data.Branches[i].Count; j++)
{
if (data.Branches[i][j] is GH_Point)
{
IsPointData = true;
GH_Point target = new GH_Point();
if (GH_Convert.ToGHPoint(data.Branches[i][j], GH_Conversion.Both, ref target))
{
pp[j] = new DataSetItemPoint(target.Value.X, target.Value.Y, target.Value.Z, 0.0);
}
}
else
{
break;
}
}
if (IsPointData)
{
points.Add(pp);
}
else
{
break;
}
}
// double data
if (!IsPointData)
{
DataSetItemPoint[] pp = new DataSetItemPoint[data.Branches.Count];
for (int i = 0; i < data.Branches.Count; i++)
{
DataSetItemPoint p = new DataSetItemPoint();
for (int j = 0; j < data.Branches[i].Count; j++)
{
if (data.Branches[i][j] is GH_Number)
{
if (GH_Convert.ToDouble(data.Branches[i][j], out double value, GH_Conversion.Both))
{
switch (j)
{
case 0:
p.X = value;
break;
case 1:
p.Y = value;
break;
case 2:
p.Z = value;
break;
case 3:
p.W = value;
break;
}
}
}
}
pp[i] = p;
}
points.Add(pp);
}
if (IsPointData)
{
DataTree <IGH_Goo> output = new DataTree <IGH_Goo>();
for (int i = 0; i < points.Count; i++)
{
DbscanAlgorithm <DataSetItemPoint> dbs = new DbscanAlgorithm <DataSetItemPoint>((x, y) => Math.Sqrt(((x.X - y.X) * (x.X - y.X)) + ((x.Y - y.Y) * (x.Y - y.Y)) + ((x.Z - y.Z) * (x.Z - y.Z)) + ((x.W - y.W) * (x.W - y.W))));
dbs.ComputeClusterDbscan(points[i].ToArray(), eps[i], minP[i], out HashSet <DataSetItemPoint[]> clusters3d);
for (int j = 0; j < clusters3d.Count; j++)
{
ConcurrentQueue <GH_Point> _points = new ConcurrentQueue <GH_Point>();
Parallel.ForEach(clusters3d.ElementAt(j), p =>
{
_points.Enqueue(new GH_Point(new Point3d(p.X, p.Y, p.Z)));
});
output.AddRange(_points.ToList(), new GH_Path(i, j));
}
}
DA.SetDataTree(0, output);
}
else
{
DataTree <GH_Number> output = new DataTree <GH_Number>();
for (int i = 0; i < points.Count; i++)
{
DbscanAlgorithm <DataSetItemPoint> dbs = new DbscanAlgorithm <DataSetItemPoint>((x, y) => Math.Sqrt(((x.X - y.X) * (x.X - y.X)) + ((x.Y - y.Y) * (x.Y - y.Y)) + ((x.Z - y.Z) * (x.Z - y.Z)) + ((x.W - y.W) * (x.W - y.W))));
dbs.ComputeClusterDbscan(points[i].ToArray(), eps[i], minP[i], out HashSet <DataSetItemPoint[]> clusters3d);
for (int j = 0; j < clusters3d.Count; j++)
{
ConcurrentQueue <List <double> > _points = new ConcurrentQueue <List <double> >();
for (int k = 0; k < clusters3d.ElementAt(j).Length; k++)
{
List <GH_Number> ii = new List <GH_Number>();
GH_Number target1 = new GH_Number();
GH_Number target2 = new GH_Number();
GH_Number target3 = new GH_Number();
GH_Number target4 = new GH_Number();
if (GH_Convert.ToGHNumber(clusters3d.ElementAt(j).ElementAt(k).X, GH_Conversion.Both, ref target1))
{
ii.Add(target1);
}
if (GH_Convert.ToGHNumber(clusters3d.ElementAt(j).ElementAt(k).Y, GH_Conversion.Both, ref target2))
{
ii.Add(target2);
}
if (GH_Convert.ToGHNumber(clusters3d.ElementAt(j).ElementAt(k).Z, GH_Conversion.Both, ref target3))
{
ii.Add(target3);
}
if (GH_Convert.ToGHNumber(clusters3d.ElementAt(j).ElementAt(k).W, GH_Conversion.Both, ref target4))
{
ii.Add(target4);
}
output.AddRange(ii, new GH_Path(i, j, k));
}
}
}
DA.SetDataTree(0, output);
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
if (!this.Hidden)
{
try
{
m_display.Clear();
}
catch
{
m_display = new CustomDisplay(true);
}
GH_Structure <IGH_GeometricGoo> geo = new GH_Structure <IGH_GeometricGoo>();
List <Color> colors = new List <Color>();
int style = 4;
int size = 1;
if (!DA.GetDataTree(0, out geo))
{
return;
}
if (!DA.GetDataList(1, colors))
{
return;
}
DA.GetData(2, ref style);
DA.GetData(3, ref size);
try
{
geo.Simplify(GH_SimplificationMode.CollapseAllOverlaps);
if (geo.Branches.Count == colors.Count)
{
for (int i = 0; i < geo.Branches.Count; i++)
{
ConcurrentQueue <Point3d> points = new ConcurrentQueue <Point3d>();
// Testing first object
if (geo.Branches[i][0] is GH_Point)
{
Parallel.ForEach(geo.Branches[i], obj =>
{
if (obj is GH_Point)
{
GH_Point p = new GH_Point();
if (GH_Convert.ToGHPoint(obj, GH_Conversion.Both, ref p))
{
points.Enqueue(new Point3d(p.Value.X, p.Value.Y, p.Value.Z));
}
}
});
}
// Testing for mesh
else if (geo.Branches[i][0].TypeName == "Mesh")
{
Parallel.ForEach(geo.Branches[i], obj =>
{
if (obj.TypeName == "Mesh")
{
Mesh m = new Mesh();
if (GH_Convert.ToMesh(obj, ref m, GH_Conversion.Both))
{
points = new ConcurrentQueue <Point3d>(m.Vertices.ToPoint3dArray());
}
}
});
}
PointStyle pointStyle = (PointStyle)style;
m_display.AddPoints(points, colors[i], pointStyle, size);
}
}
else
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Data input incorrect!");
}
}
catch (Exception e)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
}
}
}
/*******************************************/
public static bool CastToGoo(object value, ref GH_Point target)
{
return(GH_Convert.ToGHPoint(value, GH_Conversion.Both, ref target));
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
List <IGH_GeometricGoo> geo = new List <IGH_GeometricGoo>();
if (!DA.GetDataList(0, geo))
{
return;
}
if (!DA.GetData(1, ref constraint_X))
{
return;
}
if (!DA.GetData(2, ref constraint_Y))
{
return;
}
if (!DA.GetData(3, ref constraint_Z))
{
return;
}
if (!DA.GetData(4, ref constraint_RX))
{
return;
}
if (!DA.GetData(5, ref constraint_RY))
{
return;
}
if (!DA.GetData(6, ref constraint_RZ))
{
return;
}
DA.GetData(7, ref scale);
DataTree <IGH_GeometricGoo> symbols = new DataTree <IGH_GeometricGoo>();
for (int i = 0; i < geo.Count; i++)
{
Point3d p = new Point3d();
if (geo[i] is Point3d)
{
if (!GH_Convert.ToPoint3d(geo[i], ref p, GH_Conversion.Both))
{
return;
}
}
else if (geo[i] is GH_Point)
{
GH_Point ghP = new GH_Point();
if (GH_Convert.ToGHPoint(geo[i], GH_Conversion.Both, ref ghP))
{
p = ghP.Value;
}
else
{
return;
}
}
double radius = scale / 8.0;
Sphere s1 = new Sphere(p, radius);
double pX = radius * Math.Sin(Math.PI / 4) * Math.Cos(Math.PI / 4);
double pY = radius * Math.Sin(Math.PI / 4) * Math.Sin(Math.PI / 4);
double pZ = radius * Math.Cos(Math.PI / 4);
double pX0 = radius * Math.Sin(Math.PI / 4) * Math.Cos(0);
double pY0 = radius * Math.Sin(0) * Math.Sin(Math.PI / 4);
Point3d p01 = new Point3d(p.X - pX0, p.Y - pY0, p.Z - pZ);
Point3d p02 = new Point3d(p.X + pX0, p.Y - pY0, p.Z - pZ);
Point3d p03 = new Point3d(p.X + pX0, p.Y + pY0, p.Z - pZ);
Point3d p04 = new Point3d(p.X - pX0, p.Y + pY0, p.Z - pZ);
Point3d p11 = new Point3d(p.X - pX, p.Y - pY, p.Z - pZ);
Point3d p12 = new Point3d(p.X + pX, p.Y - pY, p.Z - pZ);
Point3d p13 = new Point3d(p.X + pX, p.Y + pY, p.Z - pZ);
Point3d p14 = new Point3d(p.X - pX, p.Y + pY, p.Z - pZ);
Point3d p21 = new Point3d(p.X - scale / 2.0, p.Y - scale / 2.0, p.Z - scale / 2.0);
Point3d p22 = new Point3d(p.X + scale / 2.0, p.Y - scale / 2.0, p.Z - scale / 2.0);
Point3d p23 = new Point3d(p.X + scale / 2.0, p.Y + scale / 2.0, p.Z - scale / 2.0);
Point3d p24 = new Point3d(p.X - scale / 2.0, p.Y + scale / 2.0, p.Z - scale / 2.0);
Line l1 = new Line(p11, p21);
Line l2 = new Line(p12, p22);
Line l3 = new Line(p13, p23);
Line l4 = new Line(p14, p24);
Line l5 = new Line(p21, p22);
Line l6 = new Line(p22, p23);
Line l7 = new Line(p23, p24);
Line l8 = new Line(p24, p21);
Arc a1 = new Arc(p11, p01, p12);
Arc a2 = new Arc(p12, p02, p13);
Arc a3 = new Arc(p13, p03, p14);
Arc a4 = new Arc(p14, p04, p11);
List <Curve> c1 = new List <Curve>()
{
l1.ToNurbsCurve(), l2.ToNurbsCurve(), l5.ToNurbsCurve(), a3.ToNurbsCurve()
};
List <Curve> c2 = new List <Curve>()
{
l2.ToNurbsCurve(), l3.ToNurbsCurve(), l6.ToNurbsCurve(), a2.ToNurbsCurve()
};
List <Curve> c3 = new List <Curve>()
{
l3.ToNurbsCurve(), l4.ToNurbsCurve(), l7.ToNurbsCurve(), a1.ToNurbsCurve()
};
List <Curve> c4 = new List <Curve>()
{
l4.ToNurbsCurve(), l1.ToNurbsCurve(), l8.ToNurbsCurve(), a4.ToNurbsCurve()
};
Brep b1 = Brep.CreateEdgeSurface(c1);
Brep b2 = Brep.CreateEdgeSurface(c2);
Brep b3 = Brep.CreateEdgeSurface(c3);
Brep b4 = Brep.CreateEdgeSurface(c4);
symbols.Add(GH_Convert.ToGeometricGoo(s1), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l1), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l2), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l3), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l4), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l5), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l6), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l7), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(l8), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(b1), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(b2), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(b3), new GH_Path(i));
symbols.Add(GH_Convert.ToGeometricGoo(b4), new GH_Path(i));
}
DA.SetDataTree(0, symbols);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
int i, j, k;
bool IsPointData = false;
GH_Structure <IGH_Goo> data = new GH_Structure <IGH_Goo>();
GH_Structure <IGH_GeometricGoo> geo = new GH_Structure <IGH_GeometricGoo>();
List <int> numCluster = new List <int>();
if (!DA.GetDataTree(0, out data))
{
return;
}
if (!DA.GetDataTree(1, out geo))
{
return;
}
if (!DA.GetDataList(2, numCluster))
{
return;
}
data.Simplify(GH_SimplificationMode.CollapseAllOverlaps);
DataTree <IGH_Goo> outputData = new DataTree <IGH_Goo>();
DataTree <IGH_GeometricGoo> outputGeo = new DataTree <IGH_GeometricGoo>();
DataTree <Point3d> outputCentroids = new DataTree <Point3d>();
for (i = 0; i < data.Branches.Count; i++)
{
double[] x = new double[data.Branches[i].Count];
double[] y = new double[data.Branches[i].Count];
double[] z = new double[data.Branches[i].Count];
for (j = 0; j < data.Branches[i].Count; j++)
{
if (data.Branches[i][j] is GH_Point)
{
IsPointData = true;
GH_Point target = new GH_Point();
if (GH_Convert.ToGHPoint(data.Branches[i][j], GH_Conversion.Both, ref target))
{
x[j] = target.Value.X;
y[j] = target.Value.Y;
z[j] = target.Value.Z;
}
}
else
{
break;
}
}
if (IsPointData)
{
List <double[]> datalist = new List <double[]>
{
x,
y,
z
};
double[][] _data = ArrayConvert.To2DArray(datalist);
KMeans m = new KMeans(numCluster[i]);
KMeansClusterCollection cluster = m.Learn(_data);
int[] labels = cluster.Decide(_data);
double[][] centroids = m.Centroids;
for (j = 0; j < data.Branches[i].Count; j++)
{
GH_Path path = new GH_Path(i, labels[j]);
outputData.Add(data.Branches[i][j], path);
outputGeo.Add(geo.Branches[i][j], path);
}
for (k = 0; k < centroids.Length; k++)
{
outputCentroids.Add(new Point3d(centroids.ElementAt(k).ElementAt(0), centroids.ElementAt(k).ElementAt(1), centroids.ElementAt(k).ElementAt(2)), new GH_Path(k));
}
}
else
{
break;
}
}
if (!IsPointData)
{
GH_Path oldPath = new GH_Path();
GH_Path newPath = new GH_Path();
int DataGroupCount = 0;
for (i = 0; i < data.PathCount; i++)
{
if (data.Paths[i].Indices.Length == 1)
{
DataGroupCount = 1;
break;
}
else
{
int[] pp = new int[data.Paths[i].Indices.Length - 1];
for (j = 0; j < data.Paths[i].Indices.Length - 1; j++)
{
pp[j] = data.Paths[i].Indices[j];
}
newPath.Indices = pp;
if (newPath != oldPath)
{
DataGroupCount++;
oldPath = newPath;
}
newPath = new GH_Path();
}
}
for (i = 0; i < DataGroupCount; i++)
{
List <double[]> datalist = new List <double[]>();
for (j = 0; j < data.Branches.Count / DataGroupCount; j++)
{
double[] values = new double[data.Branches[DataGroupCount * i + j].Count];
for (k = 0; k < data.Branches[DataGroupCount * i + j].Count; k++)
{
if (data.Branches[DataGroupCount * i + j][k] is GH_Number)
{
if (GH_Convert.ToDouble(data.Branches[DataGroupCount * i + j][k], out double value, GH_Conversion.Both))
{
values[k] = value;
}
}
else
{
break;
}
}
datalist.Add(values);
}
double[][] _data = ArrayConvert.ToDoubleArray(datalist);
KMeans m = new KMeans(numCluster[0]);
KMeansClusterCollection cluster = m.Learn(_data);
int[] labels = cluster.Decide(_data);
for (j = 0; j < labels.Length; j++)
{
List <IGH_Goo> numbers = new List <IGH_Goo>();
List <IGH_GeometricGoo> geos = new List <IGH_GeometricGoo>();
for (k = 0; k < data.Branches[DataGroupCount * i + j].Count; k++)
{
numbers.Add(data.Branches[DataGroupCount * i + j][k]);
geos.Add(geo.Branches[DataGroupCount * i + j][k]);
}
GH_Path path = new GH_Path(i, j, labels[j]);
outputData.AddRange(numbers, path);
outputGeo.AddRange(geos, path);
}
}
}
DA.SetDataTree(0, outputData);
DA.SetDataTree(1, outputGeo);
DA.SetDataTree(2, outputCentroids);
}
