//http://www.pointclouds.org/documentation/tutorials/normal_estimation.php
//https://www.cloudcompare.org/doc/wiki/index.php?title=Normals%5CCompute
public static List <Vector3d> LineCloudNormals(DataTree <Line> lines, DataTree <int> adj)
{
List <Vector3d> _Normals = new List <Vector3d>();
//Compute bounding box of cloud
BoundingBox bbox = new BoundingBox();
foreach (Line l in lines.AllData())
{
bbox.Union(l.From);
bbox.Union(l.To);
}
bbox.Inflate(100);
Point3d p = bbox.PointAt(0.5, 0.5, 1);
//Iterate through joints
//Fit to Plane
//Add all lines point to a base datatree
DataTree <Point3d> pts = new DataTree <Point3d>();
for (int i = 0; i < lines.BranchCount; i++)
{
pts.Add(lines.Branch(i)[0].From, new GH_Path(i));
pts.Add(lines.Branch(i)[0].To, new GH_Path(i));
}
//Add only second object point to first object path
for (int i = 0; i < adj.BranchCount; i++)
{
int id0 = adj.Branch(i)[0];
int id1 = adj.Branch(i)[1];
pts.Add(lines.Branch(id1)[0].From, new GH_Path(id0));
pts.Add(lines.Branch(id1)[0].To, new GH_Path(id0));
}
//Orient Plane
for (int i = 0; i < pts.BranchCount; i++)
{
Plane.FitPlaneToPoints(pts.Branch(i), out Plane plane);
plane.Origin = (pts.Branch(i)[0] + pts.Branch(i)[1]) * 0.5;
if ((plane.Origin + plane.Normal).DistanceToSquared(p) > (plane.Origin - plane.Normal).DistanceToSquared(p))
{
plane.Flip();
}
_Normals.Add(plane.Normal);
}
return(_Normals);
}
//Thic function replicate SandBox lines topology
//As inputs there are lines
//Tolerance is used to glued points thar are close to each others
//Outputs are
//points list of Point3d
//linePoint dataTree containing the points index number for end and beginning of the line
//pointPoint dataTree containing the points index number for each other point connected to this point
public static void LineTopology(List <Line> lines, double tolerance, ref List <Point3d> points, ref DataTree <int> linePoint, ref DataTree <int> pointPoint, ref DataTree <int> pointLine)
{
for (int n_line = 0; n_line < lines.Count; n_line++)
{
bool addPoint = true;
int nPoint = 0;
for (int i = 0; i < points.Count; i++)
{
if (points[i].DistanceTo(lines[n_line].From) < tolerance)
{
addPoint = false;
nPoint = i;
}
}
if (addPoint)
{
points.Add(lines[n_line].From);
linePoint.Add(points.Count - 1, new GH_Path(n_line));
}
else
{
linePoint.Add(nPoint, new GH_Path(n_line));
}
addPoint = true;
for (int i = 0; i < points.Count; i++)
{
if (points[i].DistanceTo(lines[n_line].To) < tolerance)
{
addPoint = false;
nPoint = i;
}
}
if (addPoint)
{
points.Add(lines[n_line].To);
linePoint.Add(points.Count - 1, new GH_Path(n_line));
}
else
{
linePoint.Add(nPoint, new GH_Path(n_line));
}
}
for (int n_line = 0; n_line < linePoint.BranchCount; n_line++)
{
pointPoint.Add(linePoint.Branches[n_line][0], new GH_Path(linePoint.Branches[n_line][1]));
pointPoint.Add(linePoint.Branches[n_line][1], new GH_Path(linePoint.Branches[n_line][0]));
}
for (int j = 0; j < linePoint.BranchCount; j++)
{
pointLine.Add(j, new GH_Path(linePoint.Branch(j)[0]));
pointLine.Add(j, new GH_Path(linePoint.Branch(j)[1]));
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
///////////////////////////////////////////////////////////////////////////////////////////////////声明变量
List <Curve> c = new List <Curve>();
double t1 = 0;
double t2 = 0;
///////////////////////////////////////////////////////////////////////////////////////////////////检测输入端是否合理
if (!DA.GetDataList(0, c))
{
return;
}
if (!DA.GetData(1, ref t1))
{
return;
}
if (!DA.GetData(2, ref t2))
{
return;
}
DataTree <Curve> last = new DataTree <Curve>();
DataTree <Point3d> collects = ViperClass.EmptyTree(c.Count);
int index = 0;
int branch = DA.Iteration;
for (int i = 0; i < c.Count; i++)
{
for (int q = i + 1; q < c.Count; q++)
{
Rhino.Geometry.Intersect.CurveIntersections result = Rhino.Geometry.Intersect.Intersection.CurveCurve(c[i], c[q], t1, t2);
if (result.Count > 0) ////有交集
{
for (int k = 0; k < result.Count; k++) ////记录每次相交的t值并分别赋值给两曲线
{
collects.Branch(i).Add((result[k].PointA));
collects.Branch(q).Add((result[k].PointB));
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
for (int i = 0; i < c.Count; i++)
{
if (collects.Branch(i).Count == 0)
{
last.Add(c[i], new GH_Path(0, branch, index));
index++;
continue;
}
last.AddRange(ViperClass.SplitByPts(c[i], collects.Branch(i).ToList()), new GH_Path(0, branch, index));
index++;
}
DA.SetDataTree(0, last);
}
private void RunScript(DataTree <Plane> iWrap, DataTree <Plane> iAllPlanes, DataTree <Plane> iTravelPlanes, ref object oProjectedPlanes, ref object oDebug, ref object oDebugB)
{
// <Custom code>
DataTree <int> iWrapCounts = new DataTree <int>();
for (int i = 0; i < iWrap.BranchCount; i++)
{
GH_Path pth = new GH_Path(i);
iWrapCounts.Add(iWrap.Branch(i).Count, pth);
}
DataTree <int> iTravelCounts = new DataTree <int>();
for (int i = 0; i < iTravelPlanes.BranchCount; i++)
{
GH_Path pth = new GH_Path(i);
iTravelCounts.Add(iTravelPlanes.Branch(i).Count, pth);
}
DataTree <int> iSelectionIndexes = new DataTree <int>();
for (int i = 0; i < iTravelCounts.BranchCount; i++)
{
GH_Path pth = new GH_Path(i);
for (int y = 0; y < iTravelCounts.Branch(i)[0]; y++)
{
iSelectionIndexes.Add(iWrapCounts.Branch(i)[0] + y, pth);
}
}
DataTree <Plane> projectedPlanes = new DataTree <Plane>();
for (int i = 0; i < iAllPlanes.BranchCount; i++)
{
GH_Path pth = new GH_Path(i);
for (int y = 0; y < iSelectionIndexes.Branch(i).Count; y++)
{
Plane tempPlane = iAllPlanes.Branch(i)[iSelectionIndexes.Branch(i)[y]];
Plane tempPlane2 = iTravelPlanes.Branch(i)[y];
tempPlane2.Origin = tempPlane.Origin;
projectedPlanes.Add(tempPlane2, pth);
iAllPlanes.Branch(i)[iSelectionIndexes.Branch(i)[y]] = tempPlane2;
}
}
oProjectedPlanes = iAllPlanes;
oDebug = iWrapCounts;
oDebugB = projectedPlanes;
// </Custom code>
}
public static List <List <Point3d> > TreeToList(DataTree <Point3d> Points)
{
List <List <Point3d> > outPoints = new List <List <Point3d> >();
for (int i = 0; i < Points.BranchCount; i++)
{
List <Point3d> temppoints = new List <Point3d>();
for (int j = 0; j < Points.Branch(i).Count; j++)
{
temppoints.Add(Points.Branch(i)[j]);
}
outPoints.Add(temppoints);
}
return(outPoints);
}
/// <summary>
/// Draws a gradient trail through the display pipeline
/// </summary>
/// <param name="args">preview Display Args for IGH_PreviewObjects</param>
/// <param name="particleSet">The data tree containing the points list for each object you want to draw a gradient for</param>
/// <param name="colorType">the color type</param>
/// <param name="minTrailThickness">the minimum trail thickness</param>
/// <param name="maxTrailThickness">the maximum trail thickness</param>
public void DrawGradientTrails(IGH_PreviewArgs args, DataTree <Point3d> particleSet, int colorType, float minTrailThickness, float maxTrailThickness)
{
Color color = args.WireColour;
for (int i = 0; i < particleSet.BranchCount; i++)
{
List <Point3d> ptlist = particleSet.Branch(i);
//-------DRAW TRAILS AS SEGMENTS WITH CUSTOM STROKE WIDTH---------
if (ptlist.Count > 0)
{
for (int x = 0; x < ptlist.Count; x++)
{
if (x != 0)
{
float stroke = CulebraData.Utilities.Mapping.Map(x / (1.0f * ptlist.Count), 0.0f, 1.0f, minTrailThickness, maxTrailThickness);
float colorValue = CulebraData.Utilities.Mapping.Map(x / (1.0f * ptlist.Count), 0.0f, 1.0f, 0f, 255.0f);
if (colorType == 0)
{
args.Display.DrawLine(ptlist[x - 1], ptlist[x], Color.FromArgb(0, (int)colorValue, 0, 100), (int)stroke);
}
else if (colorType == 1)
{
args.Display.DrawLine(ptlist[x - 1], ptlist[x], Color.FromArgb(0, 0, 255, (int)colorValue), (int)stroke);
}
else
{
args.Display.DrawLine(ptlist[x - 1], ptlist[x], Color.FromArgb(0, 255, 255, (int)colorValue), (int)stroke);
}
}
}
}
}
}
protected override void SetOutputs(IGH_DataAccess da)
{
outTree = new DataTree <Point3d>();
GH_Path trunk = new GH_Path(0); // {0}
GH_Path branch = new GH_Path(); // {}\
GH_Path limb = new GH_Path();
for (int i = 0; i < particles.Count; i++)
{
IQuelea particle = particles[i];
branch = trunk.AppendElement(i);
DataTree <Point3d> particlePositionHistoryTree = particle.Position3DHistory.ToTree();
for (int j = 0; j < particlePositionHistoryTree.BranchCount; j++)
{
limb = branch.AppendElement(j);
//for (int k = particlePositionHistoryTree.Branch(j).Count - 1; k >= 0; k--)
//{
// outTree.Add(particlePositionHistoryTree.Branch(j)[k], limb);
//}
outTree.AddRange(particlePositionHistoryTree.Branch(j), limb);
}
}
da.SetDataTree(nextOutputIndex++, outTree);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
List <string> colList = new List <string>();
string path = "";
DA.GetData(IN_imagePath, ref path);
DA.GetDataList(IN_colList, colList);
imageProcessor = new ImageProcessor(path, colList);
var areaPts = imageProcessor._areaPoints;
var programCentroids = imageProcessor._progCentroids;
var perimPts = imageProcessor._ProcessedPts;
BoundaryExtractor engine = new BoundaryExtractor(perimPts, programCentroids);
var ptTree = engine.outTree;
//temp polylineTree
DataTree <Polyline> treeInterim = new DataTree <Polyline>();
for (int i = 0; i < ptTree.BranchCount; i++)
{
Polyline poly = new Polyline();
poly.AddRange(ptTree.Branch(i));
poly.Add(ptTree.Branch(i)[0]);
treeInterim.Add(poly, new GH_Path(ptTree.Path(i).Indices[0]));
}
//final output tree
DataTree <Polyline> treeOut = new DataTree <Polyline>();
for (int i = 0; i < treeInterim.BranchCount; i++)
{
if (treeInterim.Branch(i).Count == 2)
{
treeOut.Add(treeInterim.Branch(i).OrderByDescending(l => l.Length).ToArray()[0], new GH_Path(treeInterim.Path(i)));
}
else
{
treeOut.AddRange(treeInterim.Branch(i), new GH_Path(treeInterim.Path(i)));
}
}
DA.SetDataTree(OUT_polyTree, treeOut);
}
protected override void RegisterInputParams(GH_InputParamManager pManager)
{
var t = new DataTree <int>();
var a = t.Branch();
_keyIn = pManager.AddTextParameter("Key", "K", "Key", GH_ParamAccess.list);
_valueIn = pManager.AddTextParameter("Value", "V", "Value", GH_ParamAccess.list);
}
// <Custom additional code>
public void IdentifyPinIndexes(WindingClass wC, DataTree <Point3d> anchors)
{
// Find pin index
double minDistancePin = double.MaxValue;
for (var i = 0; i < anchors.Branch(wC.edgeIndex).Count; i++)
{
Point3d pt = wC.basePlane.Origin;
double distancePin = pt.DistanceTo(anchors.Branch(wC.edgeIndex)[i]);
if (distancePin < minDistancePin)
{
minDistancePin = distancePin;
wC.pinIndex = i;
}
}
}
public void Add(Point3d position, bool wrapped)
{
if (Count >= size)
{
tree.Branch(0).RemoveAt(0);
if (tree.Branch(0).Count == 0)
{
tree.RemovePath(tree.Path(0));
}
}
if (wrapped)
{
nextPathIndex++;
}
tree.Add(position, new GH_Path(nextPathIndex));
}
// public Input(int num)
// {
// w = new double[num];
// for (int i = 0; i < num; i++)
// w[i] = rnd.NextDouble();
// }
//extracting the program data (6 programs) and assigning weights per the data
public Input(int num, int branch, DataTree <double> _pData)
{
w = new double[num];
for (int j = 0; j < num; j++)
{
var b = _pData.Branch(branch);
w[j] = b[j];
}
}
public BoundaryExtractor(DataTree <Point3d> pTree, Point3d [] centList)
{
pointTree = pTree;
outTree = new DataTree <Point3d>();
// centroids = new List<Point3d>();
for (int i = 0; i < pointTree.BranchCount; i++)
{
BranchWork(pointTree.Branch(i), i, centList[i]);
}
}
public KMap(DataTree <double> ProgramInputs, List <Point3d> NodePts, double resolution, DataTree <double> NodeData, int numW, double learn, List <double> radMultiplier, double BMUradMultiplier, int maxIterations) // BMU rad might want to be smaller than radMultiplier
{
m_pNames = new List <string>();
this.numNodes = NodePts.Count;
learning = learn;
radius = radMultiplier;
inputW = new DataTree <double>();
progInputs = ProgramInputs;
applyProgramInputs(radius.Count);
bmuMultiplier = BMUradMultiplier;
maxIters = maxIterations;
this.numWeights = numW;
cRadius = resolution / 2.0;
nodeW = new DataTree <double>();
nodeWeights = new List <double>();
nodePoints = new List <Point3d>();
nodePoints = NodePts;
tree = new DataTree <Polyline>();
drawingPolys = new List <Polyline>();
_nodeData = new DataTree <double>();
_nodeData = NodeData;
discreteCol = new List <System.Drawing.Color>();
iter = 0;
nodes = new Node[numNodes];
double average = 0.0;
for (int i = 0; i < radius.Count; i++)
{
average += radius[i];
}
average /= radius.Count;
for (int i = 0; i < numNodes; i++)
{
var pt = nodePoints[i];
nodes[i] = new Node(pt, _nodeData.Branch(i));
}
timeConstant = maxIters / Math.Log(average);
for (int i = 0; i < inputs.Length; i++)
{
radiusDecay.Add(radius[i]);
}
}
static List <List <T> > TreeToListOfLists <T>(DataTree <T> tree)
{
List <List <T> > list = new List <List <T> >();
foreach (GH_Path p in tree.Paths)
{
List <T> l = tree.Branch(p);
list.Add(l);
}
return(list);
}
public void GetPointBoundaries(out List <string> length)
{
_ProcessedPts = new DataTree <Point3d>();
length = new List <string>();
for (int i = 0; i < _areaPoints.BranchCount; i++)
{
var outPts = ExtractPerimeterPts(_areaPoints.Branch(i));
_ProcessedPts.AddRange(outPts, new GH_Path(i));
length.Add(outPts.Count.ToString());
}
}
/// <summary>
/// Write XML
///string settings_path = @"C:\Users\petra\AppData\Roaming\Grasshopper\6\Libraries\RhinoJoint\TileTypeSettings.xml";
///TilesToXML(male, female, type, settings_path);
/// </summary>
/// <param name="male"></param>
/// <param name="female"></param>
/// <param name="type"></param>
/// <param name="settings_path"></param>
public static void TilesToXML(DataTree <Polyline> male, DataTree <Polyline> female, DataTree <string> type, string settings_path)
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
//string settings_path = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "TileTypeSettings.xml");
var root = new XElement("Tile");
for (int i = 0; i < type.BranchCount; i++)
{
if (male.Branch(i).Count == 0)
{
continue;
}
var tileXML = PolylinesToXML(male.Branch(i), female.Branch(i), type.Branch(i)[0]);
root.Add(tileXML);
}
//1. Add root to document
XDocument doc = new XDocument(root);
doc.Save(settings_path);
}
private IGH_DataTree GeometryTree <T>(DataTree <T> output)
{
DataTree <object> newOutput = new DataTree <object>();
for (int b = 0; b < output.BranchCount; b++)
{
var p = output.Path(b);
var currentBranch = output.Branch(b);
var newBranch = GeometryList(currentBranch);
newOutput.AddRange(newBranch, p);
}
return(newOutput);
}
public void CreateCurves()
{
//Curve At Top
#region PointsAtTop
List <Point3d> _PointsAtTop = new List <Point3d>(PointsAtTop);
_PointsAtTop.Add(PointsAtTop[0]);
CurvesAtTop.Add(Curve.CreateControlPointCurve(_PointsAtTop));
#endregion PointsAtTop
//Curve AT Bottom
#region PointsAtBottom
List <Point3d> _PointsAtBottom = new List <Point3d>(PointsAtBottom);
_PointsAtBottom.Add(PointsAtBottom[0]);
CurvesAtBottom.Add(Curve.CreateControlPointCurve(_PointsAtBottom));
#endregion PointsAtBottom
//Curve AT Top Plate
#region PointsAtTopPlate
if (PointsAtTopPlate != null)
{
List <Point3d> _PointsAtTopPlate = new List <Point3d>(PointsAtTopPlate);
_PointsAtTopPlate.Add(PointsAtTopPlate[0]);
CurvesAtTopPlate.Add(Curve.CreateControlPointCurve(_PointsAtTopPlate));
}
#endregion PointsAtTopPlate
//Curves At Bottom Plate
#region PointsAtBottomPlate
if (PointsAtBottomPlate != null)
{
List <Point3d> _PointsAtBottomPlate = new List <Point3d>(PointsAtBottomPlate);
_PointsAtBottomPlate.Add(PointsAtBottomPlate[0]);
CurvesAtBottomPlate.Add(Curve.CreateControlPointCurve(_PointsAtBottomPlate));
}
#endregion PointsAtBottomPlate
//Curves At Loop
#region PointsAtLoop
for (int i = 0; i < PointsAtLoop.BranchCount; i++)
{
CurvesAtLoop.Add(Curve.CreateControlPointCurve(PointsAtLoop.Branch(i), 3));
}
#endregion PointsAtLoop
}
protected override void SolveInstance(IGH_DataAccess da)
{
if (!GetInputs(da))
{
return;
}
if (reset == true)
{
trailTree = new DataTree <Point3d>();
iter = 0;
maxid = 0;
}
else
{
foreach (Amoeba amo in p.population)
{
GH_Path thispath = new GH_Path(amo.ID);
if (amo.ID > maxid)
{
trailTree.Add(amo.prev_loc, thispath);
maxid = amo.ID;
}
trailTree.Add(amo.Location, thispath);
if (trailTree.Branch(thispath).Count > history)
{
trailTree.Branch(thispath).RemoveAt(0);
}
}
foreach (int id in p._todie_id)
{
GH_Path thispath = new GH_Path(id);
trailTree.Branch(thispath).Clear();
}
iter++;
}
SetOutputs(da);
}
// ===============================================================================================
// reorganized certain indices in a list of 4 itemss
// ===============================================================================================
public static DataTree <T> ReOrganize2 <T>(DataTree <T> tree)
{
for (int i = 0; i < tree.BranchCount; i++)
{
var temp1 = tree.Branch(i)[2];
var temp2 = tree.Branch(i)[3];
tree.Branch(i)[2] = temp2;
tree.Branch(i)[3] = temp1;
temp1 = tree.Branch(i)[4];
temp2 = tree.Branch(i)[5];
tree.Branch(i)[4] = temp2;
tree.Branch(i)[5] = temp1;
}
return(tree);
}
/// <summary>
/// Draws a polyline trail through the display pipeline
/// </summary>
/// <param name="args">preview Display Args for IGH_PreviewObjects</param>
/// <param name="particleSet">The data tree containing the points list for each object you want to draw a gradient for</param>
/// <param name="dottedPolyline">do you want a dotted polyline</param>
/// <param name="thickness">the thickness of the trail</param>
/// <param name="color">the color of the trail</param>
public void DrawPolylineTrails(IGH_PreviewArgs args, DataTree <Point3d> particleSet, bool dottedPolyline, int thickness, System.Drawing.Color color)
{
for (int i = 0; i < particleSet.BranchCount; i++)
{
List <Point3d> ptlist = particleSet.Branch(i);
if (dottedPolyline)
{
args.Display.DrawDottedPolyline(ptlist, color, false);
}
else
{
args.Display.DrawPolyline(ptlist, color, thickness);
}
}
}
private DataTree <Vector3d> GetMemberDisplacementsByType(int result_type)
{
var oDisplacementsByType = new DataTree <Vector3d>();
for (int i = 0; i < _memberdisplacements.Paths.Count; i++)
{
if (_memberdisplacements.Paths[i].Indices[1] == result_type)
{
var oldPath = _memberdisplacements.Paths[i];
var gh_path = new GH_Path(oldPath.Indices[0]);
oDisplacementsByType.AddRange(_memberdisplacements.Branch(oldPath), gh_path);
}
}
return(oDisplacementsByType);
}
/// <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)
{
Sheet sheet = null;
if (!DA.GetData(0, ref sheet))
{
return;
}
DA.SetData(0, sheet.Properties.Title);
DA.SetData(1, sheet.Properties.SheetId);
DA.SetData(2, sheet.Properties.Index);
// empty tree for cell strings
DataTree <string> rowsTree = new DataTree <string>();
// extract strings, add to tree
var rowData = sheet.Data[0].RowData;
for (int i = 0; i < rowData.Count; i++)
{
// create new branch
rowsTree.Insert("", new GH_Path(i), 0);
}
// clear dummy data
rowsTree.ClearData();
for (int i = 0; i < rowData.Count; i++)
{
List <string> rowStrings = new List <string>();
if (!(rowData[i].Values is null))
{
foreach (var value in rowData[i].Values)
{
//rowStrings.Add(value.EffectiveValue?.ToDataString());
rowStrings.Add(value.FormattedValue);
}
}
rowsTree.Branch(i).AddRange(rowStrings);
}
// set row data
DA.SetDataTree(3, rowsTree);
}
}//eof
/// <summary>
/// This is the method that actually does the work.
/// </summary>
protected override void SolveInstance(IGH_DataAccess DA)
{
List<Curve> crv = new List<Curve>();
if (!DA.GetDataList(0, crv)) return;
DataTree<Curve> r = new DataTree<Curve>();
for (int i = 0; i < crv.Count; ++i)
{
if (!isChildOfCrv(crv[i], crv))
{
GH_Path p = new GH_Path(0);
r.Add(crv[i], p);
}
}
bool isAnyCrvAligned = true;
while (isAnyCrvAligned)
{
isAnyCrvAligned = false;
int BC = r.BranchCount;
for (int i = 0; i < BC; ++i)
{
for (int j = 0; j < crv.Count; ++j)
{
if (r.AllData().IndexOf(crv[j]) == -1)
{
GH_Path p = new GH_Path(i + 1);
if (isChildOfCrv(crv[j], r.Branch(i)))
{
r.Add(crv[j], p);
isAnyCrvAligned = true;
}
}
}
}
}
DA.SetDataTree(0, r);
}//eof
private DataTree <Mesh> GetDeformedMeshes(double scale, ref List <string> msg)
{
var oMeshes = new DataTree <Mesh>();
// Same tree structure as displacements
foreach (var path in _meshdisplacements.Paths)
{
var gh_path = new GH_Path(path);
var mesh_path = new GH_Path(path.Indices[0]);
// Get fe mesh as starting mesh
var mesh = _feMeshes.Branch(mesh_path)[0].DuplicateMesh();
// Move FE Nodes according to displacements
for (int i = 0; i < mesh.Vertices.Count; i++)
{
mesh.Vertices[i] += (Point3f)(Point3d)(scale * _meshdisplacements.Branch(path)[i]); // -_-
}
// Add mesh to tree
oMeshes.Add(mesh, gh_path);
}
return(oMeshes);
}
public static void IntersectBreps(DataTree <Brep> panels, DataTree <Brep> foundations, ref DataTree <Polyline> panelsCuts, ref DataTree <Polyline> foundationsCuts)
{
panelsCuts = new DataTree <Polyline>();
foundationsCuts = new DataTree <Polyline>();
// try {
for (int i = 0; i < panels.BranchCount; i++)
{
for (int j = 0; j < foundations.BranchCount; j++)
{
Polyline[] intersection0 = new Polyline[0];
Polyline[] intersection1 = new Polyline[0];
bool isIntersecting = IntersectBreps2x2(panels.Branch(i), foundations.Branch(j), ref intersection0, ref intersection1);
if (isIntersecting && intersection0.Length != 0 && intersection1.Length != 0)
{
Rhino.RhinoDoc.ActiveDoc.Objects.AddPolyline(intersection0[0]);
panelsCuts.AddRange(intersection0, new GH_Path(i));
foundationsCuts.AddRange(intersection1, new GH_Path(j));
}
}
}
//} catch (Exception e) {
// Print(e.ToString());
//}
//A = panelsCuts;
//B = foundationsCuts;
}
/// <summary>
/// Draws a disco trail through the display pipeline. Trails flash different colors throughout the simulation
/// </summary>
/// <param name="args">preview Display Args for IGH_PreviewObjects</param>
/// <param name="particleSet">The data tree containing the points list for each object you want to draw a gradient for</param>
/// <param name="randomGen">an instance of the random class</param>
/// <param name="minTrailThickness">the minimum trail thickness</param>
/// <param name="maxTrailThickness">the maximum trail thickness</param>
public void DrawDiscoTrails(IGH_PreviewArgs args, DataTree <Point3d> particleSet, Random randomGen, float minTrailThickness, float maxTrailThickness)
{
Color color = args.WireColour;
for (int i = 0; i < particleSet.BranchCount; i++)
{
List <Point3d> ptlist = particleSet.Branch(i);
//-------DRAW TRAILS AS SEGMENTS WITH CUSTOM STROKE WIDTH---------
Color randomColorAction = CulebraData.Utilities.ColorUtility.GetRandomColor(randomGen);
if (ptlist.Count > 0)
{
for (int x = 0; x < ptlist.Count; x++)
{
if (x != 0)
{
float stroke = CulebraData.Utilities.Mapping.Map(x / (1.0f * ptlist.Count), 0.0f, 1.0f, minTrailThickness, maxTrailThickness);
args.Display.DrawLine(ptlist[x - 1], ptlist[x], randomColorAction, (int)stroke);
}
}
}
}
}
private DataTree <Curve> GetDeformedMembers(double scale, ref List <string> msg)
{
var oCurves = new DataTree <Curve>();
// Same tree structure as displacements
foreach (var path in _memberdisplacements.Paths)
{
var gh_path = new GH_Path(path);
var member_path = new GH_Path(path.Indices[0]);
// Get deformed control points
var ctrlPoints = _controlPoints.Branch(member_path);
var deformations = _memberdisplacements.Branch(path);
var deformedPoints = new List <Point3d>();
for (int i = 0; i < ctrlPoints.Count; i++)
{
deformedPoints.Add(new Point3d(ctrlPoints[i] + scale * deformations[i]));
}
// Add curve to tree
var memberShape = Curve.CreateControlPointCurve(deformedPoints);
oCurves.Add(memberShape, gh_path);
}
return(oCurves);
}
/// <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)
{
HeGraph3d graph = null;
double layerHeigth = 0;
if (!DA.GetData(0, ref graph))
{
return;
}
if (!DA.GetData(1, ref layerHeigth))
{
return;
}
var frames = new DataTree <Plane>();
var tparams = new DataTree <double>();
for (int i = 0; i < graph.Edges.Count; i++)
{
frames.AddRange(getEdgeFrames(graph, i, layerHeigth), new GH_Path(i));
}
for (int i = 0; i < graph.Edges.Count; i++)
{
var count = frames.Branch(i).Count;
var t0 = 1.0 / (double)count;
for (int j = 0; j < count; j++)
{
tparams.Add((j * t0), new GH_Path(i));
}
}
DA.SetDataTree(0, frames);
DA.SetDataTree(1, tparams);
}
/// <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)
{
//---- Declareing ---------------------------------------------------------------------------
GH_Structure<GH_Brep> AllStripes;
DA.GetDataTree("Triloop Stipes", out AllStripes);
GH_Structure<GH_Point> AllPoints;
DA.GetDataTree("Points", out AllPoints);
bool Reorient = false;
DA.GetData<bool>("Merge Stripes", ref Reorient);
bool Switch = false;
DA.GetData<bool>("Switch", ref Switch);
int Seam = 0;
DA.GetData<int>("Seam", ref Seam);
DataTree<Brep> AllUnrolledBreps = new DataTree<Brep>();
DataTree<Brep> ForReorientBreps = new DataTree<Brep>();
DataTree<Plane> AllOrientPlanes = new DataTree<Plane>();
DataTree<Curve> AllSharedCurves = new DataTree<Curve>();
DataTree<Point3d> AllUnrolledPoints = new DataTree<Point3d>();
//---- End Declareing -----------------------------------------------------------------------
//---- Functions ----------------------------------------------------------------------------
#region Unroll
for (int i = 0; i < AllStripes.Branches.Count; i++)
{
GH_Path pth = new GH_Path(i);
GH_Path originalPath = AllStripes.Paths[i];
int stripecounter = 0;
foreach (GH_Brep gbrep in AllStripes[i])
{
Unroller unroll = new Unroller(gbrep.Value);
// Add points to unroll with
if (AllPoints.Branches.Count != 0)
{
foreach (GH_Point pt in AllPoints[i])
{ unroll.AddFollowingGeometry(pt.Value); }
}
unroll.ExplodeOutput = false;
Curve[] curves;
Point3d[] unrolledPoints;
TextDot[] dots;
Brep[] unrolledBreps = unroll.PerformUnroll(out curves, out unrolledPoints, out dots);
if (Reorient == false)
{
foreach (Brep b in unrolledBreps)
{ AllUnrolledBreps.Add(b, originalPath); }
foreach (Point3d p in unrolledPoints)
{ AllUnrolledPoints.Add(p, originalPath); }
}
else
{
foreach (Brep b in unrolledBreps)
{ AllUnrolledBreps.Add(b, pth.AppendElement(stripecounter)); }
}
// For reorientation
if (Reorient == true)
{ ForReorientBreps.Add(unrolledBreps[Seam], pth); }
stripecounter++;
}
}
#endregion unroll
if (Reorient == true)
{
//ForReorientBreps.Branch(0)[0].Curves3D[0].PointAtEnd;
for (int i = 0; i < ForReorientBreps.BranchCount; i++)
{
GH_Path pth = new GH_Path(i);
foreach (Curve crv0 in ForReorientBreps.Branch(i)[0].Curves3D)
{
foreach (Curve crv1 in ForReorientBreps.Branch(i)[1].Curves3D)
{
double l0 = crv0.GetLength();
double l1 = crv1.GetLength();
if (Math.Abs(l0 - l1) < 0.00001)
{
// orient crv0
Plane origin0 = new Plane(new Point3d(0, 0, 0), new Vector3d(1, 0, 0), new Vector3d(0, 1, 0));
Plane target0 = new Plane(origin0);
AllOrientPlanes.Add(origin0, pth.AppendElement(0));
AllOrientPlanes.Add(target0, pth.AppendElement(0));
// orient crv1
Vector3d vect0 = crv1.TangentAtStart;
Vector3d vect1 = Vector3d.CrossProduct(vect0, new Vector3d(0.0, 0.0, 1.0));
Plane origin1 = new Plane(crv1.PointAtStart, vect0, vect1);
Vector3d vect2 = new Vector3d();
Vector3d vect3 = new Vector3d();
Plane target1 = new Plane();
if (Switch == true)
{
vect2 = crv0.TangentAtStart;
vect3 = Vector3d.CrossProduct(vect2, new Vector3d(0.0, 0.0, 1.0));
target1 = new Plane(crv0.PointAtStart, vect2, vect3);
}
else
{
vect2 = crv0.TangentAtStart;
vect3 = Vector3d.CrossProduct(-vect2, new Vector3d(0.0, 0.0, 1.0));
target1 = new Plane(crv0.PointAtEnd, -vect2, vect3);
}
AllOrientPlanes.Add(origin1, pth.AppendElement(1));
AllOrientPlanes.Add(target1, pth.AppendElement(1));
// shared curve of stripe0 and stripe 1
AllSharedCurves.Add(crv0, pth.AppendElement(0));
AllSharedCurves.Add(crv1, pth.AppendElement(0));
}
}
// orient crv2
foreach (Curve crv2 in ForReorientBreps.Branch(i)[2].Curves3D)
{
double l0 = crv0.GetLength();
double l1 = crv2.GetLength();
if (Math.Abs(l0 - l1) < 0.00001)
{
Vector3d vect0 = crv2.TangentAtStart;
Vector3d vect1 = Vector3d.CrossProduct(vect0, new Vector3d(0.0, 0.0, 1.0));
Plane origin2 = new Plane(crv2.PointAtStart, vect0, vect1);
Vector3d vect2 = new Vector3d();
Vector3d vect3 = new Vector3d();
Plane target2 = new Plane();
if (Switch == true)
{
vect2 = crv0.TangentAtStart;
vect3 = Vector3d.CrossProduct(vect2, new Vector3d(0.0, 0.0, 1.0));
target2 = new Plane(crv0.PointAtStart, vect2, vect3);
}
else
{
vect2 = crv0.TangentAtStart;
vect3 = Vector3d.CrossProduct(-vect2, new Vector3d(0.0, 0.0, 1.0));
target2 = new Plane(crv0.PointAtEnd, -vect2, vect3);
}
AllOrientPlanes.Add(origin2, pth.AppendElement(2));
AllOrientPlanes.Add(target2, pth.AppendElement(2));
// shared curve of stripe0 and stripe 2
AllSharedCurves.Add(crv2, pth.AppendElement(2));
AllSharedCurves.Add(crv0, pth.AppendElement(2));
}
}
}
// find the shared curve oft stripe 1 and stripe 2
foreach (Curve crv1 in ForReorientBreps.Branch(i)[1].Curves3D)
{
foreach (Curve crv2 in ForReorientBreps.Branch(i)[2].Curves3D)
{
double l1 = crv1.GetLength();
double l2 = crv2.GetLength();
// shared curve of stripe1 and stripe 2
if (Math.Abs(l1 - l2) < 0.00001)
{
AllSharedCurves.Add(crv1, pth.AppendElement(1));
AllSharedCurves.Add(crv2, pth.AppendElement(1));
}
}
}
}
}
//---- End Functions --------------------------------------------------------------------------
//----Set Output-------------------------------------------------------------------------------
DA.SetDataTree(0, AllUnrolledBreps);
DA.SetDataTree(1, AllOrientPlanes);
DA.SetDataTree(2, AllSharedCurves);
DA.SetDataTree(3, AllUnrolledPoints);
//----End Set 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)
{
//----Declareing--------------------------------------------------------------------------
// contains the 3 points of each face
DataTree<Point3f> facePoints = new DataTree<Point3f>();
// contains the coresponding topology points of each face
DataTree<int> faceTopologyPoints = new DataTree<int>();
// contains the face normals of each face
List<Vector3f> faceNormals = new List<Vector3f>();
// contains the 3 topology edges of each face
DataTree<int> faceTopoEdgesIdx = new DataTree<int>();
// contains the points of each topology edge
DataTree<int> topologyEdgesTopPtsIdx = new DataTree<int>();
// Contains the coordinates of each topology point
List<Point3d> topologyPoints = new List<Point3d>();
// Contains the index of neighbouring faces for each face
DataTree<int> faceNeighbours = new DataTree<int>();
// Contains Normals of topology vertices
List<Vector3d> topologyNormals = new List<Vector3d>();
// Contains the index of topology Edges for each Topology Point
DataTree<int> TopPt_Connected_TopEdges = new DataTree<int>();
//get Mesh from input
Mesh M = new Mesh();
DA.GetData<Mesh>("Mesh", ref M);
//----End Declareing-----------------------------------------------------------------------
//----Functions------------------------------------------------------------------------------
// get List with sublist of 3 points per face
for (int face_id = 0; face_id < M.Faces.Count; face_id++)
{
// set up the branch index
GH_Path pth = new GH_Path(face_id);
# region FacePoints
//---- Face Points (Point3f)
Point3f A, B, C, D;
M.Faces.GetFaceVertices(face_id, out A, out B, out C, out D);
facePoints.Add(A, pth);
facePoints.Add(B, pth);
facePoints.Add(C, pth);
#endregion FacePoints
#region FaceNormals
//---- Face Normals (Vector3f)
M.FaceNormals.ComputeFaceNormals();
faceNormals.Add(M.FaceNormals[face_id]);
#endregion FaceNormals
#region faceTopologyPoints
//---- Topology Points of the face (int)
int TA = M.Faces.GetTopologicalVertices(face_id)[0];
int TB = M.Faces.GetTopologicalVertices(face_id)[1];
int TC = M.Faces.GetTopologicalVertices(face_id)[2];
faceTopologyPoints.Add(TA, pth);
faceTopologyPoints.Add(TB, pth);
faceTopologyPoints.Add(TC, pth);
#endregion faceTopologyPoints
#region faceNeighbours
//---- Neighbours of face (int)
foreach (int i in M.TopologyEdges.GetEdgesForFace(face_id))
{
if (M.TopologyEdges.GetConnectedFaces(i).Length > 1)
{
foreach (int j in M.TopologyEdges.GetConnectedFaces(i))
{
if (j != face_id)
{ faceNeighbours.Add(j, pth); }
}
}
else
{ faceNeighbours.Add(-1, pth); }
}
#endregion faceNeighbours
#region Face Topology Edges
//---- Topology Edges (int)
foreach (int i in M.TopologyEdges.GetEdgesForFace(face_id))
{ faceTopoEdgesIdx.Add(i, pth); }
#endregion Face Topology Edges
}
for (int i = 0; i < M.TopologyVertices.Count; i++)
{
#region topologyPoints
//---- Topology Points (point3f)
int[] vertIdx = M.TopologyVertices.MeshVertexIndices(i);
topologyPoints.Add(M.Vertices[vertIdx[0]]);
#endregion topologyPoints
#region topologyNormals
//---- Topology Normals
M.FaceNormals.ComputeFaceNormals();
Vector3d normal = new Vector3d(0, 0, 0);
int count = 0;
foreach (int face in M.TopologyVertices.ConnectedFaces(i))
{
Vector3f temp = new Vector3f();
temp = M.FaceNormals[face];
Vector3d temp2 = new Vector3d(temp.X, temp.Y, temp.Z);
normal += temp2;
count++;
}
normal /= count;
topologyNormals.Add(normal);
#endregion topologyNormals
}
#region Topology Edges
for (int i = 0; i < M.TopologyEdges.Count; i++)
{
topologyEdgesTopPtsIdx.Add(M.TopologyEdges.GetTopologyVertices(i).I, new GH_Path(i));
topologyEdgesTopPtsIdx.Add(M.TopologyEdges.GetTopologyVertices(i).J, new GH_Path(i));
}
#endregion Topology Edges
#region Topology Vertex connected Topology Edge
for (int i = 0; i < topologyPoints.Count; i++)
{
// i = index of Topology Point
GH_Path pth = new GH_Path(i);
for (int j = 0; j < topologyEdgesTopPtsIdx.BranchCount; j++)
{
// j = index of Topology Edge
foreach (int k in topologyEdgesTopPtsIdx.Branch(j))
{
if (k == i)
// add multiple Topology Edges to the branch index, which is representing the topology point index
{ TopPt_Connected_TopEdges.Add(j, pth); }
}
}
}
#endregion Topology Vertex connected Topology Edge
//----End Functions--------------------------------------------------------------------------
//----Set Output-----------------------------------------------------------------------------
DA.SetDataTree(0, facePoints);
DA.SetDataTree(1, faceTopologyPoints);
DA.SetDataList(2, faceNormals);
DA.SetDataTree(3, faceNeighbours);
DA.SetDataList(4, topologyPoints);
DA.SetDataList(5, topologyNormals);
DA.SetDataTree(6, faceTopoEdgesIdx);
DA.SetDataTree(7, topologyEdgesTopPtsIdx);
DA.SetDataTree(8, TopPt_Connected_TopEdges);
//----End Set Output-------------------------------------------------------------------------
}
private Mesh local_tet(Plane pl, double xBase, double yBase, double zBase)
{
List<Point3d> list = new List<Point3d> {
pl.PointAt(-xBase, yBase, -zBase),
pl.PointAt(xBase, yBase, -zBase),
pl.PointAt(xBase, -yBase, -zBase),
pl.PointAt(-xBase, -yBase, -zBase),
pl.PointAt(-xBase, yBase, zBase),
pl.PointAt(xBase, yBase, zBase),
pl.PointAt(xBase, -yBase, zBase),
pl.PointAt(-xBase, -yBase, zBase)
};
List<double> list2 = new List<double>();
foreach (Point3d pointd in list)
{
double item = this.calculate_field(pointd);
list2.Add(item);
}
DataTree<Point3d> tree = new DataTree<Point3d>();
Point3d[] data = new Point3d[] { list[0], list[2], list[3], list[7] };
tree.AddRange(data, new GH_Path(0));
data = new Point3d[] { list[0], list[2], list[6], list[7] };
tree.AddRange(data, new GH_Path(1));
data = new Point3d[] { list[0], list[4], list[6], list[7] };
tree.AddRange(data, new GH_Path(2));
data = new Point3d[] { list[0], list[6], list[1], list[2] };
tree.AddRange(data, new GH_Path(3));
data = new Point3d[] { list[0], list[6], list[1], list[4] };
tree.AddRange(data, new GH_Path(4));
data = new Point3d[] { list[5], list[6], list[1], list[4] };
tree.AddRange(data, new GH_Path(5));
DataTree<double> tree2 = new DataTree<double>();
tree2.AddRange(new double[] { list2[0], list2[2], list2[3], list2[7] }, new GH_Path(0));
tree2.AddRange(new double[] { list2[0], list2[2], list2[6], list2[7] }, new GH_Path(1));
tree2.AddRange(new double[] { list2[0], list2[4], list2[6], list2[7] }, new GH_Path(2));
tree2.AddRange(new double[] { list2[0], list2[6], list2[1], list2[2] }, new GH_Path(3));
tree2.AddRange(new double[] { list2[0], list2[6], list2[1], list2[4] }, new GH_Path(4));
tree2.AddRange(new double[] { list2[5], list2[6], list2[1], list2[4] }, new GH_Path(5));
Mesh mesh = new Mesh();
foreach (GH_Path path in tree2.Paths)
{
List<Point3d> list3 = tree.Branch(path);
List<double> list4 = tree2.Branch(path);
int num2 = 0;
if (list4[0] < this.use_iso)
{
num2 |= 1;
}
if (list4[1] < this.use_iso)
{
num2 |= 2;
}
if (list4[2] < this.use_iso)
{
num2 |= 4;
}
if (list4[3] < this.use_iso)
{
num2 |= 8;
}
Mesh other = new Mesh();
switch (num2)
{
case 1:
case 14:
other.Vertices.Add(this.interp_vertex(list3[0], list3[1], list4[0], list4[1]));
other.Vertices.Add(this.interp_vertex(list3[0], list3[2], list4[0], list4[2]));
other.Vertices.Add(this.interp_vertex(list3[0], list3[3], list4[0], list4[3]));
other.Faces.AddFace(0, 1, 2);
break;
case 2:
case 13:
other.Vertices.Add(this.interp_vertex(list3[1], list3[0], list4[1], list4[0]));
other.Vertices.Add(this.interp_vertex(list3[1], list3[3], list4[1], list4[3]));
other.Vertices.Add(this.interp_vertex(list3[1], list3[2], list4[1], list4[2]));
other.Faces.AddFace(0, 1, 2);
break;
case 3:
case 12:
other.Vertices.Add(this.interp_vertex(list3[0], list3[3], list4[0], list4[3]));
other.Vertices.Add(this.interp_vertex(list3[0], list3[2], list4[0], list4[2]));
other.Vertices.Add(this.interp_vertex(list3[1], list3[3], list4[1], list4[3]));
other.Faces.AddFace(0, 1, 2);
other.Vertices.Add(this.interp_vertex(list3[1], list3[2], list4[1], list4[2]));
other.Faces.AddFace(2, 3, 1);
break;
case 4:
case 11:
other.Vertices.Add(this.interp_vertex(list3[2], list3[0], list4[2], list4[0]));
other.Vertices.Add(this.interp_vertex(list3[2], list3[1], list4[2], list4[1]));
other.Vertices.Add(this.interp_vertex(list3[2], list3[3], list4[2], list4[3]));
other.Faces.AddFace(0, 1, 2);
break;
case 5:
case 10:
other.Vertices.Add(this.interp_vertex(list3[0], list3[1], list4[0], list4[1]));
other.Vertices.Add(this.interp_vertex(list3[2], list3[3], list4[2], list4[3]));
other.Vertices.Add(this.interp_vertex(list3[0], list3[3], list4[0], list4[3]));
other.Faces.AddFace(0, 1, 2);
other.Vertices.Add(this.interp_vertex(list3[1], list3[2], list4[1], list4[2]));
other.Faces.AddFace(0, 3, 1);
break;
case 6:
case 9:
other.Vertices.Add(this.interp_vertex(list3[0], list3[1], list4[0], list4[1]));
other.Vertices.Add(this.interp_vertex(list3[1], list3[3], list4[1], list4[3]));
other.Vertices.Add(this.interp_vertex(list3[2], list3[3], list4[2], list4[3]));
other.Faces.AddFace(0, 1, 2);
other.Vertices.Add(this.interp_vertex(list3[0], list3[2], list4[0], list4[2]));
other.Faces.AddFace(0, 3, 2);
break;
case 7:
case 8:
other.Vertices.Add(this.interp_vertex(list3[3], list3[0], list4[3], list4[0]));
other.Vertices.Add(this.interp_vertex(list3[3], list3[2], list4[3], list4[2]));
other.Vertices.Add(this.interp_vertex(list3[3], list3[1], list4[3], list4[1]));
other.Faces.AddFace(0, 1, 2);
break;
}
mesh.Append(other);
}
mesh.Vertices.CombineIdentical(true, true);
return mesh;
}
private void RunScript(List<Mesh> x, List<int> y, List<double> z, ref object A, ref object B, ref object C,ref object D)
{
try
{
DataTree<double> output222;
if (temp.Count == 0)
{
temp = y;
for (int i = 0; i < x.Count; i++)
{
GH_Path path = new GH_Path(i);
List<Line> output11;
List<double> output22;
Point3d output33;
List<Point3d> output44;
Print(Step(x[i], y[i], 0.5, true, out output11, out output22, out output33, out output44));
output1.AddRange(output11, path);
output2.AddRange(output22, path);
output3.Add(output33, path);
output4.AddRange(output44, path);
}
}
else
{
for (int i = 0; i < y.Count; i++)
{
GH_Path path = new GH_Path(i);
if (y[i] != temp[i])
{
List<Line> output11;
List<double> output22;
Point3d output33;
List<Point3d> output44;
Print(Step(x[i], y[i], 0.5, true, out output11, out output22, out output33, out output44));
output1.Branch(path).Clear();
output1.Branch(path).AddRange(output11);
output2.Branch(path).Clear();
output2.Branch(path).AddRange(output22);
output3.Branch(path)[0] = output33;
output4.Branch(path).Clear();
output4.Branch(path).AddRange(output44);
temp[i] = y[i];
}
}
}
output222 = new DataTree<double>(output2);
for (int i = 0; i < output222.Paths.Count; i++)
{
GH_Path path = new GH_Path(i);
for(int j=0;j<output222.Branch(path).Count;j++){
output222[path, j] *= z[i];
}}
A = output1; B = output222; C = output3; D = output4;
}
catch (Exception ex)
{
Print(ex.ToString());
}
}
