/// <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) { Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(); if (!DA.GetData(0, ref mesh)) { return; } if (!mesh.IsValid) { return; } // call the cpp function to solve the adjacency list var res = IGLRhinoCommon.Utils.getAdjacencyLst(ref mesh); // construct the index & pt tree from the adjacency list Grasshopper.DataTree <int> treeArray = new Grasshopper.DataTree <int>(); Grasshopper.DataTree <Point3d> ptArray = new Grasshopper.DataTree <Point3d>(); for (int i = 0; i < res.Count; i++) { var path = new Grasshopper.Kernel.Data.GH_Path(i); treeArray.AddRange(res[i], path); foreach (var id in res[i]) { ptArray.Add(mesh.Vertices[id], path); } } // assign to the output DA.SetDataTree(0, treeArray); DA.SetDataTree(1, ptArray); }
protected override void SolveInstance(IGH_DataAccess DA) { string p = ""; bool b = false; List <string> sheets = new List <string>(); if (!DA.GetData(0, ref p)) { return; } if (!DA.GetDataList(1, sheets)) { return; } if (!DA.GetData(2, ref b)) { return; } if (b) { // Get raw data List <string[, ]> data = new List <string[, ]>(); if (sheets.Count == 1 && sheets[0] == _allSheets) { data = ExcelTools.ExcelUtilities.GetAllData2(p); } else { data = ExcelTools.ExcelUtilities.GetAllData2(p, sheets); } // Sort data into tree structure Grasshopper.DataTree <string> dt = new Grasshopper.DataTree <string>(); Grasshopper.Kernel.Data.GH_Path pth; int pCount = 0; foreach (string[,] dataSheet in data) { for (int i = 0; i < dataSheet.GetLength(0); i++) { pth = new Grasshopper.Kernel.Data.GH_Path(pCount, i); for (int j = 0; j < dataSheet.GetLength(1); j++) { dt.Add(dataSheet[i, j], pth); } } pCount++; } DA.SetDataTree(0, dt); } }
public void SetComponentOutputs(Schema schema, IGH_DataAccess DA, List <IGH_Param> outputParams, GH_ActiveObject component) { foreach (var datatree in schema.Values) { string outputParamName = datatree.ParamName; if (outputParamName.StartsWith("RH_OUT:")) { var chunks = outputParamName.Split(new char[] { ':' }); outputParamName = chunks[chunks.Length - 1]; } int paramIndex = 0; for (int i = 0; i < outputParams.Count; i++) { if (outputParams[i].Name.Equals(outputParamName)) { paramIndex = i; break; } } var structure = new Grasshopper.Kernel.Data.GH_Structure <Grasshopper.Kernel.Types.IGH_Goo>(); foreach (var kv in datatree.InnerTree) { var tokens = kv.Key.Trim(new char[] { '{', '}' }).Split(';'); List <int> elements = new List <int>(); foreach (var token in tokens) { if (!string.IsNullOrWhiteSpace(token)) { elements.Add(int.Parse(token)); } } var path = new Grasshopper.Kernel.Data.GH_Path(elements.ToArray()); for (int gooIndex = 0; gooIndex < kv.Value.Count; gooIndex++) { var goo = GooFromReshopperObject(kv.Value[gooIndex]); structure.Insert(goo, path, gooIndex); } } DA.SetDataTree(paramIndex, structure); } foreach (var error in schema.Errors) { component.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, error); } foreach (var warning in schema.Warnings) { component.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, warning); } }
/// <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) { // INPUT // declaration string _XML = String.Empty; List <string> _tagName = new List <string>(); DA.GetData(0, ref _XML); DA.GetDataList(1, _tagName); // actions XmlDocument xmlDoc = new XmlDocument(); //declare tree Grasshopper.DataTree <string> intTree = new Grasshopper.DataTree <string>(); xmlDoc.LoadXml(_XML); if (_tagName != null) { try { //set up tree for (int i = 0; i < _tagName.Count; i++) { Grasshopper.Kernel.Data.GH_Path pth = new Grasshopper.Kernel.Data.GH_Path(i); var innerTextData = xmlDoc.GetElementsByTagName(_tagName[i])[0].InnerText; intTree.Add(innerTextData, pth); } // output DA.SetDataTree(0, intTree); } catch { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Please provide a valid keyword."); return; } } }
/// <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) { Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(); List <int> con_idx = new List <int>(); List <double> con_val = new List <double>(); int divN = 1; if (!DA.GetData(0, ref mesh)) { return; } if (!mesh.IsValid) { return; } if (!DA.GetDataList(1, con_idx)) { return; } if (!DA.GetDataList(2, con_val)) { return; } if (!(con_idx.Count > 0) || !(con_val.Count > 0)) { return; } if (con_idx.Count != con_val.Count) { return; } // TODO: add warning message if (!DA.GetData(3, ref divN)) { return; } // call the cpp function to solve the adjacency list var res = IGLRhinoCommon.Utils.getIsolinePts(ref mesh, ref con_idx, ref con_val, divN); // construct the index & pt tree from the adjacency list Grasshopper.DataTree <Point3d> ptTree = new Grasshopper.DataTree <Point3d>(); Grasshopper.DataTree <Curve> crvTree = new Grasshopper.DataTree <Curve>(); for (int i = 0; i < res.Count; i++) { var path = new Grasshopper.Kernel.Data.GH_Path(i); ptTree.AddRange(res[i], path); // if has move than 2 pts, interpolate curves if (res[i].Count > 3) { var crv = Curve.CreateInterpolatedCurve(res[i], 3); crvTree.Add(crv, path); } else if (res[i].Count > 2) { var crv = Curve.CreateInterpolatedCurve(res[i], 2); crvTree.Add(crv, path); } } // assign to the output DA.SetDataTree(0, crvTree); DA.SetDataTree(1, ptTree); }
protected override void SolveInstance(IGH_DataAccess DA) { List<DHr> hours = new List<DHr>(); List<String> keys = new List<string>(); if (DA.GetDataList(0, hours) && DA.GetDataList(1, keys)) { if ((hours[0].is_surrogate) && ((hours.Count != 1) && (hours.Count != 12) && (hours.Count != 52) && (hours.Count != 365))) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "This component can only plot unmasked surrogate hours for yearly, monthly, weekly, and daily statistics"); } Interval ival_y = new Interval(); bool calc_ival_y = false; if (!(DA.GetData(2, ref ival_y))) { ival_y.T0 = hours[0].val(keys[0]); ival_y.T1 = hours[0].val(keys[0]); calc_ival_y = true; } Dictionary<string, float[]> val_dict = new Dictionary<string, float[]>(); List<Interval> val_ranges = new List<Interval>(); foreach (string key in keys) { Interval ival = new Interval(); float[] vals = new float[0]; DHr.get_domain(key, hours.ToArray(), ref vals, ref ival); vals = new float[hours.Count]; for (int h = 0; h < hours.Count; h++) vals[h] = hours[h].val(key); val_dict.Add(key, vals); val_ranges.Add(ival); } bool force_start_at_zero = true; int stack_dir = StackDirection(val_ranges[0]); if (stack_dir==0) this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The first key returned nothing but zero values. I can't deal!"); foreach (Interval ival in val_ranges) { if (StackDirection(ival) != stack_dir) this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "A stacked graph can only handle all negative or all positive numbers."); if (calc_ival_y) { if (stack_dir < 1) { if (ival.T1 > ival_y.T0) ival_y.T0 = ival.T1; if (ival.T0 < ival_y.T1) ival_y.T1 = ival.T0; } else { if (ival.T0 < ival_y.T0) ival_y.T0 = ival.T0; if (ival.T1 > ival_y.T1) ival_y.T1 = ival.T1; } } } if (force_start_at_zero && calc_ival_y) ival_y.T0 = 0; Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Interval> intervalTreeOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Interval>(); intervalTreeOut.Append(new Grasshopper.Kernel.Types.GH_Interval(ival_y),new Grasshopper.Kernel.Data.GH_Path(0)); foreach (Interval ival in val_ranges) intervalTreeOut.Append(new Grasshopper.Kernel.Types.GH_Interval(ival), new Grasshopper.Kernel.Data.GH_Path(1)); Plane plane = new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, 1)); DA.GetData(3, ref plane); Grasshopper.Kernel.Types.UVInterval ival2d = new Grasshopper.Kernel.Types.UVInterval(); if (!DA.GetData(4, ref ival2d)) { ival2d.U0 = 0.0; ival2d.U1 = 12.0; ival2d.V0 = 0.0; ival2d.V1 = 1.0; } double barWidth = 1.0; DA.GetData(5, ref barWidth); Grasshopper.Kernel.Data.GH_Structure<DHr> hourTreeOut = new Grasshopper.Kernel.Data.GH_Structure<DHr>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Point> pointTreeOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Point>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Rectangle> rectTreeOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Rectangle>(); List<Point3d> basepoints = new List<Point3d>(); for (int h = 0; h < hours.Count; h++) { Point3d gpt = GraphPoint(hours[h].hr, 0.0f, plane, ival_y, ival2d); Point3d wpt = plane.PointAt(gpt.X, 0.0); basepoints.Add(wpt); } for (int k = 0; k < keys.Count; k++) { Grasshopper.Kernel.Data.GH_Path key_path = new Grasshopper.Kernel.Data.GH_Path(k); List<Point3d> points = new List<Point3d>(); List<Rectangle3d> rects = new List<Rectangle3d>(); for (int h = 0; h < hours.Count; h++) { float val = val_dict[keys[k]][h]; for (int kk = 0; kk < k; kk++) val += val_dict[keys[kk]][h]; // add in all previous values Point3d gpt = GraphPoint(hours[h].hr, val, plane, ival_y, ival2d); // returns a point in graph coordinates hours[h].pos = gpt; // the hour records the point in graph coordinates hourTreeOut.Append(new DHr(hours[h]), key_path); Point3d wpt = plane.PointAt(gpt.X, gpt.Y); points.Add(wpt); // adds this point in world coordinates Interval ival_gx; // interval of horz space occupied by this hour in graphic units Interval ival_gy = new Interval(ival2d.V0, gpt.Y); // interval of vertical space occupied by this hour in graphic units if (!hours[h].is_surrogate) { double delta_x2 = (Math.Abs(ival2d.U.Length) / 8760 / 2.0); ival_gx = new Interval(gpt.X - delta_x2, gpt.X + delta_x2); // interval of horz space occupied by this hour in graphic units } else { // if we've been passed surrogate hours, the spacing between bars may not be consistant // we assume we've been given an hour at the start of the range represented double ival_gx_0 = gpt.X; double ival_gx_1; if (h < hours.Count - 1) { Point3d pt_next = GraphPoint(hours[h + 1].hr, val_dict[keys[k]][h + 1], plane, ival_y, ival2d); ival_gx_1 = gpt.X + (pt_next.X - gpt.X) * barWidth; } else { ival_gx_1 = gpt.X + (ival2d.U1 - gpt.X) * barWidth; } ival_gx = new Interval(ival_gx_0, ival_gx_1); if (hours.Count == 1) ival_gx = ival2d.U; } Rectangle3d rect = new Rectangle3d(plane, ival_gx, ival_gy); rects.Add(rect); } List<Grasshopper.Kernel.Types.GH_Point> gh_points = new List<Grasshopper.Kernel.Types.GH_Point>(); foreach (Point3d pt in points) gh_points.Add(new Grasshopper.Kernel.Types.GH_Point(pt)); pointTreeOut.AppendRange(gh_points, key_path); List<Grasshopper.Kernel.Types.GH_Rectangle> gh_rects = new List<Grasshopper.Kernel.Types.GH_Rectangle>(); foreach (Rectangle3d rec in rects) gh_rects.Add(new Grasshopper.Kernel.Types.GH_Rectangle(rec)); rectTreeOut.AppendRange(gh_rects, key_path); } DA.SetDataTree(0, hourTreeOut); DA.SetDataTree(1, intervalTreeOut); DA.SetDataTree(2, pointTreeOut); DA.SetDataList(3, basepoints); DA.SetDataTree(4, rectTreeOut); } }
protected override void SolveInstance(IGH_DataAccess DA) { Grasshopper.Kernel.Data.GH_Structure<DHr> hourTreeIn = new Grasshopper.Kernel.Data.GH_Structure<DHr>(); if (DA.GetDataTree(0, out hourTreeIn)) { Plane plane = new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, 1)); DA.GetData(1, ref plane); Grasshopper.Kernel.Types.UVInterval ival2d = new Grasshopper.Kernel.Types.UVInterval(); if (!DA.GetData(2, ref ival2d)) { ival2d.U0 = 0.0; ival2d.U1 = 1.0; ival2d.V0 = 0.0; ival2d.V1 = 2.0; } if (ival2d.U.IsDecreasing) ival2d.U.Swap(); if (ival2d.V.IsDecreasing) ival2d.V.Swap(); double barWidthScale = 1.0; DA.GetData(3, ref barWidthScale); Grasshopper.Kernel.Data.GH_Structure<DHr> hourTreeOut = new Grasshopper.Kernel.Data.GH_Structure<DHr>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Point> points = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Point>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Rectangle> srects = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Rectangle>(); List<Rectangle3d> rects = new List<Rectangle3d>(); List<Mesh> meshes = new List<Mesh>(); int i = 0;//keeps track of which branch we're on... note, this assumes we've been passed a list of lists and nothing 'deeper' int maxHourCount = hourTreeIn.Branches[0].Count; foreach (List<DHr> hourList in hourTreeIn.Branches) if (hourList.Count > maxHourCount) maxHourCount = hourList.Count; Rectangle3d brect = new Rectangle3d(plane, new Interval(0, ival2d.U1), new Interval(0, ival2d.V.ParameterAt((double)hourTreeIn.DataCount / maxHourCount))); DA.SetData(5, brect); double dx = ival2d.U.Length / hourTreeIn.Branches.Count * barWidthScale; double dy = ival2d.V.Length / maxHourCount; foreach (List<DHr> hourList in hourTreeIn.Branches) { Grasshopper.Kernel.Data.GH_Path path = new Grasshopper.Kernel.Data.GH_Path(i); hourTreeOut.EnsurePath(path); points.EnsurePath(path); srects.EnsurePath(path); double x = ival2d.U.ParameterAt((i + 0.5) / hourTreeIn.Branches.Count); for (int j = 0; j < hourList.Count; j++) { DHr dhour = hourList[j]; double y = ival2d.V.ParameterAt((j + 0.5) / maxHourCount); Point3d pt = plane.PointAt(x, y); dhour.pos = new Point3d(x, y, 0); points.Append(new Grasshopper.Kernel.Types.GH_Point(pt), path); hourTreeOut.Append(dhour, path); Plane pln = new Plane(plane); pln.Origin = plane.PointAt(x - dx / 2, y - dy / 2); Rectangle3d rct = new Rectangle3d(pln, dx, dy); srects.Append(new Grasshopper.Kernel.Types.GH_Rectangle(rct), path); } // make meshes & big rectangles if (hourList.Count > 0) { Mesh mesh = new Mesh(); // add bottom pts mesh.Vertices.Add(plane.PointAt(x - dx / 2, 0)); mesh.VertexColors.Add(hourList[0].color); mesh.Vertices.Add(plane.PointAt(x + dx / 2, 0)); mesh.VertexColors.Add(hourList[0].color); for (int j = 0; j < hourList.Count; j++) { double y = ival2d.V.ParameterAt((j + 0.5) / maxHourCount); mesh.Vertices.Add(plane.PointAt(x - dx / 2, y)); mesh.VertexColors.Add(hourList[j].color); mesh.Vertices.Add(plane.PointAt(x + dx / 2, y)); mesh.VertexColors.Add(hourList[j].color); } // add top pts double yy = ival2d.V.ParameterAt((float)hourList.Count / maxHourCount); mesh.Vertices.Add(plane.PointAt(x - dx / 2, yy)); mesh.VertexColors.Add(hourList[hourList.Count - 1].color); mesh.Vertices.Add(plane.PointAt(x + dx / 2, yy)); mesh.VertexColors.Add(hourList[hourList.Count - 1].color); for (int n = 2; n < mesh.Vertices.Count; n = n + 2) mesh.Faces.AddFace(n - 2, n - 1, n + 1, n); meshes.Add(mesh); Plane pln = new Plane(plane); pln.Origin = plane.PointAt(x - dx / 2, 0); Rectangle3d rct = new Rectangle3d(pln, dx, yy); rects.Add(rct); } i++; } DA.SetDataTree(0, hourTreeOut); DA.SetDataTree(1, points); DA.SetDataList(2, srects); DA.SetDataList(3, rects); DA.SetDataList(4, meshes); } }
protected override void SolveInstance(IGH_DataAccess DA) { Grasshopper.Kernel.Data.GH_Structure<DHr> hourTreeIn = new Grasshopper.Kernel.Data.GH_Structure<DHr>(); String key = ""; if (DA.GetDataTree(0, out hourTreeIn) && DA.GetData(1, ref key)) { Interval ival_y = new Interval(); float[] garbage = new float[0]; if (!(DA.GetData(2, ref ival_y))) DHr.get_domain(key, hourTreeIn.ToArray(), ref garbage, ref ival_y); // vals are no good here, we would need a tree of values Plane plane = new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, 1)); DA.GetData(3, ref plane); Grasshopper.Kernel.Types.UVInterval ival2d = new Grasshopper.Kernel.Types.UVInterval(); if (!DA.GetData(4, ref ival2d)) { ival2d.U0 = 0.0; ival2d.U1 = 12.0; ival2d.V0 = 0.0; ival2d.V1 = 1.0; } double barWidth = 1.0; DA.GetData(5, ref barWidth); Grasshopper.Kernel.Data.GH_Structure<DHr> hourTreeOut = new Grasshopper.Kernel.Data.GH_Structure<DHr>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Point> points = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Point>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Rectangle> rects = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Rectangle>(); double ival2d_u_delta = ival2d.U.Length / hourTreeIn.Branches.Count; for (int b = 0; b < hourTreeIn.Branches.Count; b++) { List<DHr> hours = hourTreeIn.Branches[b]; Grasshopper.Kernel.Data.GH_Path path = new Grasshopper.Kernel.Data.GH_Path(b); hourTreeOut.EnsurePath(path); points.EnsurePath(path); rects.EnsurePath(path); Grasshopper.Kernel.Types.UVInterval ival2d_sub = new Grasshopper.Kernel.Types.UVInterval(new Interval(b * ival2d_u_delta, (b + 1) * ival2d_u_delta), ival2d.V); double t0_sub = ival2d_sub.U.Mid - (ival2d_sub.U.Mid - ival2d_sub.U.T0) * barWidth; double t1_sub = ival2d_sub.U.Mid + (ival2d_sub.U.T1 - ival2d_sub.U.Mid) * barWidth; ival2d_sub.U = new Interval(t0_sub, t1_sub); for (int h = 0; h < hours.Count; h++) { Point3d gpt = GraphPoint(hours[h].hr % 24, hours[h].val(key), plane, ival_y, ival2d_sub); // returns a point in graph coordinates hours[h].pos = gpt; // the hour records the point in graph coordinates hourTreeOut.Append(hours[h], path); Point3d wpt = plane.PointAt(gpt.X, gpt.Y); points.Append(new Grasshopper.Kernel.Types.GH_Point(wpt), path); // adds this point in world coordinates double delta_x2 = (Math.Abs(ival2d_sub.U.Length) / 24.0 / 2.0); Interval ival_gx = new Interval(gpt.X - delta_x2, gpt.X + delta_x2); // interval of horz space occupied by this hour in graphic units Interval ival_gy = new Interval(ival2d_sub.V0, gpt.Y); // interval of vertical space occupied by this hour in graphic units Rectangle3d rect = new Rectangle3d(plane, ival_gx, ival_gy); rects.Append(new Grasshopper.Kernel.Types.GH_Rectangle(rect), path); } } DA.SetDataTree(0, hourTreeOut); DA.SetDataTree(1, points); DA.SetDataTree(2, rects); } }
/// <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) { Mesh mshin = new Mesh(); if (!DA.GetData(0, ref mshin)) { return; } CResults results = null; if (!DA.GetData(1, ref results)) { return; } int outputType = 0; if (!DA.GetData(2, ref outputType)) { outputType = 0; } Grasshopper.DataTree <double> avgI = new Grasshopper.DataTree <double>(); List <double> areas = new List <double>(); MeshFaceList mshfaces = mshin.Faces; for (int m = 0; m < mshfaces.Count; m++) { MeshFace fc = mshfaces[m]; int spA = fc.A; int spB = fc.B; int spC = fc.C; int spD = fc.D; int intvert = 3; double quadmulti = 0; if (fc.IsQuad) { intvert = 4; quadmulti = 1; } Grasshopper.Kernel.Data.GH_Path ghpath = new Grasshopper.Kernel.Data.GH_Path(m); List <double> sp_I = new List <double>(); switch (outputType) { case 0: avgI.Add((results.I_total[spA] + results.I_total[spB] + results.I_total[spC] + (results.I_total[spD] * quadmulti)) / intvert, ghpath); break; case 1: avgI.Add((results.Ib_total[spA] + results.Ib_total[spB] + results.Ib_total[spC] + (results.Ib_total[spD] * quadmulti)) / intvert, ghpath); break; case 2: avgI.Add((results.Id_total[spA] + results.Id_total[spB] + results.Id_total[spC] + (results.Id_total[spD] * quadmulti)) / intvert, ghpath); break; case 3: for (int t = 0; t < results.I_hourly.ColumnCount; t++) { avgI.Add((results.I_hourly[spA, t] + results.I_hourly[spB, t] + results.I_hourly[spC, t] + (results.I_hourly[spD, t] * quadmulti)) / intvert, ghpath); } break; case 4: for (int t = 0; t < results.Ib_hourly.ColumnCount; t++) { avgI.Add((results.Ib_hourly[spA, t] + results.Ib_hourly[spB, t] + results.Ib_hourly[spC, t] + (results.Ib_hourly[spD, t] * quadmulti)) / intvert, ghpath); } break; case 5: for (int t = 0; t < results.Id_hourly.ColumnCount; t++) { avgI.Add((results.Id_hourly[spA, t] + results.Id_hourly[spB, t] + results.Id_hourly[spC, t] + (results.Id_hourly[spD, t] * quadmulti)) / intvert, ghpath); } break; case 6: for (int t = 0; t < results.Ib_hourly.ColumnCount; t++) { int shdwcount = 0; if (results.Ib_hourly[spA, t] == 0) { shdwcount++; } if (results.Ib_hourly[spB, t] == 0) { shdwcount++; } if (results.Ib_hourly[spC, t] == 0) { shdwcount++; } if (results.Ib_hourly[spD, t] == 0) { shdwcount++; } if (shdwcount > 1) { avgI.Add(0, ghpath); } else { avgI.Add(1, ghpath); } } break; } areas.Add(CMisc.getMeshFaceArea(m, mshin)); } DA.SetDataTree(0, avgI); DA.SetDataList(1, areas); }
protected override void SolveInstance(IGH_DataAccess DA) { List<DHr> dhrs = new List<DHr>(); string key_u = ""; string key_v = ""; Interval subdivs = new Interval(); if ((DA.GetDataList(0, dhrs)) && (DA.GetData(1, ref key_u)) && (DA.GetData(2, ref key_v)) && (DA.GetData(4, ref subdivs))) { int subdivs_u = (int) Math.Floor(subdivs.T0); int subdivs_v = (int) Math.Floor(subdivs.T1); Grasshopper.Kernel.Types.UVInterval ival_overall = new Grasshopper.Kernel.Types.UVInterval(); if (!DA.GetData(3, ref ival_overall)) { // go thru the given hours and find the max and min value for the given key Interval ival_temp_u = new Interval(MDHr.INVALID_VAL, MDHr.INVALID_VAL); Interval ival_temp_v = new Interval(MDHr.INVALID_VAL, MDHr.INVALID_VAL); foreach (DHr dhr in dhrs) { float val_u = dhr.val(key_u); float val_v = dhr.val(key_v); if ((ival_temp_u.T0 == MDHr.INVALID_VAL) || (val_u < ival_temp_u.T0)) ival_temp_u.T0 = val_u; if ((ival_temp_u.T1 == MDHr.INVALID_VAL) || (val_u > ival_temp_u.T1)) ival_temp_u.T1 = val_u; if ((ival_temp_v.T0 == MDHr.INVALID_VAL) || (val_v < ival_temp_v.T0)) ival_temp_v.T0 = val_v; if ((ival_temp_v.T1 == MDHr.INVALID_VAL) || (val_v > ival_temp_v.T1)) ival_temp_v.T1 = val_v; } } bool cull_outliers = false; DA.GetData(5, ref cull_outliers); Grasshopper.Kernel.Data.GH_Structure<DHr> hrsOut = new Grasshopper.Kernel.Data.GH_Structure<DHr>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Integer> freqOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Integer>(); Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Interval2D> ivalsOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_Interval2D>(); if (ival_overall.U.IsDecreasing) ival_overall.U.Swap(); if (ival_overall.V.IsDecreasing) ival_overall.V.Swap(); double delta_u = ival_overall.U.Length / subdivs_u; double delta_v = ival_overall.V.Length / subdivs_v; for (int u = 0; u < subdivs_u; u++) { for (int v = 0; v < subdivs_v; v++) { Grasshopper.Kernel.Data.GH_Path path = new Grasshopper.Kernel.Data.GH_Path(new int[] { u, v }); ivalsOut.EnsurePath(path); hrsOut.EnsurePath(path); Interval sub_u = new Interval(ival_overall.U.T0 + u * delta_u, ival_overall.U.T0 + ((u + 1) * delta_u)); Interval sub_v = new Interval(ival_overall.V.T0 + v * delta_v, ival_overall.V.T0 + ((v + 1) * delta_v)); Grasshopper.Kernel.Types.UVInterval sub_uv = new Grasshopper.Kernel.Types.UVInterval(sub_u, sub_v); Grasshopper.Kernel.Types.GH_Interval2D i2d = new Grasshopper.Kernel.Types.GH_Interval2D(); i2d.Value = sub_uv; ivalsOut.Append(i2d, path); } } foreach (DHr dhr in dhrs) { int[] address = new int[] { -1 , -1}; for (int u = 0; u < subdivs_u; u++) { Grasshopper.Kernel.Data.GH_Path path_u = new Grasshopper.Kernel.Data.GH_Path(new int[] { u, 0 }); Interval sub_u = ivalsOut.get_DataItem(path_u, 0).Value.U; double val = dhr.val(key_u); if ((sub_u.IncludesParameter(val)) || ((!cull_outliers) && (u == 0) && (val <= sub_u.Min)) || ((!cull_outliers) && (u == subdivs_u - 1) && (val >= sub_u.Max))) { address[0] = u; break; } } for (int v = 0; v < subdivs_v; v++) { Grasshopper.Kernel.Data.GH_Path path_v = new Grasshopper.Kernel.Data.GH_Path(new int[] { 0, v }); Interval sub_v = ivalsOut.get_DataItem(path_v, 0).Value.V; double val = dhr.val(key_v); if ((sub_v.IncludesParameter(val)) || ((!cull_outliers) && (v == 0) && (val <= sub_v.Min)) || ((!cull_outliers) && (v == subdivs_v - 1) && (val >= sub_v.Max))) { address[1] = v; break; } } if ((address[0] < 0) || (address[1] < 0)) { if (!cull_outliers) this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Crud. Could not place an outlier into any intervals. What gives?!"); } else { Grasshopper.Kernel.Data.GH_Path path = new Grasshopper.Kernel.Data.GH_Path(address); hrsOut.Append(dhr, path); } } foreach (Grasshopper.Kernel.Data.GH_Path path in hrsOut.Paths) { int n = hrsOut.get_Branch(path).Count; freqOut.Append(new Grasshopper.Kernel.Types.GH_Integer(n), path); } DA.SetDataTree(0, freqOut); DA.SetDataTree(1, ivalsOut); DA.SetDataTree(2, hrsOut); } }
protected override void SolveInstance(IGH_DataAccess DA) { AWorld refwrld = new AWorld(); List<double> v_list = new List<double>(); //GH_Dict test = GH_Dict.create("a", 1.0); //if (!DA.GetData(0, ref refwrld) || !refwrld.IsValid) return; //AWorld wrld = new AWorld(refwrld); SpatialGraph gph = new SpatialGraph(); if (!DA.GetData(0, ref gph)) return; int nGen = 0; string pyString = ""; if (!DA.GetData(1, ref pyString)) return; if (!DA.GetDataList(2, v_list)) return; if (!DA.GetData(3, ref nGen)) return; // Sets the initial Generation by using the input v_list // if it runs out of values, it starts over (wraps) double[] val_list = new double[gph.nodes.Count]; int v_i = 0; for (int i = 0; i < gph.nodes.Count; i++) { if (v_i == v_list.Count) v_i = 0; val_list[i] = v_list[v_i]; v_i++; } AWorld wrld = new AWorld(gph, val_list); _py = PythonScript.Create(); _py.Output = this.m_py_output.Write; _compiled_py = _py.Compile(pyString); // console out Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_String> consoleOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_String>(); // Main evaluation cycle // Should move code into the Antsworld Class for (int g = 0; g < nGen; g++) { // console out this.m_py_output.Reset(); double[] new_vals = new double[wrld.NodeCount]; for (int i = 0; i < wrld.NodeCount; i++) { int[] neighboring_indices = wrld.gph.NeighboringIndexesOf(i); // build list of neighboring values List<double> neighboring_vals = new List<double>(); for (int k = 0; k < neighboring_indices.Length; k++) neighboring_vals.Add(wrld.LatestGen[neighboring_indices[k]]); double d = EvaluateCell(i, wrld.LatestGen[i], neighboring_vals); //double d = g + i + 0.0; new_vals[i] = d; } wrld.AddGen(new_vals); // console out Grasshopper.Kernel.Data.GH_Path key_path = new Grasshopper.Kernel.Data.GH_Path(g); List<Grasshopper.Kernel.Types.GH_String> gh_strs = new List<Grasshopper.Kernel.Types.GH_String>(); foreach (String str in this.m_py_output.Result) gh_strs.Add(new Grasshopper.Kernel.Types.GH_String(str)); consoleOut.AppendRange(gh_strs, key_path); } DA.SetDataTree(0, consoleOut); DA.SetData(1, wrld); }
protected override void SolveInstance(IGH_DataAccess DA) { AWorld refwrld = new AWorld(); bool SelectType = false; List<double> v_list = new List<double>(); Random rnd = new Random(); //if (!DA.GetData(0, ref refwrld) || !refwrld.IsValid) return; //AWorld wrld = new AWorld(refwrld); SpatialGraph gph = new SpatialGraph(); if (!DA.GetData(0, ref gph)) return; int nGen = 0; string pyString = ""; string spyString = ""; if (!DA.GetData(1, ref spyString)) return; if (!DA.GetData(2, ref SelectType)) return; if (!DA.GetData(3, ref pyString)) return; if (!DA.GetDataList(4, v_list)) return; if (!DA.GetData(5, ref nGen)) return; // Sets the initial Generation by using the input v_list // if it runs out of values, it starts over (wraps) double[] val_list = new double[gph.nodes.Count]; int v_i = 0; for (int i = 0; i < gph.nodes.Count; i++) { if (v_i == v_list.Count) v_i = 0; val_list[i] = v_list[v_i]; v_i++; } AWorld wrld = new AWorld(gph, val_list); // evaluation function _py = PythonScript.Create(); _py.Output = this.m_py_output.Write; _compiled_py = _py.Compile(pyString); // selection function _spy = PythonScript.Create(); _py.Output = this.m_py_output.Write; _compiled_spy = _py.Compile(spyString); // console out Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_String> consoleOut = new Grasshopper.Kernel.Data.GH_Structure<Grasshopper.Kernel.Types.GH_String>(); // Main evaluation cycle // Should move code into the Antsworld Class for (int g = 0; g < nGen; g++) { // console out this.m_py_output.Reset(); double[] new_vals = new double[wrld.NodeCount]; // build list to test List<int> nodes_to_test = new List<int>(); for (int i = 0; i < wrld.NodeCount; i++) { // build this now since we will only change a few of them later new_vals[i] = wrld.LatestGen[i]; int[] neighboring_indices = wrld.gph.NeighboringIndexesOf(i); double[] n_wts = wrld.gph.NeighboringWeightsOf(i); // build list of neighboring values List<double> neighboring_vals = new List<double>(); for (int k = 0; k < neighboring_indices.Length; k++) neighboring_vals.Add(wrld.LatestGen[neighboring_indices[k]]); bool test = SelectCell(i, wrld.LatestGen[i], neighboring_vals, n_wts); if (test) nodes_to_test.Add(i); } if (SelectType) { int trial = rnd.Next(nodes_to_test.Count); int new_index = nodes_to_test[trial]; nodes_to_test[0] = new_index; nodes_to_test.RemoveRange(1, nodes_to_test.Count - 1); } // evaluate list of cells for (int j = 0; j < nodes_to_test.Count; j++) { int i = nodes_to_test[j]; int[] neighboring_indices = wrld.gph.NeighboringIndexesOf(i); // build list of neighboring values List<double> neighboring_vals = new List<double>(); for (int k = 0; k < neighboring_indices.Length; k++) neighboring_vals.Add(wrld.LatestGen[neighboring_indices[k]]); double d = EvaluateCell(i, wrld.LatestGen[i], neighboring_vals, wrld.gph.NeighboringWeightsOf(i)); //double d = g + i + 0.0; new_vals[i] = d; } wrld.AddGen(new_vals); // console out Grasshopper.Kernel.Data.GH_Path key_path = new Grasshopper.Kernel.Data.GH_Path(g); List<Grasshopper.Kernel.Types.GH_String> gh_strs = new List<Grasshopper.Kernel.Types.GH_String>(); foreach (String str in this.m_py_output.Result) gh_strs.Add(new Grasshopper.Kernel.Types.GH_String(str)); consoleOut.AppendRange(gh_strs, key_path); } DA.SetDataTree(0, consoleOut); DA.SetData(1, wrld); }
public bool AddVolatileDataList(Grasshopper.Kernel.Data.GH_Path path, System.Collections.IEnumerable list) { throw new NotImplementedException(); }
public bool AddVolatileData(Grasshopper.Kernel.Data.GH_Path path, int index, object data) { throw new NotImplementedException(); }