private GH_Structure <IGH_Goo> SingleDataStructrue(object value)
{
if (value is string path)
{
if (File.Exists(path) && Path.GetExtension(path) == ".noahdata")
{
byte[] array;
try
{
array = File.ReadAllBytes(path);
}
catch
{
return(null);
}
return(IO.DeserializeGrasshopperData(array));
}
}
GH_Structure <IGH_Goo> m_data = new GH_Structure <IGH_Goo>();
GH_Number castNumber = null;
GH_String castString = null;
GH_Curve castCurve = null;
if (GH_Convert.ToGHCurve(value, GH_Conversion.Both, ref castCurve))
{
m_data.Append(new GH_ObjectWrapper(castCurve));
}
else if (GH_Convert.ToGHNumber(value, GH_Conversion.Both, ref castNumber))
{
m_data.Append(new GH_ObjectWrapper(castNumber));
}
else if (GH_Convert.ToGHString(value, GH_Conversion.Both, ref castString))
{
m_data.Append(new GH_ObjectWrapper(castString));
}
else
{
m_data.Append((IGH_Goo)value);
}
return(m_data);
}
protected override void CollectVolatileData_Custom()
{
m_data.Clear();
string k = NickName;
var script = PythonScript.Create();
script.ExecuteScript("import scriptcontext as sc\nif sc.sticky.has_key('" + k + "'):\t\t\t\tV = sc.sticky['" + k + "']\nelse : V = 0");
object value = script.GetVariable("V");
GH_Number castNumber = null;
GH_String castString = null;
if (GH_Convert.ToGHNumber(value, GH_Conversion.Both, ref castNumber))
{
m_data.Append(new GH_ObjectWrapper(castNumber));
}
else if (GH_Convert.ToGHString(value, GH_Conversion.Both, ref castString))
{
m_data.Append(new GH_ObjectWrapper(castString));
}
else
{
m_data.Append((IGH_Goo)value);
}
}
public static void AssignDataToDoc(string dataSetJson)
{
JObject dataSet = JsonConvert.DeserializeObject <JObject>(dataSetJson);
GH_Canvas activeCanvas = Instances.ActiveCanvas;
if (activeCanvas == null)
{
throw new Exception("读取文档失败");
}
GH_Document doc = activeCanvas.Document;
if (doc == null)
{
return;
}
var hooks = doc.ClusterInputHooks();
foreach (var hook in hooks)
{
GH_Structure <IGH_Goo> m_data;
string key = hook.NickName;
if (string.IsNullOrEmpty(key))
{
key = hook.Name;
}
if (string.IsNullOrEmpty(key))
{
key = hook.CustomName;
}
if (string.IsNullOrEmpty(key))
{
key = hook.CustomNickName;
}
if (!key.StartsWith("@", StringComparison.Ordinal))
{
continue;
}
key = key.Substring(1);
if (!dataSet.TryGetValue(key, out var data))
{
continue;
}
m_data = SingleDataStructrue(data);
hook.ClearPlaceholderData();
hook.SetPlaceholderData(m_data);
//hook.ExpireSolution(true);
}
// for data placeholder inside cluster (deep = 1)
var clusters = new List <GH_Cluster>();
foreach (var obj in doc.Objects)
{
if (!(obj is GH_Cluster cluster))
{
continue;
}
clusters.Add(cluster);
}
if (clusters.Count == 0)
{
return;
}
foreach (var cluster in clusters)
{
foreach (var obj in cluster.Document("").Objects)
{
if (!(obj is IGH_Param param))
{
continue;
}
string nickname = param.NickName;
if (string.IsNullOrEmpty(nickname))
{
nickname = param.Name;
}
if (!nickname.StartsWith("@", StringComparison.Ordinal))
{
continue;
}
nickname = nickname.Substring(1);
if (!dataSet.TryGetValue(nickname, out var data))
{
continue;
}
Utility.InvokeMethod(param, "Script_ClearPersistentData");
Utility.InvokeMethod(param, "Script_AddPersistentData", new List <object>()
{
data
});
//param.ExpireSolution(true);
//cluster.ExpireSolution(true);
}
}
doc.NewSolution(true);
activeCanvas.Document.IsModified = false;
activeCanvas.Refresh();
GH_Structure <IGH_Goo> SingleDataStructrue(object value)
{
GH_Structure <IGH_Goo> m_data = new GH_Structure <IGH_Goo>();
GH_Number castNumber = null;
GH_String castString = null;
GH_Curve castCurve = null;
if (GH_Convert.ToGHCurve(value, GH_Conversion.Both, ref castCurve))
{
m_data.Append(new GH_ObjectWrapper(castCurve));
}
else if (GH_Convert.ToGHNumber(value, GH_Conversion.Both, ref castNumber))
{
m_data.Append(new GH_ObjectWrapper(castNumber));
}
else if (GH_Convert.ToGHString(value, GH_Conversion.Both, ref castString))
{
m_data.Append(new GH_ObjectWrapper(castString));
}
else
{
m_data.Append((IGH_Goo)value);
}
return(m_data);
}
}
/// <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);
}
}
/*******************************************/
public static bool CastToGoo(object value, ref GH_Number target)
{
return(GH_Convert.ToGHNumber(value, GH_Conversion.Both, ref target));
}
