protected override void SolveInstance(IGH_DataAccess DA) { GH_Program program = null; DA.GetData(0, ref program); var path = DA.ParameterTargetPath(0); var cellTargets = program.Value.Targets; var groupCount = cellTargets[0].ProgramTargets.Count; var planes = new GH_Structure<GH_Plane>(); var joints = new GH_Structure<GH_Number>(); var configuration = new GH_Structure<GH_String>(); var deltaTime = new GH_Structure<GH_Number>(); for (int i = 0; i < groupCount; i++) { var tempPath = path.AppendElement(i); for (int j = 0; j < cellTargets.Count; j++) { planes.AppendRange(cellTargets[j].ProgramTargets[i].Kinematics.Planes.Select(x => new GH_Plane(x)), tempPath.AppendElement(j)); joints.AppendRange(cellTargets[j].ProgramTargets[i].Kinematics.Joints.Select(x => new GH_Number(x)), tempPath.AppendElement(j)); configuration.Append(new GH_String(cellTargets[j].ProgramTargets[i].Kinematics.Configuration.ToString()), tempPath); deltaTime.Append(new GH_Number(cellTargets[j].DeltaTime), tempPath); } } DA.SetDataTree(0, planes); DA.SetDataTree(1, joints); DA.SetDataTree(2, configuration); DA.SetDataTree(3, deltaTime); }
protected override void SolveInstance(IGH_DataAccess DA) { string name = null; GH_RobotSystem robotSystem = null; var initCommandsGH = new List<GH_Command>(); var targetsA = new List<GH_Target>(); var targetsB = new List<GH_Target>(); var multiFileIndices = new List<int>(); double stepSize = 1; if (!DA.GetData(0, ref name)) { return; } if (!DA.GetData(1, ref robotSystem)) { return; } if (!DA.GetDataList(2, targetsA)) { return; } DA.GetDataList(3, targetsB); DA.GetDataList(4, initCommandsGH); DA.GetDataList(5, multiFileIndices); if (!DA.GetData(6, ref stepSize)) { return; } var initCommands = initCommandsGH.Count > 0 ? new Robots.Commands.Group(initCommandsGH.Select(x => x.Value)) : null; var targets = new List<IEnumerable<Target>>(); targets.Add(targetsA.Select(x => x.Value)); if (targetsB.Count > 0) targets.Add(targetsB.Select(x => x.Value)); var program = new Program(name, robotSystem.Value, targets, initCommands, multiFileIndices, stepSize); DA.SetData(0, new GH_Program(program)); if (program.Code != null) { var path = DA.ParameterTargetPath(2); var structure = new GH_Structure<GH_String>(); for (int i = 0; i < program.Code.Count; i++) { var tempPath = path.AppendElement(i); for (int j = 0; j < program.Code[i].Count; j++) { structure.AppendRange(program.Code[i][j].Select(x => new GH_String(x)), tempPath.AppendElement(j)); } } DA.SetDataTree(1, structure); } DA.SetData(2, program.Duration); if (program.Warnings.Count > 0) { DA.SetDataList(3, program.Warnings); this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Warnings in program"); } if (program.Errors.Count > 0) { DA.SetDataList(4, program.Errors); this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Errors in program"); } }
public GH_Structure <GH_Number> DataTree() { GH_Structure <GH_Number> dataTree = new GH_Structure <GH_Number>(); GH_Structure <GH_Integer> indices = new GH_Structure <GH_Integer>(); for (int i = 0; i < trainedVectors.GetLength(0); i++) { GH_Path p = new GH_Path(Utils.ReverseArray(this.adressBook[i])); indices.Append(new GH_Integer(i), p); } indices.Flatten(); dataTree = new GH_Structure <GH_Number>(); GH_Structure <GH_Number> valueTree = Utils.MultidimensionalArrayToGHTree(trainedVectors); for (int i = 0; i < indices.DataCount; i++) { dataTree.AppendRange(valueTree.Branches[indices.Branches[0][i].Value], new GH_Path(this.adressBook[i])); } return(dataTree); }
protected override bool Prompt_ManageCollection(GH_Structure <T> values) { foreach (var item in values.AllData(true)) { if (item.IsValid) { continue; } if (item is Types.IGH_ElementId elementId) { if (elementId.IsReferencedElement) { elementId.LoadElement(); } } } return(base.Prompt_ManageCollection(values)); }
public static List <object> DataTreeToNestedLists(GH_Structure <IGH_Goo> dataInput, ISpeckleConverter converter, Action OnConversionProgress = null) { var output = new List <object>(); for (var i = 0; i < dataInput.Branches.Count; i++) { var path = dataInput.Paths[i].Indices.ToList(); var leaves = new List <object>(); foreach (var goo in dataInput.Branches[i]) { OnConversionProgress?.Invoke(); leaves.Add(TryConvertItemToSpeckle(goo, converter)); } RecurseTreeToList(output, path, 0, leaves); } return(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) { //input GH_Structure <GH_Plane> planes = new GH_Structure <GH_Plane>(); double t1 = 0; double t2 = 0; if (!DA.GetDataTree(0, out planes)) { return; } if (!DA.GetData(1, ref t1)) { return; } if (!DA.GetData(2, ref t2)) { return; } int trimLengthBase = (int)t1; int trimLengthTop = (int)t2; //find nodes List <List <List <GH_Plane> > > nodesList = ExtractNodes(planes, trimLengthTop); //trim nodes List <List <List <GH_Plane> > > trimmedNodesList = TrimNodes(nodesList, trimLengthBase, trimLengthTop); //find stems GH_Structure <GH_Plane> stems = ExtractStems(planes, trimLengthBase, trimLengthTop); //convert to datatree GH_Structure <GH_Plane> untrimmedNodesTree = ConvertListToTree(nodesList); GH_Structure <GH_Plane> trimmedNodesTree = ConvertListToTree(trimmedNodesList); //output DA.SetDataTree(0, untrimmedNodesTree); DA.SetDataTree(1, trimmedNodesTree); DA.SetDataTree(2, stems); }
/// <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) { DA.GetDataTree("R", out GH_Structure <GH_Number> _R); var R = _R.Branches; var x = new List <double>(); DA.GetDataList("x", x); var y = new List <double>(); DA.GetDataList("y", y); var xlabel = new List <string>(); DA.GetDataList("xlabel", xlabel); var ylabel = new List <string>(); DA.GetDataList("ylabel", ylabel); var xl = new List <string>(); DA.GetDataList("xlabel for check", xl); var yl = new List <string>(); DA.GetDataList("ylabel for check", yl); DA.GetDataTree("reac_f", out GH_Structure <GH_Number> _reac_f); var reac_f = _reac_f.Branches; var eps = 0.1; DA.GetData("eps", ref eps); var QX = new GH_Structure <GH_Number>(); var QY = new GH_Structure <GH_Number>(); for (int i = 0; i < xl.Count; i++) { int ind = xlabel.IndexOf(xl[i]); var qy = new List <GH_Number>(); for (int j = 0; j < reac_f.Count; j++) { int k = (int)reac_f[j][0 + 7].Value; if (Math.Abs(x[ind] - R[k][0].Value) < 5e-3 && Math.Abs(reac_f[j][2 + 7].Value) > eps) { qy.Add(new GH_Number(Math.Abs(reac_f[j][2 + 7].Value))); } } QY.AppendRange(qy, new GH_Path(i)); } for (int i = 0; i < yl.Count; i++) { int ind = ylabel.IndexOf(yl[i]); var qx = new List <GH_Number>(); for (int j = 0; j < reac_f.Count; j++) { int k = (int)reac_f[j][0].Value; if (Math.Abs(y[ind] - R[k][1].Value) < 5e-3 && Math.Abs(reac_f[j][1].Value) > eps) { qx.Add(new GH_Number(Math.Abs(reac_f[j][1].Value))); } } QX.AppendRange(qx, new GH_Path(i)); } DA.SetDataTree(0, QX); DA.SetDataTree(1, QY); }
public GH_Structure <GH_Brep> Slab(IEnumerable <StbSlab> slabs) { var brepList = new GH_Structure <GH_Brep>(); if (slabs == null) { return(brepList); } foreach ((StbSlab slab, int i) in slabs.Select((slab, index) => (slab, index))) { StbSlabOffset[] offsets = slab.StbSlabOffsetList; var curveList = new PolylineCurve[2]; double depth = BrepMaker.Slab.GetDepth(_sections, slab); string[] nodeIds = slab.StbNodeIdOrder.Split(' '); var topPts = new List <Point3d>(); foreach (string nodeId in nodeIds) { var offsetVec = new Vector3d(); if (offsets != null) { foreach (StbSlabOffset offset in offsets) { if (nodeId == offset.id_node) { offsetVec = new Vector3d(offset.offset_X, offset.offset_Y, offset.offset_Z); } } } StbNode node = _nodes.First(n => n.id == nodeId); topPts.Add(new Point3d(node.X, node.Y, node.Z) + offsetVec); } topPts.Add(topPts[0]); curveList[0] = new PolylineCurve(topPts); brepList.Append(CreateSlabBrep(depth, curveList, topPts), new GH_Path(0, i)); } return(brepList); }
public static GH_Structure <GH_String> MakeReportForRequests( Dictionary <OSMTag, int> foundItemsForResult) { var output = new GH_Structure <GH_String>(); var tInfo = CultureInfo.CurrentCulture.TextInfo; var requestMetaDataItems = foundItemsForResult.Keys.ToList(); for (int i = 0; i < requestMetaDataItems.Count; i++) { var metaData = requestMetaDataItems[i]; GH_Path path = new GH_Path(i); var count = foundItemsForResult[metaData]; var colorForItem = GetPerceptualColorForTreeItem(requestMetaDataItems.Count, i); var metaDataTitle = tInfo.ToTitleCase(metaData.Name); output.Append(new GH_String(metaDataTitle), path); output.Append(new GH_String(metaData.ToString()), path); output.Append(new GH_String($"{count} found"), path); output.Append(new GH_String(colorForItem.ToString())); if (metaData.Key != null) { var titleName = tInfo.ToTitleCase(metaData.Key.Name); output.Append(new GH_String(titleName), path); var layerName = titleName + "::" + metaDataTitle; output.Append(new GH_String(layerName), path); // Layer path helper } else { output.Append(new GH_String("(No Parent Feature)"), path); output.Append(new GH_String(metaDataTitle + "::"), path); // Layer path helper } if (!string.IsNullOrEmpty(metaData.Description)) { output.Append(new GH_String($"Defined as: {metaData.Description}"), path); } } return(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) { GH_Structure <IGH_Goo> treeIn = new GH_Structure <IGH_Goo>(); DA.GetDataTree <IGH_Goo>(0, out treeIn); int pruneDepth = 0; DA.GetData <int>(1, ref pruneDepth); GH_Structure <IGH_Goo> treeOut = new GH_Structure <IGH_Goo>(); ///Create list of path strings var pathStrings = treeIn.Paths.Select(x => x.ToString()); ///Find the deepest path in the tree var maxDepthPath = pathStrings.Aggregate((max, cur) => max.Split(';').Length > cur.Split(';').Length ? max : cur); ///Get number of branches for deepest path var maxDepthInt = maxDepthPath.Split(';').Length; foreach (var path in treeIn.Paths) { ///Determine number of branches to prune if any GH_Path.SplitPathLikeString(path.ToString(), out string[] path_segments, out string index_segment); var numBranchesToRemove = path_segments.Length - (maxDepthInt - pruneDepth); var newPath = path; if (numBranchesToRemove > 0 && maxDepthInt - pruneDepth > 0) { ///Remove pruned branches from path string path_segments = path_segments.Take(path_segments.Count() - numBranchesToRemove).ToArray(); int[] path_args = path_segments.Select(int.Parse).ToArray(); newPath = new GH_Path(path_args); } treeOut.AppendRange(treeIn[path], newPath); } DA.SetDataTree(0, treeOut); }
protected override void SolveInstance(IGH_DataAccess access) { // =============================================================================================== // Read input parameters // =============================================================================================== var tree = new GH_Structure <IGH_Goo>(); //get values from grasshopper access.GetDataTree(0, out tree); // =============================================================================================== // Applying Values to Class // =============================================================================================== var partitioned = new GH_Structure <IGH_Goo>(); if (tree != null && !tree.IsEmpty) { for (int p = 0; p < tree.PathCount; p++) { var path = tree.Paths[p]; var list = tree.Branches[p]; int index = 0; int count = 0; for (int i = 0; i < list.Count; i++) { partitioned.Append(list[i], path.AppendElement(index)); count++; if (count >= 8) { count = 0; index++; } } } } // =============================================================================================== // Exporting Data to Grasshopper // =============================================================================================== access.SetDataTree(0, partitioned); }
/// <summary> /// Match the number of values of two given data structure, modifing the one with less elements. GH_Breps => GH_Numbers /// </summary> /// <param name="inGhBreps"></param> /// <param name="inGhNums"></param> /// <param name="outGhNums"></param> /// <returns></returns> public static GH_Structure <GH_Number> NumbersDSFromBreps(GH_Structure <GH_Brep> inGhBreps, GH_Structure <GH_Number> inGhNums, GH_Structure <GH_Number> outGhNums) { bool brepTopoEqualNumsTopo = inGhNums.TopologyDescription.Equals(inGhBreps.TopologyDescription); if (brepTopoEqualNumsTopo) { outGhNums = inGhNums.Duplicate(); } else { foreach (GH_Path ghPath in inGhBreps.Paths) { for (int i = 0; i < inGhBreps.get_Branch(ghPath).Count; i++) { outGhNums.Insert(inGhNums.get_LastItem(true), ghPath, i); } } } return(outGhNums); }
protected override void CollectVolatileData_FromSources() { base.CollectVolatileData_FromSources(); collectedData.Clear(); collectedData = m_data.Duplicate(); List <GH_ValueListItem> ghValueListItemList = new List <GH_ValueListItem>((IEnumerable <GH_ValueListItem>)m_userItems); m_userItems.Clear(); List <IGH_Goo> ghGooList = new List <IGH_Goo>((IEnumerable <IGH_Goo>)collectedData); for (int index = 0; index < ghGooList.Count; ++index) { IGH_Goo gooIn = ghGooList[index]; m_userItems.Add(new GH_ValueListItem(gooIn.ToString(), "\"" + gooIn.ToString() + "\"", gooIn)); if (index < ghValueListItemList.Count) { m_userItems[index].Selected = ghValueListItemList[index].Selected; } } CollectVolatileData_Custom(); }
//GET FROM MESH CLASS public int FindSizeOfM(GH_Structure <GH_Integer> treeConnectivity) { int max = 0; for (int i = 0; i < treeConnectivity.PathCount; i++) { List <GH_Integer> cNodes = (List <GH_Integer>)treeConnectivity.get_Branch(i); for (int j = 0; j < cNodes.Count; j++) { if (cNodes[j].Value > max) { max = cNodes[j].Value; } } } int sizeOfM = 3 * (max + 1); return(sizeOfM); }
/// <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) { GH_Structure <GH_Integer> Tt; if (!DA.GetDataTree(0, out Tt)) { return; } GH_Structure <GH_Integer> Tinv = new GH_Structure <GH_Integer>(); for (int i = 0; i < Tt.Branches.Count; i++) { for (int j = 0; j < Tt.Branches[i].Count; j++) { Tinv.Append(new GH_Integer(Tt.Paths[i].Indices[0]), new GH_Path(Tt.Branches[i][j].Value)); } } DA.SetDataTree(0, Tinv); }
private static GH_Structure <IGH_Goo> GetSubTree(GH_Structure <IGH_Goo> valueTree, GH_Path searchPath) { var subTree = new GH_Structure <IGH_Goo>(); var gen = 0; foreach (var path in valueTree.Paths) { var branch = valueTree.get_Branch(path) as IEnumerable <IGH_Goo>; if (path.IsAncestor(searchPath, ref gen)) { subTree.AppendRange(branch, path); } else if (path.IsCoincident(searchPath)) { subTree.AppendRange(branch, path); break; } } subTree.Simplify(GH_SimplificationMode.CollapseLeadingOverlaps); return(subTree); }
/// <summary> /// Match the number of values of two given data structure, modifing the one with less elements. GH_Curve => GH_Plane /// </summary> /// <param name="refGhCurves"></param> /// <param name="inputPlanes"></param> /// <param name="outputPlanes"></param> /// <returns></returns> public static GH_Structure <GH_Plane> PlanesDSFromCurves(GH_Structure <GH_Curve> refGhCurves, GH_Structure <GH_Plane> inputPlanes, GH_Structure <GH_Plane> outputPlanes) { bool planesTopoEqualCurvesTopo = refGhCurves.TopologyDescription.Equals(inputPlanes.TopologyDescription); if (planesTopoEqualCurvesTopo) { outputPlanes = inputPlanes.Duplicate(); } else { foreach (GH_Path ghPath in refGhCurves.Paths) { for (int i = 0; i < refGhCurves.get_Branch(ghPath).Count; i++) { outputPlanes.Insert(inputPlanes.get_LastItem(true), ghPath, i); } } } return(outputPlanes); }
/// <summary> /// Match the number of values of two given data structure, modifing the one with less elements. GH_Breps => GH_Boolean /// </summary> /// <param name="inGhBreps"></param> /// <param name="inGhBool"></param> /// <param name="outGhBool"></param> /// <returns></returns> public static GH_Structure <GH_Boolean> BoolDSFromBreps(GH_Structure <GH_Brep> inGhBreps, GH_Structure <GH_Boolean> inGhBool, GH_Structure <GH_Boolean> outGhBool) { bool brepTopologyEqualBoolTopology = inGhBool.TopologyDescription.Equals(inGhBreps.TopologyDescription); if (brepTopologyEqualBoolTopology) { outGhBool = inGhBool.Duplicate(); } else { foreach (GH_Path ghPath in inGhBreps.Paths) { for (int i = 0; i < inGhBreps.get_Branch(ghPath).Count; i++) { outGhBool.Insert(inGhBool.get_LastItem(true), ghPath, i); } } } return(outGhBool); }
internal static IEnumerable <GH_String> GetSlabRcSection(object slabFigure, string strength) { var ghSecString = new GH_Structure <GH_String>(); switch (slabFigure) { case StbSecSlab_RC_Straight figure: ghSecString.Append(new GH_String("t=" + figure.depth + "(" + strength + ")")); break; case StbSecSlab_RC_Taper figure: ghSecString.Append(new GH_String("t=" + figure.pos + ":" + figure.depth + "(" + strength + ")")); break; case StbSecSlab_RC_Haunch figure: ghSecString.Append(new GH_String("t=" + figure.pos + ":" + figure.depth + "(" + strength + ")")); break; } return(ghSecString); }
internal static IEnumerable <GH_String> GetBraceSSection(object steelFigure) { var ghSecStrings = new GH_Structure <GH_String>(); switch (steelFigure) { case StbSecSteelBrace_S_Same figure: ghSecStrings.Append(new GH_String(figure.shape + "(" + figure.strength_main + ")")); break; case StbSecSteelBrace_S_NotSame figure: ghSecStrings.Append(new GH_String(figure.pos + ":" + figure.shape + "(" + figure.strength_main + ")")); break; case StbSecSteelBrace_S_ThreeTypes figure: ghSecStrings.Append(new GH_String(figure.pos + ":" + figure.shape + "(" + figure.strength_main + ")")); break; } return(ghSecStrings); }
/// <summary> /// 将二维树转化为列表 /// </summary> /// <param name="tree"></param> /// <returns></returns> public static List <List <Plane> > TreeToList2(GH_Structure <GH_Plane> tree) { IList <GH_Path> paths = tree.Paths; List <List <Plane> > list = new List <List <Plane> >(); IEnumerable <GH_Plane> this_branch = new List <GH_Plane>(); for (int i = 0; i < paths.Count; i++) { list.Add(new List <Plane>()); this_branch = tree.get_Branch(paths[i]).Cast <GH_Plane>(); List <GH_Plane> this_list = this_branch.ToList(); for (int j = 0; j < this_list.Count(); j++) { GH_Plane raw_item = this_list[j]; Plane item = new Plane(); raw_item.CastTo(out item); list[i].Add(item); } } return(list); }
public GH_Structure <GH_Brep> Brace(IEnumerable <StbBrace> braces) { var brepList = new GH_Structure <GH_Brep>(); if (braces == null) { return(brepList); } foreach ((StbBrace brace, int i) in braces.Select((brace, index) => (brace, index))) { StbBraceKind_structure kind = brace.kind_structure; StbNode[] endNodes = { _nodes.First(node => node.id == brace.id_node_start), _nodes.First(node => node.id == brace.id_node_end) }; Point3d[] offset = { new Point3d(brace.offset_start_X, brace.offset_start_Y, brace.offset_start_Z), new Point3d(brace.offset_end_X, brace.offset_end_Y, brace.offset_end_Z) }; Point3d[] sectionPoints = { new Point3d(endNodes[0].X, endNodes[0].Y, endNodes[0].Z) + offset[0], Point3d.Origin, Point3d.Origin, new Point3d(endNodes[1].X, endNodes[1].Y, endNodes[1].Z) + offset[1] }; Vector3d memberAxis = sectionPoints[3] - sectionPoints[0]; sectionPoints[1] = sectionPoints[0] + memberAxis / memberAxis.Length * brace.joint_start; sectionPoints[2] = sectionPoints[3] - memberAxis / memberAxis.Length * brace.joint_end; var brepMaker = new BrepMaker.Brace(_sections, _tolerance); brepList.Append(new GH_Brep(brepMaker.CreateBraceBrep(brace.id_section, brace.rotate, kind, sectionPoints, memberAxis)), new GH_Path(0, i)); } return(brepList); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object can be used to retrieve data from input parameters and /// to store data in output parameters.</param> protected override void SolveInstance(IGH_DataAccess DA) { List <Line> bldGrid = new List <Line>(); double xcell = 0; double ycell = 0; double zcell = 0; if (!DA.GetData(0, ref xcell)) { return; } if (!DA.GetData(1, ref ycell)) { return; } if (!DA.GetData(2, ref zcell)) { return; } if (!DA.GetDataList(3, bldGrid)) { return; } Parameters parameters = new Parameters(xcell, ycell, zcell); PartController pControl = new PartController(bldGrid, parameters); GH_Structure <GH_Mesh> caveSlices = new GH_Structure <GH_Mesh>(); GH_Structure <GH_Brep> bboxes = new GH_Structure <GH_Brep>(); getSlices(pControl, ref bboxes, ref caveSlices); DA.SetDataTree(0, caveSlices); DA.SetDataTree(1, bboxes); Documenter documenter3d = new Documenter(); documenter3d.WritePart3d(pControl, parameters, @"C:\Users\Admin\Documents\projects\PassageProjects\DD\Output\part.3dm"); }
public GH_Structure <GH_Brep> Post(IEnumerable <StbPost> posts) { var brepList = new GH_Structure <GH_Brep>(); if (posts == null) { return(brepList); } foreach ((StbPost post, int i) in posts.Select((post, index) => (post, index))) { StbColumnKind_structure kind = post.kind_structure; StbNode[] endNodes = { _nodes.First(node => node.id == post.id_node_bottom), _nodes.First(node => node.id == post.id_node_top) }; Point3d[] offset = { new Point3d(post.offset_bottom_X, post.offset_bottom_Y, post.offset_bottom_Z), new Point3d(post.offset_top_X, post.offset_top_Y, post.offset_top_Z) }; Point3d[] sectionPoints = { new Point3d(endNodes[0].X, endNodes[0].Y, endNodes[0].Z) + offset[0], new Point3d(), new Point3d(), new Point3d(endNodes[1].X, endNodes[1].Y, endNodes[1].Z) + offset[1] }; Vector3d memberAxis = sectionPoints[3] - sectionPoints[0]; sectionPoints[1] = sectionPoints[0] + memberAxis / memberAxis.Length * post.joint_bottom; sectionPoints[2] = sectionPoints[3] - memberAxis / memberAxis.Length * post.joint_top; var brepMaker = new BrepMaker.Column(_sections, _tolerance); brepList.Append(new GH_Brep(brepMaker.CreateColumnBrep(post.id_section, post.rotate, kind, sectionPoints, memberAxis)), new GH_Path(0, i)); } return(brepList); }
/// <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) { GH_Structure <IGH_Goo> issue_tree = new GH_Structure <IGH_Goo>(); string attributeName = ""; DA.GetDataTree("Issues", out issue_tree); DA.GetData("Attribute", ref attributeName); StringBuilder output = new StringBuilder(); int total = 0; for (int b = 0; b < issue_tree.Branches.Count; b++) { var summary = new StringCounter(); foreach (var gh_issue in issue_tree[b]) { Issue issue = ((GH_ObjectWrapper)gh_issue).Value as Issue; if (issue == null) { continue; } total += 1; var value = issue.GetPropertyValue(attributeName); summary.Increment(value); } output.Append(string.Format("[Path {0}]\r\n", b)); var keys = new List <string>(); keys.AddRange(summary.Keys); keys.Sort(); foreach (var key in keys) { output.Append(key).Append(": ").Append(summary[key].ToString()).Append("\n"); } output.Append("\r\n\r\n"); } DA.SetData(0, total); DA.SetData(1, output.ToString()); }
/// <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 variables GH_Structure <IGH_Goo> data; string name = String.Empty; // Catch the input data if (!DA.GetData(0, ref name)) { return; } if (!DA.GetDataTree(1, out data)) { return; } // Output variable GH_Structure <GH_String> names = HelperMethods.DataTreeNaming(name, data); // Output DA.SetDataTree(0, names); }
public static GH_Structure <GH_String> MakeTreeForItemTags(RequestHandler result) { var output = new GH_Structure <GH_String>(); for (int i = 0; i < result.RequestedMetaData.Requests.Count; i++) { new GH_Path(i); var metaData = result.RequestedMetaData.Requests[i]; var results = result.FoundData[metaData]; for (int j = 0; j < results.Count; j++) { var subPath = new GH_Path(i, j); foreach (var tag in results[j].Tags) { var tagReadout = new GH_String(tag.Key + "=" + tag.Value); output.Append(tagReadout, subPath); } } } return(output); }
public static List <Point3d> GHTreeToPointList(GH_Structure <GH_Point> pointTree) { int listLengthes = pointTree.Branches[0].Count; for (int i = 0; i < pointTree.Branches.Count; i++) { if (listLengthes != pointTree.Branches[i].Count) { return(new List <Point3d>()); } } List <Point3d> points = new List <Point3d>(); for (int i = 0; i < pointTree.Branches.Count; i++) { for (int j = 0; j < pointTree.Branches[i].Count; j++) { points.Add(pointTree[i][j].Value); } } return(points); }
/// <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) { var shell = new List <Surface>(); var xyz = new List <Point3d>(); GH_Structure <GH_Number> r = new GH_Structure <GH_Number>(); GH_Structure <GH_Number> ijkl = new GH_Structure <GH_Number>(); int N = 6; int M = 32; double X = 1.5; double Y = 8.0; double angle = 120.0; var cp = new List <double>(); double te = 0.090; int me = 0; List <double> thickness = new List <double>(); List <int> mat = new List <int>(); DA.GetData("number of points on width direction", ref N); DA.GetData("number of points on length direction", ref M); DA.GetData("thickness", ref te); DA.GetData("material number", ref me); DA.GetData("width of 1 unit", ref X); DA.GetData("length of 1 unit", ref Y); DA.GetData("fold angle", ref angle); DA.GetDataList("center point of the bottom", cp); var dx = X / ((double)N - 1.0); var dy = Y / ((double)M - 1.0); var theta = (180.0 - angle) / 2.0 / 180.0 * Math.PI; for (int j = 0; j < M; j++) { for (int i = 0; i < N * 2 - 1; i++) { var l = dx * i; var x = l * Math.Cos(theta); var z = l * Math.Sin(theta); var y = dy * j; if (i >= N) { z = X * Math.Sin(theta) - (l - X) * Math.Sin(theta); } xyz.Add(new Point3d(x - X * Math.Cos(theta) + cp[0], y - Y / 2.0 + cp[1], z + cp[2])); var rlist = new List <GH_Number>(); rlist.Add(new GH_Number(x - X * Math.Cos(theta) + cp[0])); rlist.Add(new GH_Number(y - Y / 2.0 + cp[1])); rlist.Add(new GH_Number(z + cp[2])); r.AppendRange(rlist, new GH_Path(i + j * (N * 2 - 1))); thickness.Add(te); mat.Add(me); } } DA.SetDataList("nodes", xyz); for (int j = 0; j < M - 1; j++) { for (int i = 0; i < N * 2 - 2; i++) { int n1 = i + (N * 2 - 1) * j; int n2 = n1 + 1; int n3 = i + (N * 2 - 1) * (j + 1) + 1; int n4 = n3 - 1; shell.Add(NurbsSurface.CreateFromCorners(xyz[n1], xyz[n2], xyz[n3], xyz[n4])); } } DA.SetDataList("shells", shell); DA.SetDataList("material number", mat); DA.SetDataList("thickness", thickness); }
/// <summary> /// Path[0] = joint; Path[1] = member /// </summary> /// <param name="inputPlanes"></param> /// <returns></returns> private GH_Structure <GH_Curve> BuildStructureAsCurves() { GH_Structure <GH_Curve> curves = new GH_Structure <GH_Curve>(); for (int i = 0; i < Utility.GetMainBranchCount(inputPlanes.Paths); i++) { int subBranchCount = Utility.GetSecondaryBranchCount(inputPlanes.Paths, i); for (int j = 0; j < subBranchCount; j++) { GH_Path path = new GH_Path(i, j); List <Point3d> cp = new List <Point3d>(); foreach (GH_Plane plane in inputPlanes.get_Branch(path)) { cp.Add(plane.Value.Origin); } GH_Curve cv = new GH_Curve(); cv.CastFrom(Curve.CreateInterpolatedCurve(cp, 3)); curves.Append(cv, path); } } return(curves); }
/// <summary> /// Returns true if all values are similar under a certain epsilon threshold. /// </summary> /// <param name="A"></param> /// <param name="B"></param> /// <param name="epsilon"></param> /// <returns></returns> internal static bool EqualNumData(GH_Structure <GH_Number> A, GH_Structure <GH_Number> B, double epsilon) { var bA = A.Branches; var bB = B.Branches; double a, b; for (int i = bA.Count - 1; i >= 0; i--) { for (int j = bA[i].Count - 1; j >= 0; j--) { a = bA[i][j].Value; b = bB[i][j].Value; if (Math.Abs(b - a) >= epsilon || double.IsNaN(a) != double.IsNaN(b)) { return(false); } } } return(true); }
// // Duplicate a structure. // internal GH_Structure <IGH_Goo> duplicateStructure(IGH_Structure source) { GH_Structure <IGH_Goo> copy = new GH_Structure <IGH_Goo>(); foreach (GH_Path p in source.Paths) { List <IGH_Goo> l = new List <IGH_Goo>(); foreach (IGH_Goo item in source.get_Branch(p)) { if (item == null) { l.Add(null); } else { l.Add(item.Duplicate()); } } copy.AppendRange(l, p); } return(copy); }
/// <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) { #region INPUTS // import silkwormSettings file List<string> silkwormSettings = new List<string>(); if (!DA.GetDataList(0, silkwormSettings)) return; List<GH_ObjectWrapper> things = new List<GH_ObjectWrapper>(); if (!DA.GetDataList(1, things)) return; // import Silkworm Movement #endregion SilkwormUtility sUtil = new SilkwormUtility(); Dictionary<string, string> Settings = sUtil.convertSettings(silkwormSettings); #region Optional Variables int shell = -999; if (!DA.GetData(4, ref shell)) { } double layerheight = -999; if (!DA.GetData(3, ref layerheight)) { } //bool detect = false; //if (!DA.GetData(5, ref detect)) { } List<Plane> sliceplanes = new List<Plane>(); if (!DA.GetDataList(2, sliceplanes)) { } if (shell == -999) { shell = int.Parse(Settings["perimeters"]); } if (layerheight == -999) { layerheight = double.Parse(Settings["layer_height"]); } if (sliceplanes.Count<1) { sliceplanes.Add(Plane.WorldXY); } #endregion List<Brep> Breps = new List<Brep>(); List<Mesh> Meshes = new List<Mesh>(); SilkwormSkein skein = new SilkwormSkein(); #region Sort Types foreach (GH_ObjectWrapper obj in things) { if (obj.Value is GH_Brep) { Brep brep = null; GH_Convert.ToBrep(obj.Value, ref brep, GH_Conversion.Both); Breps.Add(brep); continue; } if (obj.Value is GH_Mesh) { Mesh mesh = null; GH_Convert.ToMesh(obj.Value, ref mesh, GH_Conversion.Both); Meshes.Add(mesh); continue; } } #endregion if (Breps.Count>0) { skein = new SilkwormSkein(Settings, Breps, sliceplanes, shell, layerheight); skein.BrepSlice(false); } if (Meshes.Count > 0) { //TODO } //Reflect Errors and Warnings foreach (string message in skein.ErrorMessages) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message); } foreach (string message in skein.WarningMessages) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message); } List<Curve>[] openregions = skein.openRegions; List<Brep>[] rRegions = skein.Regions; List<Brep>[] rPerimeterR = skein.regionPerimeter; List<Brep>[] rInfillR = skein.regionInfill; GH_Structure<GH_Brep> Regions = new GH_Structure<GH_Brep>(); GH_Structure<GH_Curve> openRegions = new GH_Structure<GH_Curve>(); #region Add Regions to GH_Structure if (rRegions.GetUpperBound(0) > 1) { for (int i = 0; i < rRegions.Length; i++) { if (rRegions[i] != null) { for (int j = 0; j < rRegions[i].Count; j++) { GH_Brep gShapes = new GH_Brep(rRegions[i][j]); Regions.Insert(gShapes, new GH_Path(i, 0), j); } } } } if (rPerimeterR.GetUpperBound(0) > 1) { for (int i = 0; i < rPerimeterR.Length; i++) { if (rPerimeterR[i] != null) { for (int j = 0; j < rPerimeterR[i].Count; j++) { GH_Brep gShapes = new GH_Brep(rPerimeterR[i][j]); Regions.Insert(gShapes, new GH_Path(i, 1), j); } } } } if (rInfillR.GetUpperBound(0) > 1) { for (int i = 0; i < rInfillR.Length; i++) { if (rInfillR[i] != null) { for (int j = 0; j < rInfillR[i].Count; j++) { GH_Brep gShapes = new GH_Brep(rInfillR[i][j]); Regions.Insert(gShapes, new GH_Path(i, 2), j); } } } } if (openregions.GetUpperBound(0) > 1) { for (int i = 0; i < openregions.Length; i++) { if (openregions[i] != null) { for (int j = 0; j < openregions[i].Count; j++) { GH_Curve gShapes = new GH_Curve(openregions[i][j]); openRegions.Insert(gShapes, new GH_Path(i), j); } } } } //TODO //Add Overhang and Bridges #endregion #region Add Open Regions to GH_Structure if (openregions.GetUpperBound(0) > 1) { for (int i = 0; i < openregions.Length; i++) { for (int j = 0; j < openregions[i].Count; j++) { if (openregions[i][j] != null) { SilkwormSegment segment = new SilkwormSegment(openregions[i][j]); Curve curve = segment.Pline.ToNurbsCurve(); GH_Curve gShapes = new GH_Curve(curve); openRegions.Insert(gShapes, new GH_Path(i), j); } } } } #endregion #region OUTPUT if (!DA.SetDataTree(0, Regions)) { return; } if (!DA.SetDataTree(1, openRegions)) { return; } #endregion }
public PositionHistoryAsGhStructure(int size) { this.structure = new GH_Structure<IGH_Goo>(); this.size = size; this.nextPathIndex = 0; }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Structure<IGH_Goo> Input = new GH_Structure<IGH_Goo>(); DA.GetDataTree("Input", out Input); GH_Structure<HashType> Output = new GH_Structure<HashType>(); bool bEnumerate = false; DA.GetData("Enumerate", ref bEnumerate); // iterate through all the sources by the Params.input value (and thus bypass the DA object, is this ugly?) foreach (IGH_Param Param in this.Params.Input[0].Sources) { foreach (GH_Path path in Input.Paths) { String nickname = Param.NickName; if (nickname.Length == 0) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Nickname of the connected component is empty"); nickname = "Anonymous"; } List<object> DataList = new List<object>(); IEnumerable Data = Param.VolatileData.get_Branch(path); if (Data != null) { foreach (object item in Data) { if (item != null) { DataList.Add(item); } else { DataList.Add(""); } } } // // Add the data to the list. If result is a tree or something similar: this means the results will be flattened. if (Data == null || DataList.Count == 0) { } else if (DataList.Count == 1) { // If the component has a single output: name it singular Output.Append(new HashType(nickname, DataList[0]), path); } else if (DataList.Count > 1) { // .. otherwise: add a int j = 0; if (bEnumerate) { foreach (object item in DataList) { Output.Append(new HashType(String.Format("{0}_{1}", nickname, j), item), path); j++; } } else { Output.Append(new HashType(nickname, DataList), path); } } } } DA.SetDataTree(0, Output); }
protected override void SafeSolveInstance(IGH_DataAccess DA) { this.InitalizePrivateData(); GH_Structure<Grasshopper.Kernel.Types.IGH_Goo> geom_tree = new GH_Structure<Grasshopper.Kernel.Types.IGH_Goo>(); GH_Structure<Decodes_Attributes> attr_tree = new GH_Structure<Decodes_Attributes>(); if ((DA.GetDataTree<Grasshopper.Kernel.Types.IGH_Goo>(0, out geom_tree)) && (DA.GetDataTree<Decodes_Attributes>(1, out attr_tree))) { if (geom_tree.PathCount != attr_tree.Branches.Count) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "geometry and property inputs do not have the same number of branches. check your inputs."); return; } for (int b = 0; b < geom_tree.Branches.Count; b++) { List<Grasshopper.Kernel.Types.IGH_Goo> geom_given = geom_tree.Branches[b]; List<Decodes_Attributes> attr_given = attr_tree.Branches[b]; if (geom_given.Count != attr_given.Count) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "geometry and property inputs are not lists of the same length. check your inputs."); return; } for (int i = 0; i < geom_given.Count; i++) { if (!(geom_given[i] is Grasshopper.Kernel.Types.IGH_GeometricGoo)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Did you give me something that isn't geometry?"); continue; } try { m_obj.Add((Grasshopper.Kernel.Types.IGH_GeometricGoo)geom_given[i]); if (!(attr_given[i] is Decodes_Attributes)) m_att.Add(new Decodes_Attributes()); else { m_att.Add(attr_given[i]); if (!required_layers.Contains(attr_given[i].layer)) required_layers.Add(attr_given[i].layer); } m_branch_index.Add(b); } catch (Exception e) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Did you give me something that looks like geometry, but isn't?\n" + e.Message); } } } } }
protected override void SolveInstance(IGH_DataAccess DA) { //declare input variables to load into AuthToken authToken = new AuthToken(); string sheetName = ""; string worksheet = ""; bool rowsColumns = false; GH_Structure<GH_String> addresses = new GH_Structure<GH_String>(); GH_Structure<GH_String> data = new GH_Structure<GH_String>(); bool write = false; //declare output variables GH_Structure<GH_String> addressesOut = new GH_Structure<GH_String>(); //get data from inputs if (!DA.GetData<AuthToken>("Token", ref authToken)) { return; //exit if no token given } if (!authToken.IsValid) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "The provided authentication token appears to be invalid. Try re-running the Google Authenticator component."); return; //exit if token invalid } if (!DA.GetData<string>("Name", ref sheetName)) { return; //exit if no name given } DA.GetData<string>("Worksheet", ref worksheet); DA.GetData<bool>("Organize by Rows or Columns", ref rowsColumns); DA.GetDataTree<GH_String>("Address", out addresses); DA.GetDataTree<GH_String>("Data", out data); DA.GetData<bool>("Write", ref write); if (!write) return; //exit if write is not true //check each specified address for validity foreach (GH_String address in addresses.AllData(true)) { if (!GDriveUtil.isValidAddress(address.ToString())) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error,"Not all addresses are specified in a valid format."); return; } } //setup auth and factory //set up oAuth parameters OAuth2Parameters parameters = GDriveUtil.GetParameters(authToken); SpreadsheetsService service = GDriveUtil.GetSpreadsheetsService(parameters); //find spreadsheet by name SpreadsheetEntry spreadsheet = GDriveUtil.findSpreadsheetByName(sheetName, service); if (spreadsheet == null) //if the spreadsheet is not found { if (createNewSpreadsheets) //if the user has elected to create new spreadsheets { List<string> worksheets = new List<string>(); if (!String.IsNullOrEmpty(worksheet)) { worksheets.Add(worksheet); //create a 1-item list with the worksheet name } spreadsheet = CreateSpreadsheet.createNewSpreadsheet(this, authToken, sheetName, worksheets, false); //create the spreadsheet } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Specified spreadsheet not found."); return; } } //find worksheet by name WorksheetEntry worksheetEntry = GDriveUtil.findWorksheetByName(worksheet, spreadsheet); if (worksheetEntry == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Specified worksheet not found."); return; } uint maxRow = 0; uint maxCol = 0; // set up dictionary<Cell address, cell input> // associate each input value with a corresponding address Dictionary<string, string> writeMap = constructWriteMap(addresses, data, rowsColumns, ref maxRow, ref maxCol, ref addressesOut); //expand worksheet if necessary if (worksheetEntry.Rows < maxRow) { worksheetEntry.Rows = maxRow; worksheetEntry.Etag = "*"; //required for compatibility with "new" google sheets (see: http://stackoverflow.com/questions/22719170/updating-cell-in-google-spreadsheets-returns-error-missing-resource-version-id) worksheetEntry.Update(); } if (worksheetEntry.Cols < maxCol) { worksheetEntry.Cols = maxCol; worksheetEntry.Etag = "*"; //required for compatibility with "new" google sheets (see: http://stackoverflow.com/questions/22719170/updating-cell-in-google-spreadsheets-returns-error-missing-resource-version-id) worksheetEntry.Update(); } //set bounds of cell query CellQuery cellQuery = new CellQuery(worksheetEntry.CellFeedLink); cellQuery.MinimumColumn = 0; cellQuery.MinimumRow = 0; cellQuery.MaximumColumn = maxCol; cellQuery.MaximumRow = maxRow; cellQuery.ReturnEmpty = ReturnEmptyCells.yes; //retrieve cellfeed CellFeed cellFeed = service.Query(cellQuery); //convert cell entries to dictionary Dictionary<string,AtomEntry> cellDict = cellFeed.Entries.ToDictionary(k => k.Title.Text); CellFeed batchRequest = new CellFeed(cellQuery.Uri, service); //set up batchrequest foreach (KeyValuePair<string, string> entry in writeMap) { AtomEntry atomEntry; cellDict.TryGetValue(entry.Key, out atomEntry); CellEntry batchEntry = atomEntry as CellEntry; batchEntry.InputValue = entry.Value; batchEntry.Etag = "*"; //required for compatibility with "new" google sheets (see: http://stackoverflow.com/questions/22719170/updating-cell-in-google-spreadsheets-returns-error-missing-resource-version-id) batchEntry.BatchData = new GDataBatchEntryData(GDataBatchOperationType.update); batchRequest.Entries.Add(batchEntry); } CellFeed batchResponse = (CellFeed)service.Batch(batchRequest, new Uri(cellFeed.Batch)); // Check the results bool isSuccess = true; foreach (CellEntry entry in batchResponse.Entries) { string batchId = entry.BatchData.Id; if (entry.BatchData.Status.Code != 200) { isSuccess = false; GDataBatchStatus status = entry.BatchData.Status; } } if (!isSuccess) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Update operations failed"); } //output addresses DA.SetDataTree(0, addressesOut); //write addressesOut to first output parameter }
protected override void SolveInstance(IGH_DataAccess DA) { //declare input variables to load into AuthToken authToken = new AuthToken(); string sheetName = ""; string worksheet = ""; bool includeBlankCells = false; bool rangeSpecified = false; SpreadsheetRange range = new SpreadsheetRange(); bool rowsColumns = false; bool formulasValues = false; //declare output variables List<string> metaData = new List<string>(); GH_Structure<GH_String> values = new GH_Structure<GH_String>(); GH_Structure<GH_String> addresses = new GH_Structure<GH_String>(); //get data from inputs if (!DA.GetData<AuthToken>("Token", ref authToken)) { return; //exit if no token } if (!authToken.IsValid) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "The provided authentication token appears to be invalid. Try re-running the Google Authenticator component."); return; //exit if invalid token } if (!DA.GetData<string>("Name", ref sheetName)) { return; //exit if no name provided } DA.GetData<string>("Worksheet", ref worksheet); DA.GetData<bool>("Include Blank Cells?", ref includeBlankCells); if (DA.GetData<SpreadsheetRange>("Spreadsheet Range", ref range)) { rangeSpecified = true; } DA.GetData<bool>("Organize by Rows or Columns", ref rowsColumns); DA.GetData<bool>("Read Formulas or Values", ref formulasValues); //set up oAuth parameters OAuth2Parameters parameters = GDriveUtil.GetParameters(authToken); //establish spreadsheetservice SpreadsheetsService service = GDriveUtil.GetSpreadsheetsService(parameters); //get spreadsheet by name SpreadsheetEntry spreadsheet = GDriveUtil.findSpreadsheetByName(sheetName, service); if (spreadsheet == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Specified Spreadsheet not found."); return; } //gather spreadsheet metadata metaData.Add("Spreadsheet Name: " + spreadsheet.Title.Text); metaData.Add("Last Updated: " + spreadsheet.Updated.ToString()); metaData.Add("Worksheets: " + worksheetList(spreadsheet.Worksheets)); //find the specified worksheet, or first one if none specified WorksheetEntry worksheetEntry = null; worksheetEntry = GDriveUtil.findWorksheetByName(worksheet, spreadsheet); if (worksheetEntry == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Specified worksheet not found."); return; } // Fetch the cell feed of the worksheet. CellQuery cellQuery = new CellQuery(worksheetEntry.CellFeedLink); if (rangeSpecified) { if (range.TestValid()) { cellQuery.MinimumColumn = range.startColumn(); cellQuery.MinimumRow = range.startRow(); cellQuery.MaximumColumn = range.endColumn(); cellQuery.MaximumRow = range.endRow(); } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid Range Specified"); return; } } //passes null values if user wants the blank cells represented, otherwise they are omitted from output. if (includeBlankCells) { cellQuery.ReturnEmpty = ReturnEmptyCells.yes; } //set up cell feed CellFeed cellFeed = service.Query(cellQuery); foreach (CellEntry cell in cellFeed.Entries) //for all the cells in the feed { GH_Path path = new GH_Path(DA.Iteration); //set up data path for data tree uint e = (rowsColumns) ? cell.Row : cell.Column; //decide whether to structure data path by row or column path = path.AppendElement((int)e); string v = (formulasValues) ? cell.InputValue : cell.Value; //decide whether to get the cell formula or the cell value as output values.Append(new GH_String(v), path); //save the value of the cell addresses.Append(new GH_String(cell.Title.Text), path); // save the address of the cell } //set output data DA.SetDataTree(0, values); DA.SetDataTree(1, addresses); DA.SetDataList("Sheet Info", metaData); }
//this method associates addresses with every piece of data. Responds intelligently to different cases of user input private Dictionary<string, string> constructWriteMap(GH_Structure<GH_String> addresses, GH_Structure<GH_String> data, bool rowColumn, ref uint maxRow, ref uint maxCol, ref GH_Structure<GH_String> addressesOut) { Dictionary<string, string> writeMap = new Dictionary<string, string>(); bool incrementBranches = false; bool incrementItems = false; //case 1: 1 address for entire tree //increment branches + increment items = true //case 2: 1 address per list //increment branches = false + increment items = true; //case 3: 1 address per item //increment branches + increment items = false bool validDataMatch = false; if (addresses.DataCount == 1) // case 1 { incrementBranches = true; incrementItems = true; validDataMatch = true; } else if(addresses.Branches.Count==data.Branches.Count) { if (oneItemPerBranch(addresses))//one item in each address branch, case 2 { incrementItems = true; validDataMatch = true; } else if(sameBranchLengths(data,addresses)){ //otherwise leave both to false in case 3 validDataMatch = true; } } if (!validDataMatch) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Either provide one address per data item, one address per list, or one address for the whole tree. \n In the latter two cases, sequential addresses are calculated automatically."); return writeMap; //return empty write map - nothing happens } for (int i_branch = 0; i_branch < data.Branches.Count; i_branch++) { List<GH_String> dataBranch = data.Branches[i_branch]; List<GH_String> addressBranch = addresses.Branches[Math.Min(i_branch, addresses.Branches.Count - 1)]; for (int i = 0; i < dataBranch.Count; i++) { string dataItem = dataBranch[i].ToString(); string addressItem = addressBranch[Math.Min(i, addressBranch.Count - 1)].ToString(); int colOffset = 0; int rowOffset = 0; if (rowColumn) // if true, data is structured in rows - otherwise in columns { colOffset = (incrementItems) ? i : 0; rowOffset = (incrementBranches) ? i_branch : 0; } else { colOffset = (incrementBranches) ? i_branch : 0; rowOffset = (incrementItems) ? i : 0; } long colAddress = GDriveUtil.colFromAddress(addressItem) + colOffset; long rowAddress = GDriveUtil.rowFromAddress(addressItem) + rowOffset; if (colAddress > maxCol) maxCol = (uint)colAddress; if (rowAddress > maxRow) maxRow = (uint)rowAddress; addressItem = GDriveUtil.addressFromCells(colAddress, rowAddress); //list of cell addresses that corresponds to input data order addressesOut.Append(new GH_String(addressItem),data.Paths[i_branch]); //dictionary of addresses + data to write - prep for batch write operation. try { writeMap.Add(addressItem, dataItem); //will throw an error if you try to write to the same cell twice - key is already in dictionary. } catch { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "You are trying to write into the same cell twice. Some data is being lost"); } } } return writeMap; }
/// <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) { #region INPUTS List<Curve> things = new List<Curve>(); if (!DA.GetDataList(0, things)) return; #region Optional Inputs int mainSegmentCount = 0; if (!DA.GetData(1, ref mainSegmentCount)) { } int subSegmentCount = 0; if (!DA.GetData(2, ref subSegmentCount)) { } double maxAngleRadians = 0.05; if (!DA.GetData(3, ref maxAngleRadians)) { } double maxChordLengthRatio = 0.1; if (!DA.GetData(4, ref maxChordLengthRatio)) { } double maxAspectRatio = 0; if (!DA.GetData(5, ref maxAspectRatio)) { } double tolerance = 0; if (!DA.GetData(6, ref tolerance)) { } double minEdgeLength = 0.1; if (!DA.GetData(7, ref minEdgeLength)) { } double maxEdgeLength = 0; if (!DA.GetData(8, ref maxEdgeLength)) { } bool keepStartPoint = true; if (!DA.GetData(9, ref keepStartPoint)) { } #endregion #endregion List<Curve>[] lines = new List<Curve>[things.Count]; List<PolylineCurve> polylines = new List<PolylineCurve>(); GH_Structure<GH_Curve> Lines = new GH_Structure<GH_Curve>(); for (int i = 0; i < things.Count; i++) { SilkwormSegment segment = new SilkwormSegment(things[i], mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, keepStartPoint); lines[i] = new List<Curve>(); lines[i].AddRange(segment.Segments); PolylineCurve pline = new PolylineCurve(segment.Pline); polylines.Add(pline); } // if (lines.GetUpperBound(0) > 1) // { // for (int i = 0; i < lines.Length; i++) // { // if (lines[i] != null) // { // for (int j = 0; j < lines[i].Count; j++) // { // GH_Curve glines = new GH_Curve(lines[i][j]); // Lines.Insert(glines, new GH_Path(i), j); // } // } // } // } //if (!DA.SetDataTree(0, Lines)) { return; } if (!DA.SetDataList(0, polylines)) { return; } }
private List<RevitObject> AssignOrientation(List<RevitObject> currentList, GH_Structure<GH_Vector> orientations) { List<RevitObject> current = currentList; List<RevitObject> tempObj = new List<RevitObject>(); for (int i = 0; i < orientations.Branches.Count; i++) { RevitObject ro = current[i]; try { Vector3d v = orientations[i][0].Value; LyrebirdPoint p = new LyrebirdPoint {X = v.X, Y = v.Y, Z = v.Z}; ro.Orientation = p; tempObj.Add(ro); } catch (Exception exception) { Debug.WriteLine(exception.Message); } } return tempObj; }
protected override void SolveInstance(IGH_DataAccess DA) { bool runCommand = false; GH_Structure<GH_Point> origPoints = new GH_Structure<GH_Point>(); GH_Structure<GH_Point> adaptPoints = new GH_Structure<GH_Point>(); GH_Structure<GH_Curve> curves = new GH_Structure<GH_Curve>(); GH_Structure<GH_Vector> orientations = new GH_Structure<GH_Vector>(); GH_Structure<GH_Vector> faceOrientations = new GH_Structure<GH_Vector>(); DA.GetData(0, ref runCommand); DA.GetDataTree(1, out origPoints); DA.GetDataTree(2, out adaptPoints); DA.GetDataTree(3, out curves); DA.GetDataTree(4, out orientations); DA.GetDataTree(5, out faceOrientations); // Make sure the family and type is set before running the command. if (runCommand && (familyName == null || familyName == "Not Selected")) { message = "Please select a family/type by double-clicking on the component before running the command."; } else if (runCommand) { // Get the scale GHInfo ghi = new GHInfo(); GHScale scale = ghi.GetScale(Rhino.RhinoDoc.ActiveDoc); // Send to Revit LyrebirdChannel channel = new LyrebirdChannel(appVersion); channel.Create(); if (channel != null) { string documentName = channel.DocumentName(); if (documentName != null) { // Create RevitObjects List<RevitObject> obj = new List<RevitObject>(); #region OriginPoint Based if (origPoints != null && origPoints.Branches.Count > 0) { List<RevitObject> tempObjs = new List<RevitObject>(); // make sure the branches match the datacount if (origPoints.Branches.Count == origPoints.DataCount) { for (int i = 0; i < origPoints.Branches.Count; i++) { GH_Point ghpt = origPoints[i][0]; LyrebirdPoint point = new LyrebirdPoint { X = ghpt.Value.X, Y = ghpt.Value.Y, Z = ghpt.Value.Z }; RevitObject ro = new RevitObject { Origin = point, FamilyName = familyName, TypeName = typeName, Category = category, CategoryId = categoryId, GHPath = origPoints.Paths[i].ToString(), GHScaleFactor = scale.ScaleFactor, GHScaleName = scale.ScaleName }; tempObjs.Add(ro); } obj = tempObjs; } else { // Inform the user they need to graft their inputs. Only one point per branch System.Windows.Forms.MessageBox.Show("Warning:\n\nEach Branch represents an object, " + "so origin point based elements should be grafted so that each point is on it's own branch."); } } #endregion #region AdaptiveComponents else if (adaptPoints != null && adaptPoints.Branches.Count > 0) { // generate adaptive components List<RevitObject> tempObjs = new List<RevitObject>(); for (int i = 0; i < adaptPoints.Branches.Count; i++) { RevitObject ro = new RevitObject(); List<LyrebirdPoint> points = new List<LyrebirdPoint>(); for (int j = 0; j < adaptPoints.Branches[i].Count; j++) { LyrebirdPoint point = new LyrebirdPoint(adaptPoints.Branches[i][j].Value.X, adaptPoints.Branches[i][j].Value.Y, adaptPoints.Branches[i][j].Value.Z); points.Add(point); } ro.AdaptivePoints = points; ro.FamilyName = familyName; ro.TypeName = typeName; ro.Origin = null; ro.Category = category; ro.CategoryId = categoryId; ro.GHPath = adaptPoints.Paths[i].ToString(); ro.GHScaleFactor = scale.ScaleFactor; ro.GHScaleName = scale.ScaleName; tempObjs.Add(ro); } obj = tempObjs; } #endregion #region Curve Based else if (curves != null && curves.Branches.Count > 0) { // Get curves for curve based components // Determine if we're profile or line based if (curves.Branches.Count == curves.DataCount) { // Determine if the curve is a closed planar curve Curve tempCrv = curves.Branches[0][0].Value; if (tempCrv.IsPlanar(0.00000001) && tempCrv.IsClosed) { // Closed planar curve List<RevitObject> tempObjs = new List<RevitObject>(); for (int i = 0; i < curves.Branches.Count; i++) { Curve crv = curves[i][0].Value; List<Curve> rCurves = new List<Curve>(); bool getCrvs = CurveSegments(rCurves, crv, true); if (rCurves.Count > 0) { RevitObject ro = new RevitObject(); List<LyrebirdCurve> lbCurves = new List<LyrebirdCurve>(); for (int j = 0; j < rCurves.Count; j++) { LyrebirdCurve lbc; lbc = GetLBCurve(rCurves[j]); lbCurves.Add(lbc); } ro.Curves = lbCurves; ro.FamilyName = familyName; ro.Category = category; ro.CategoryId = categoryId; ro.TypeName = typeName; ro.Origin = null; ro.GHPath = curves.Paths[i].ToString(); ro.GHScaleFactor = scale.ScaleFactor; ro.GHScaleName = scale.ScaleName; tempObjs.Add(ro); } } obj = tempObjs; } else if (!tempCrv.IsClosed) { // Line based. Can only be arc or linear curves List<RevitObject> tempObjs = new List<RevitObject>(); for (int i = 0; i < curves.Branches.Count; i++) { Curve ghc = curves.Branches[i][0].Value; // Test that there is only one curve segment PolyCurve polycurve = ghc as PolyCurve; if (polycurve != null) { Curve[] segments = polycurve.Explode(); if (segments.Count() != 1) { break; } } if (ghc != null) { //List<LyrebirdPoint> points = new List<LyrebirdPoint>(); LyrebirdCurve lbc = GetLBCurve(ghc); List<LyrebirdCurve> lbcurves = new List<LyrebirdCurve> { lbc }; RevitObject ro = new RevitObject { Curves = lbcurves, FamilyName = familyName, Category = category, CategoryId = categoryId, TypeName = typeName, Origin = null, GHPath = curves.Paths[i].ToString(), GHScaleFactor = scale.ScaleFactor, GHScaleName = scale.ScaleName }; tempObjs.Add(ro); } } obj = tempObjs; } } else { // Make sure all of the curves in each branch are closed bool allClosed = true; DataTree<CurveCheck> crvTree = new DataTree<CurveCheck>(); for (int i = 0; i < curves.Branches.Count; i++) { List<GH_Curve> ghCrvs = curves.Branches[i]; List<CurveCheck> checkedcurves = new List<CurveCheck>(); GH_Path path = new GH_Path(i); for (int j = 0; j < ghCrvs.Count; j++) { Curve c = ghCrvs[j].Value; if (c.IsClosed) { AreaMassProperties amp = AreaMassProperties.Compute(c); if (amp != null) { double area = amp.Area; CurveCheck cc = new CurveCheck(c, area); checkedcurves.Add(cc); } } else { allClosed = false; } } if (allClosed) { // Sort the curves by area checkedcurves.Sort((x, y) => x.Area.CompareTo(y.Area)); checkedcurves.Reverse(); foreach (CurveCheck cc in checkedcurves) { crvTree.Add(cc, path); } } } if (allClosed) { // Determine if the smaller profiles are within the larger bool allInterior = true; List<RevitObject> tempObjs = new List<RevitObject>(); for (int i = 0; i < crvTree.Branches.Count; i++) { try { List<int> crvSegmentIds = new List<int>(); List<LyrebirdCurve> lbCurves = new List<LyrebirdCurve>(); List<CurveCheck> checkedCrvs = crvTree.Branches[i]; Curve outerProfile = checkedCrvs[0].Curve; double outerArea = checkedCrvs[0].Area; List<Curve> planarCurves = new List<Curve>(); planarCurves.Add(outerProfile); double innerArea = 0.0; for (int j = 1; j < checkedCrvs.Count; j++) { planarCurves.Add(checkedCrvs[j].Curve); innerArea += checkedCrvs[j].Area; } // Try to create a planar surface IEnumerable<Curve> surfCurves = planarCurves; Brep[] b = Brep.CreatePlanarBreps(surfCurves); if (b.Count() == 1) { // Test the areas double brepArea = b[0].GetArea(); double calcArea = outerArea - innerArea; double diff = (brepArea - calcArea) / calcArea; if (diff < 0.1) { // The profiles probably are all interior foreach (CurveCheck cc in checkedCrvs) { Curve c = cc.Curve; List<Curve> rCurves = new List<Curve>(); bool getCrvs = CurveSegments(rCurves, c, true); if (rCurves.Count > 0) { int crvSeg = rCurves.Count; crvSegmentIds.Add(crvSeg); foreach (Curve rc in rCurves) { LyrebirdCurve lbc; lbc = GetLBCurve(rc); lbCurves.Add(lbc); } } } RevitObject ro = new RevitObject(); ro.Curves = lbCurves; ro.FamilyName = familyName; ro.Category = category; ro.CategoryId = categoryId; ro.TypeName = typeName; ro.Origin = null; ro.GHPath = crvTree.Paths[i].ToString(); ro.GHScaleFactor = scale.ScaleFactor; ro.GHScaleName = scale.ScaleName; ro.CurveIds = crvSegmentIds; tempObjs.Add(ro); } } else { allInterior = false; message = "Warning:\n\nEach Branch represents an object, " + "so curve based elements should be grafted so that each curve is on it's own branch, or all curves on a branch should " + "be interior to the largest, outer boundary."; } } catch { allInterior = false; // Inform the user they need to graft their inputs. Only one curve per branch message = "Warning:\n\nEach Branch represents an object, " + "so curve based elements should be grafted so that each curve is on it's own branch, or all curves on a branch should " + "be interior to the largest, outer boundary."; } } if (tempObjs.Count > 0) { obj = tempObjs; } } } } #endregion // Orientation if (orientations != null && orientations.Branches.Count > 0) { List<RevitObject> tempList = AssignOrientation(obj, orientations); obj = tempList; } // face orientation if (faceOrientations != null && faceOrientations.Branches.Count > 0) { List<RevitObject> tempList = AssignFaceOrientation(obj, faceOrientations); obj = tempList; } // Parameters... if (Params.Input.Count > 6) { List<RevitObject> currentObjs = obj; List<RevitObject> tempObjs = new List<RevitObject>(); for (int r = 0; r < currentObjs.Count; r++) { RevitObject ro = currentObjs[r]; List<RevitParameter> revitParams = new List<RevitParameter>(); for (int i = 6; i < Params.Input.Count; i++) { RevitParameter rp = new RevitParameter(); IGH_Param param = Params.Input[i]; string paramInfo = param.Description; string[] pi = paramInfo.Split(new[] { "\n", ":" }, StringSplitOptions.None); string paramName = null; try { paramName = pi[1].Substring(1); string paramStorageType = pi[5].Substring(1); rp.ParameterName = paramName; rp.StorageType = paramStorageType; } catch (Exception ex) { Debug.WriteLine(ex.Message); } if (paramName != null) { GH_Structure<IGH_Goo> data = null; try { DA.GetDataTree(i, out data); } catch (Exception ex) { Debug.WriteLine(ex.Message); } if (data != null) { string value = data[r][0].ToString(); rp.Value = value; revitParams.Add(rp); } } } ro.Parameters = revitParams; tempObjs.Add(ro); } obj = tempObjs; } // Send the data to Revit to create and/or modify family instances. if (obj != null && obj.Count > 0) { try { string docName = channel.DocumentName(); if (docName == null || docName == string.Empty) { message = "Could not contact the lyrebird server. Make sure it's running and try again."; } else { string nn = NickName; if (nn == null || nn.Length == 0) { nn = "LBOut"; } channel.CreateOrModify(obj, InstanceGuid, NickName); message = obj.Count.ToString() + " objects sent to the lyrebird server."; } } catch { message = "Could not contact the lyrebird server. Make sure it's running and try again."; } } channel.Dispose(); try { } catch (Exception ex) { Debug.WriteLine(ex.Message); } } else { message = "Error\n" + "The Lyrebird Service could not be found. Ensure Revit is running, the Lyrebird server plugin is installed, and the server is active."; } } } else { message = null; } // Check if the revit information is set if (familyName != null || (familyName != "Not Selected" && typeName != "Not Selected")) { StringBuilder sb = new StringBuilder(); sb.AppendLine("Family: " + familyName); sb.AppendLine("Type: " + typeName); sb.AppendLine("Category: " + category); for (int i = 0; i < inputParameters.Count; i++) { RevitParameter rp = inputParameters[i]; string type = "Instance"; if (rp.IsType) { type = "Type"; } sb.AppendLine(string.Format("Parameter{0}: {1} / {2} / {3}", (i + 1).ToString(CultureInfo.InvariantCulture), rp.ParameterName, rp.StorageType, type)); } objMessage = sb.ToString(); } else { objMessage = "No data type set. Double-click to set data type"; } DA.SetData(0, objMessage); DA.SetData(1, message); }
/// <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) { #region INPUTS // import silkwormSettings file List<string> silkwormSettings = new List<string>(); if (!DA.GetDataList(0, silkwormSettings)) return; List<Brep> things = new List<Brep>(); if (!DA.GetDataList(1, things)) return; // import Silkworm Movement SilkwormUtility sUtil = new SilkwormUtility(); Dictionary<string, string> Settings = sUtil.convertSettings(silkwormSettings); SilkwormCalculator calc = new SilkwormCalculator(Settings); #region Optional Inputs int infType = 0; if (!DA.GetData(2, ref infType)) { } List<double> spacing = new List<double>(); if (!DA.GetDataList(3, spacing)) { } List<double> infDens = new List<double>(); if (!DA.GetDataList(4, infDens)) { } List<double> infRot = new List<double>(); if (!DA.GetDataList(5, infRot)) { } #endregion if (spacing.Count<1) { spacing.Add(0.66); //TODO Calculator } if (infDens.Count < 1) { infDens.Add(double.Parse(Settings["fill_density"])); } if (infRot.Count < 1) { infRot.Add(double.Parse(Settings["fill_angle"])); } #endregion SilkwormSkein skein = new SilkwormSkein(Settings, things); //Switch depending on which infill type is selected by input if (infType == 0) { //Match length of data if (spacing.Count != things.Count) { List<double> newspacing = new List<double>(); for (int e = 0; e < things.Count; e++) { newspacing.Add(spacing[0]); } spacing = newspacing; } skein.Skinner(spacing); } if (infType == 1) { //Match length of data if (infDens.Count != things.Count) { List<double> newinfDens = new List<double>(); for (int e = 0; e < things.Count; e++) { newinfDens.Add(infDens[0]); } spacing = newinfDens; } if (infRot.Count != things.Count) { List<double> newinfRot = new List<double>(); for (int e = 0; e < things.Count; e++) { newinfRot.Add(infRot[0]); } spacing = newinfRot; } skein.Filler(infDens, infRot); } //Reflect Errors and Warnings foreach (string message in skein.ErrorMessages) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message); } foreach (string message in skein.WarningMessages) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message); } //Output Holders List<Curve>[] plPerimeter = skein.curvePerimeter; List<Curve>[] plInfill = skein.curveInfill; GH_Structure<GH_Curve> InfillRegion = new GH_Structure<GH_Curve>(); //Create GH_Structure #region Create Structure from Curves if (plPerimeter.Length > 0) { for (int i = 0; i < plPerimeter.Length; i++) { if (plPerimeter[i] != null) { for (int j = 0; j < plPerimeter[i].Count; j++) { Curve aShape = plPerimeter[i][j].ToNurbsCurve(); GH_Curve gShapes = new GH_Curve(aShape); InfillRegion.Insert(gShapes, new GH_Path(i, 0), j); //} } } } } if (plInfill.Length > 0) { for (int i = 0; i < plInfill.Length; i++) { if (plInfill[i] != null) { for (int j = 0; j < plInfill[i].Count; j++) { Curve aShape = plInfill[i][j].ToNurbsCurve(); GH_Curve gShapes = new GH_Curve(aShape); InfillRegion.Insert(gShapes, new GH_Path(i, 1), j); } } } } #endregion //Output if (!DA.SetDataTree(0, InfillRegion)) { return; } }