protected override void SolveInstance(IGH_DataAccess da)
{
if (!GetInputs(da)) return;
prop = new DataTree<double>();
int index = 0;
foreach (Amoeba amo in p.population)
{
prop.Add(amo.tempValue,new GH_Path(index));
prop.Add(PhysaSetting.gmin, new GH_Path(index));
prop.Add(PhysaSetting.gmax, new GH_Path(index));
index++;
}
SetOutputs(da);
}
/// <summary>
/// Gets structured content
/// </summary>
public DataTree <string> Get()
{
DataTree <string> result = new DataTree <string>($"Documentation for {Name}: {Description}");
if (Examples.Count == 1)
{
result.Add($"Example: {Examples[0]}");
}
if (Examples.Count > 1)
{
DataTree <string> example = new DataTree <string>("Examples:");
Examples.ForEach(x => example.Add(x));
result.Add(example);
}
if (!Default.IsNullOrWhiteSpace())
{
result.Add($"Default: {Default}");
}
if (!PossibleValues.IsNullOrWhiteSpace())
{
result.Add($"PossibleValues: {PossibleValues}");
}
if (!Remark.IsNullOrWhiteSpace())
{
result.Add($"Remarks: {Remark}");
}
return(result);
}
void createNetFromPoints(DataTree <Point3d> PointGrid)
{
// Receives a tree of points and gives back it's corresponding net of lines properly divided into WARP AND WEFT directions
DataTree <Line> warpLines = new DataTree <Line>();
DataTree <Line> weftLines = new DataTree <Line>();
//WARP
for (int bNum = 0; bNum < PointGrid.BranchCount; bNum++)
{ // Iterate all branches
List <Point3d> branch = PointGrid.Branches[bNum];
GH_Path pth = PointGrid.Paths[bNum];
for (int ptNum = 0; ptNum < branch.Count - 1; ptNum++)
{ // Iterate all points in each branch
Line warpLn = new Line(branch[ptNum], branch[ptNum + 1]);
warpLines.Add(warpLn, new GH_Path(pth));
if (bNum < PointGrid.BranchCount - 1)
{
List <Point3d> nextBranch = PointGrid.Branches[bNum + 1];
if (ptNum < nextBranch.Count)
{
Line weftLn = new Line(branch[ptNum], nextBranch[ptNum]);
weftLines.Add(weftLn, pth);
}
}
}
}
_warpNet.MergeTree(warpLines);
_weftNet.MergeTree(weftLines);
}
public DataTree <string> ToDataTree(List <string>[] Data)
{
DataTree <string> dTree = new DataTree <string>();
// define numbers of branches of data tree
int rows = Data[0].Count;
// define numbers of items in each branch
int cols = Data.GetLength(0);
for (int irow = 0; irow < rows; irow++)
{
for (int icol = 0; icol < cols; icol++)
{
if (Data[icol] == null)
{
continue;
}
//dTree.Add(Data[icol][irow], new GH_Path(irow));
try
{
dTree.Add(Data[icol][irow].ToString(), new GH_Path(irow));
}
catch
{
continue;
}
}
}
return(dTree);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
// get input
StruSoft.Interop.StruXml.Data.Complex_composite_type ComplexComposite = null;
if (!DA.GetData(0, ref ComplexComposite))
{
return;
}
if (ComplexComposite == null)
{
return;
}
// return
DataTree <FemDesign.Materials.Material> material = new DataTree <FemDesign.Materials.Material>();
DataTree <FemDesign.Sections.Section> section = new DataTree <FemDesign.Sections.Section>();
for (int i = 0; i < ComplexComposite.Composite_section.Count; i++)
{
var item = ComplexComposite.Composite_section[i];
foreach (var obj in item.CompositeSectionDataObj.Part)
{
material.Add(obj.MaterialObj, new GH_Path(i));
section.Add(obj.SectionObj, new GH_Path(i));
}
}
DA.SetDataTree(0, material);
DA.SetDataTree(1, section);
}
//private DataTree<Point3d> CreateControlPoints(ref List<string> msg)
//{
// var oControlPoints = new DataTree<Point3d>();
// foreach (var member in _saveddata.GetMembers())
// {
// var gh_path = new GH_Path(member.No);
// var fe1delements = _rfemMesh.GetMemberNodes(member.No, ItemAt.AtNo); // We can't sort this list
// foreach (var node in fe1delements)
// {
// oControlPoints.Add(new Point3d(node.X, node.Y, node.Z), gh_path);
// }
// }
// return oControlPoints;
//}
private DataTree <Vector3d> GetMemberDisplacements(ref List <string> msg)
{
// Get control points
_controlPoints.Clear();
var rfmembers = Component_GetData.GetRFMembers(_saveddata.GetMembers().ToList(), _saveddata);
// Save defoirmation vectors into a tree;
var oDisplacements = new DataTree <Vector3d>();
foreach (var member in rfmembers)
{
// Add also control points. We are just going to get one set of control points for each curve regardless thne result type
var pts_path = new GH_Path(member.No);
_controlPoints.RemovePath(pts_path);
var baseline = member.BaseLine.ToCurve();
// Get deformations
var memberResults = _lcresults.GetMemberDeformations(member.No, ItemAt.AtNo, MemberAxesType.GlobalAxes); // We can't sort this list
var valueType = memberResults[0].Type; // Get deformation types to avoid duplicate control points
foreach (var result in memberResults)
{
var gh_path = new GH_Path(member.No, (int)result.Type);
var displacement = new Vector3d(result.Displacements.ToPoint3d());
oDisplacements.Add(displacement, gh_path);
// Get control points
if (result.Type == valueType)
{
_controlPoints.Add(baseline.PointAtNormalizedLength(Math.Min(result.Location / baseline.GetLength(), 1.0)), pts_path);
}
}
}
return(oDisplacements);
}
private DataTree <Vector3d> GetMeshDisplacements(ref List <int> sfcNo, ref List <string> msg)
{
var oDisplacements = new DataTree <Vector3d>();
sfcNo = new List <int>();
// Save defoirmation vectors into a tree
var surfaceResults = _lcresults.GetSurfacesDeformations(false).OrderBy(o => o.LocationNo); // Sort according to nodes so there are no errors when applying displacements
foreach (var resulttype in surfaceResults.Select(x => x.Type).Distinct())
{
_resultTypes.Add(resulttype);
}
foreach (var result in surfaceResults) // GET RESULT TYPES!!!
{
var gh_path = new GH_Path(result.SurfaceNo, (int)result.Type);
var displacement = new Vector3d(result.Displacements.ToPoint3d());
oDisplacements.Add(displacement, gh_path);
// Add surface numbers to output list
if (sfcNo.Count == 0 || result.SurfaceNo != sfcNo[sfcNo.Count - 1])
{
sfcNo.Add(result.SurfaceNo);
}
}
return(oDisplacements);
}
/// <summary>
/// This procedure contains the user code. Input parameters are provided as regular arguments,
/// Output parameters as ref arguments. You don't have to assign output parameters,
/// they will have a default value.
/// </summary>
private void RunScript(DataTree <Point3d> P, ref object A, ref object B, ref object C, ref object D, ref object E)
{
// simplify
P.SimplifyPaths();
// making a copy since DataTree is reference type
A = new DataTree <Point3d>(P);
// graft
P.Graft(false);
B = new DataTree <Point3d>(P);
// flatten (extract alla data to a list)
List <Point3d> pts = P.AllData(); // data tree to List
C = pts;
// extract paths list (like Param Viewer)
IList <GH_Path> paths = P.Paths;
D = paths;
// rebuild a tree from the list
DataTree <Point3d> pTree = new DataTree <Point3d>();
GH_Path p;
for (int i = 0; i < paths.Count; i++)
{
p = new GH_Path(paths[i][0]);
pTree.Add(pts[i], p);
}
E = pTree;
}
/// <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> objects = new GH_Structure <IGH_Goo>();
if (!DA.GetDataTree(0, out objects))
{
return;
}
/////////////////////////////////////////////////////////////////////////////
DataTree <object> newobj = new DataTree <object>();
int num = objects.PathCount;
List <int> index = new List <int>();//////每个分支的长度
for (int i = 0; i < num; i++)
{
index.Add(objects.Branches[i].Count);
}
index.Sort(); /////排序长度，找出最大值
int maxnum = index[index.Count - 1]; /////找出数据最长分支的长度
for (int i = 0; i < maxnum; i++)
{
for (int j = 0; j < num; j++)
{
List <object> obb = new List <object>(objects.Branches[j]);
int num2 = obb.Count;
if (num2 >= i + 1)/////////////////////如果分支的数据长度大于序号，则进入
{
newobj.Add(obb[i], new GH_Path(0, i));
}
}
}
DA.SetDataTree(0, newobj);
}
// ===============================================================================================
// Get Vertices from breps
// ===============================================================================================
public static DataTree <Point3d> BrepVertices(List <Brep> breps)
{
DataTree <Point3d> faceVertices = new DataTree <Point3d>();
int i = 0;
foreach (Brep brep in breps)
{
int j = 0;
foreach (var face in brep.Faces)
{
Brep faceBrep = face.DuplicateFace(true);
var pts = faceBrep.DuplicateVertices();
for (int k = 0; k < pts.Length; k++)
{
GH_Path path = new GH_Path(i, j);
faceVertices.Add(pts[k], path);
}
j++;
}
i++;
}
return(faceVertices);
}
/// <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)
{
// First, we need to retrieve all data from the input parameters.
// We'll start by declaring variables and assigning them starting values.
object obj = new object();
GH_Path path = new GH_Path();
// Then we need to access the input parameters individually.
// When data cannot be extracted from a parameter, we should abort this method.
if (!DA.GetData(0, ref obj))
{
return;
}
if (!DA.GetData(1, ref path))
{
return;
}
DataTree <object> dt = new DataTree <object>();
dt.Add(obj, path);
// Finally assign to the output parameter.
DA.SetData(0, dt);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
List <sPointLoad> sups = new List <sPointLoad>();
if (!DA.GetDataList(0, sups))
{
return;
}
DataTree <sPointLoad> supTree = new DataTree <sPointLoad>();
var ngrouped = sups.GroupBy(n => n.loadPatternName);
int ngroupID = 0;
foreach (var nngroup in ngrouped)
{
GH_Path npth = new GH_Path(ngroupID);
foreach (sPointLoad sn in nngroup)
{
supTree.Add(sn, npth);
}
ngroupID++;
}
DA.SetDataTree(0, supTree);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
List <IFrameSet> beams = new List <IFrameSet>();
if (!DA.GetDataList(0, beams))
{
return;
}
DataTree <IFrameSet> beamTree = new DataTree <IFrameSet>();
var grouped = beams.GroupBy(b => b.crossSection.shapeName);
int groupID = 0;
foreach (var bgroup in grouped)
{
GH_Path bpth = new GH_Path(groupID);
foreach (IFrameSet sb in bgroup)
{
beamTree.Add(sb, bpth);
}
groupID++;
}
DA.SetDataTree(0, beamTree);
}
private static DataTree <object> UpdateInfo(List <string> patchKeys, List <Thresholds.WindThreshold> thresholds,
int criteria)
{
var info = "Patch Names:\n";
var output = new DataTree <object>();
if (criteria == 1)
{
var i = 0;
foreach (var key in patchKeys)
{
info += $"{{{i}}} is {key}\n";
i++;
}
info += "\nComfort Categories\n";
var j = 0;
foreach (var threshold in thresholds)
{
info += $"{threshold.Field} is {j}\n";
output.Add(threshold.Field, new GH_Path(1));
j++;
}
}
else
{
var i = 0;
foreach (var key in patchKeys)
{
info += $"{{{i};*}} is {key}\n";
i++;
}
info += "\nThreshold Categories\n";
var j = 0;
foreach (var threshold in thresholds)
{
info += $"{{*;{j}}} is {threshold.Field}\n";
output.Add(threshold.Field, new GH_Path(1));
j++;
}
}
output.Add(info, new GH_Path(0));
return(output);
}
public DataTree <Line> GetDowels(double radius = 0.075, int count = 8)
{
DataTree <Line> dt = new DataTree <Line>();
for (int i = 0; i < this._nexors.Count; i++)
{
if (this._nexors[i].isNexor != 0)
{
var path = new GH_Path(i);
Point3d c = (this._nexors[i].endPl0.Origin + this._nexors[i].endPl1.Origin) * 0.5;
int dir = (c.DistanceToSquared(this._nexors[i].endPl0.Origin + this._nexors[i].endPl0.ZAxis) < c.DistanceToSquared(this._nexors[i].endPl0.Origin - this._nexors[i].endPl0.ZAxis)) ? -1 : 1;
Plane plane = this._nexors[i].endPl0.ChangeOrigin(PlaneUtil.LinePlane(this._nexors[i].pipe.line, this._nexors[i].endPl0));
Circle circle = new Circle(plane, radius);
Curve curve = circle.ToNurbsCurve();
curve.DivideByCount(count, true, out Point3d[] pts);
foreach (Point3d p in pts)
{
Line line = new Line(p, this._nexors[i].endPl0.ZAxis * dir * 0.15);
dt.Add(line, path);
//line.Bake();
}
plane = this._nexors[i].endPl1.ChangeOrigin(PlaneUtil.LinePlane(this._nexors[i].pipe.line, this._nexors[i].endPl1));
circle = new Circle(plane, radius);
curve = circle.ToNurbsCurve();
curve.DivideByCount(count, true, out Point3d[] pts1);
dir = (c.DistanceToSquared(this._nexors[i].endPl1.Origin + this._nexors[i].endPl1.ZAxis) < c.DistanceToSquared(this._nexors[i].endPl1.Origin - this._nexors[i].endPl1.ZAxis)) ? -1 : 1;
foreach (Point3d p in pts1)
{
Line line = new Line(p, this._nexors[i].endPl1.ZAxis * dir * 0.15);
dt.Add(line, path);
//line.Bake();
}
//Rhino.RhinoDoc.ActiveDoc.Objects.AddCircle(circle);
}
}
return(dt);
}
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 void test_core(ref List <Rectangle3d> core_list, ref List <Point3d> g_pts, ref DataTree <bool> g_val)
{
List <Rectangle3d> c = new List <Rectangle3d>();
double core_area_min = core_area * (1.0 - deviation);
double core_area_max = core_area * (1.0 + deviation);
for (int i = 1; i <= skin_width; i++)
{
for (int j = 1; j <= skin_height; j++)
{
g_pts.Add(new Point3d(i - 0.5, j - 0.5, 0));
if ((i * j == core_area || (i * j >= core_area_min && i * j <= core_area_max)) && i >= core_min_width && j >= core_min_height)
{
double possible_x_pos = skin.Width - i;
double possible_y_pos = skin.Height - j;
for (int k = 0; k <= possible_x_pos; k++)
{
for (int l = 0; l <= possible_y_pos; l++)
{
c.Add(new Rectangle3d(Plane.WorldXY, new Point3d(k, l, 0), new Point3d(k + i, l + j, 0)));
g_val.EnsurePath(c.Count() - 1);
for (int m = 0; m < skin_width; m++)
{
for (int n = 0; n < skin_height; n++)
{
if ((m + 0.5 > k && m + 0.5 < k + i) && (n + 0.5 > l && n + 0.5 < l + j))
{
g_val.Add(false);
}
else
{
g_val.Add(true);
}
}
}
}
}
}
}
}
core_list = c;
}
public static Dictionary <string, DataTree <object> > CreateAnalysisMesh(
List <Surface> baseSurfaces,
double gridSize,
List <Brep> excludeGeometry,
double offset,
string offsetDirection)
{
var analysisMesh = new DataTree <object>();
var faceCenters = new DataTree <object>();
var faceNormals = new DataTree <object>();
var index = 0;
var doneEvents = new ManualResetEvent[baseSurfaces.Count];
var callBacks = new List <ThreadedCreateAnalysisMesh>();
foreach (var surface in baseSurfaces)
{
doneEvents[index] = new ManualResetEvent(false);
var callBack = new ThreadedCreateAnalysisMesh
{
gridSize = gridSize,
excludeGeometry = excludeGeometry,
offset = offset,
offsetDirection = offsetDirection,
doneEvent = doneEvents[index]
};
ThreadPool.QueueUserWorkItem(callBack.ThreadPoolCallback);
callBacks.Add(callBack);
index++;
}
WaitHandle.WaitAll(doneEvents);
index = 0;
foreach (var callBack in callBacks)
{
var mesh = callBack.analysisMesh;
var path = new GH_Path(index);
analysisMesh.Add(mesh, path);
foreach (var normal in mesh.FaceNormals)
{
faceNormals.Add(normal, path);
}
for (var i = 0; i < mesh.Faces.Count(); i++)
{
faceCenters.Add(mesh.Faces.GetFaceCenter(i), path);
}
index++;
}
return(new Dictionary <string, DataTree <object> >
{
{ "analysisMesh", analysisMesh },
{ "faceCenters", faceCenters },
{ "faceNormals", faceNormals },
});
}
/// <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 <Brep> breps = new List <Brep>();
double tolerance = 0;
if (!DA.GetDataList(0, breps))
{
return;
}
if (!DA.GetData(1, ref tolerance))
{
return;
}
DataTree <int> index = new DataTree <int>();
List <Brep> bps = new List <Brep>();
List <int> test = new List <int>();
int num = 0;
for (int i = 0; i < breps.Count; i++)
{
if (test.Contains(i))
{
continue;
}
Brep bb = breps[i];
bps.Add(bb);
test.Add(i);
index.Add(i, new GH_Path(0, DA.Iteration, num));
for (int j = 0; j < breps.Count; j++)
{
if (test.Contains(j))
{
continue;
}
if (bb.IsDuplicate(breps[j], tolerance))
{
test.Add(j);
index.Add(j, new GH_Path(0, DA.Iteration, num));
}
}
num++;
}
DA.SetDataList(0, bps);
DA.SetDataTree(1, index);
}
/// <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 <string> _buildingFiles = new List <string>();
List <string> _buildingBinaryFiles = new List <string>();
int _val_ = 0;
bool runIt_ = false;
DA.GetDataList(0, _buildingFiles);
DA.GetDataList(1, _buildingBinaryFiles);
DA.GetData(2, ref _val_);
DA.GetData(3, ref runIt_);
// Unwrap variables
List <FacadeVariable> variables = BuildingFacadeOutputMapping();
if (runIt_)
{
DataTree <string> fileNameTree = new DataTree <string>();
DataTree <FacadeVariable> variableTree = new DataTree <FacadeVariable>();
DataTree <double> dataTree = new DataTree <double>();
// Warning!
if (_val_ >= variables.Count)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Variable is out of range, check description of the input.");
return;
}
for (int i = 0; i < _buildingFiles.Count; i++)
{
GHD.GH_Path pth = new GHD.GH_Path(i);
try
{
string edxName = Path.GetFileNameWithoutExtension(_buildingFiles[i]);
string edtName = Path.GetFileNameWithoutExtension(_buildingBinaryFiles[i]);
if (edxName == edtName)
{
List <double> results = BuildingOutput.ParseBinBuilding(_buildingFiles[i], _buildingBinaryFiles[i], (int)variables[_val_], Direction);
fileNameTree.Add(Path.GetFileName(_buildingFiles[i]), pth);
variableTree.Add(variables[_val_], pth);
dataTree.AddRange(results, pth);
}
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Something is wrong in output dynamic folder.\nPlease, make sure EDT length is equals to EDX length.");
continue;
}
}
DA.SetDataTree(0, fileNameTree);
DA.SetDataTree(1, variableTree);
DA.SetDataTree(2, dataTree);
}
}
/// <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 <Point3d> x = new List <Point3d>();
double t = 0;
if (!DA.GetDataList(0, x))
{
return;
}
if (!DA.GetData(1, ref t))
{
return;
}
//////////////////////////////////////////////////////////
DataTree <int> index = new DataTree <int>();
int mem = 0;
int branch = DA.Iteration;
List <Point3d> last = new List <Point3d>();
for (int i = 0; i < x.Count; i++)
{
if (x[i] == Point3d.Unset)
{
continue;
}
last.Add(x[i]);
index.Add(i, new GH_Path(0, branch, mem));
for (int q = 0; q < x.Count; q++)
{
if (x[q] == Point3d.Unset || i == q)
{
continue;
}
if (x[i].DistanceTo(x[q]) <= t + 0.000000001)
{
x[q] = Point3d.Unset;
index.Add(q, new GH_Path(0, branch, mem));
}
}
mem++;
}
DA.SetDataList(0, last);
DA.SetDataTree(1, index);
}
public void MatchToProgram()
{
for (int i = 0; i < nodes.Count; i++)
{
for (int j = 0; j < smIntervals.Length; j++)
{
if (nodes[i].intervalIndex == j)
{
smIntervals[j].cumulArea += nodes[i].area;
}
}
}
var sortedIntervals = smIntervals.OrderBy(i => i.cumulArea).ToList();
var sortedProgram = programPairs.OrderBy(p => p.area).ToList();
for (int i = 0; i < nodes.Count; i++)
{
for (int j = 0; j < sortedIntervals.Count; j++)
{
if (nodes[i].intervalIndex == j)
{
nodes[i].name = sortedProgram[j].name;
}
}
}
var sortedNodes = nodes.OrderBy(n => n.multiplierStrength).ToList();
for (int i = 0; i < sortedIntervals.Count; i++)
{
int count = 0;
for (int j = 0; j < sortedNodes.Count; j++)
{
if (i == sortedNodes[j].intervalIndex)
{ //if(i == 0)
// sortedNodes[j].bmu = true;
sortedNodes[j].name += "_" + count;
count++;
}
}
}
for (int i = 0; i < nodes.Count; i++)
{
for (int j = 0; j < sortedIntervals.Count; j++)
{
if (nodes[i].intervalIndex == j)
{
programTree.Add(nodes[i], new GH_Path(j));
}
}
}
}
protected override void SolveInstance(IGH_DataAccess da)
{
if (!GetInputs(da))
{
return;
}
prop = new DataTree <double>();
int index = 0;
foreach (Amoeba amo in p.population)
{
prop.Add(amo.tempValue, new GH_Path(index));
prop.Add(PhysaSetting.gmin, new GH_Path(index));
prop.Add(PhysaSetting.gmax, new GH_Path(index));
index++;
}
SetOutputs(da);
}
public DataTree <int> GetID()
{
DataTree <int> dt = new DataTree <int>();
for (int i = 0; i < _pipes.Count; i++)
{
dt.Add(_pipes[i].ID, new Grasshopper.Kernel.Data.GH_Path(i));
}
return(dt);
}
//Properties
public DataTree <Line> GetLines()
{
DataTree <Line> dt = new DataTree <Line>();
for (int i = 0; i < _pipes.Count; i++)
{
dt.Add(_pipes[i].line, new Grasshopper.Kernel.Data.GH_Path(i));
}
return(dt);
}
public DataTree <Mesh> GetMeshes()
{
DataTree <Mesh> dt = new DataTree <Mesh>();
for (int i = 0; i < _pipes.Count; i++)
{
dt.Add(_pipes[i].meshloft, new Grasshopper.Kernel.Data.GH_Path(i));
}
return(dt);
}
public DataTree <Brep> GetBreps()
{
DataTree <Brep> dt = new DataTree <Brep>();
for (int i = 0; i < _pipes.Count; i++)
{
dt.Add(_pipes[i].breploft, new Grasshopper.Kernel.Data.GH_Path(i));
}
return(dt);
}
static DataTree <T> ListToTree <T>(List <T> List)
{
DataTree <T> tree = new DataTree <T>();
for (int i = 0; i < List.Count; i++)
{
tree.Add(List[i], new GH_Path(i));
}
return(tree);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
//Input variables
List <Line> lines = new List <Line>();
List <Point3d> points = new List <Point3d>();
//Link input
DA.GetDataList(0, lines);
DA.GetDataList(1, points);
//output variables
DataTree <int> IDS = new DataTree <int>();
DataTree <Line> tree = new DataTree <Line>();
//tolerance needed to cover rounding errors
double tol = 1e-6;
//loop over data
for (int i = 0; i < points.Count; i++)
{
Point3d ptree = points[i];
GH_Path path = new GH_Path(i);
foreach (Line linetree in lines)
{
//if startpoint is equal to current point
if (Math.Abs(ptree.X - linetree.From.X) < tol && Math.Abs(ptree.Y - linetree.From.Y) < tol && Math.Abs(ptree.Z - linetree.From.Z) < tol)
{
tree.Add(linetree, path);
IDS.Add(lines.IndexOf(linetree), path);
}
//if endpoint is equal to current point
if (Math.Abs(ptree.X - linetree.To.X) < tol && Math.Abs(ptree.Y - linetree.To.Y) < tol && Math.Abs(ptree.Z - linetree.To.Z) < tol)
{
tree.Add(linetree, path);
IDS.Add(lines.IndexOf(linetree), path);
}
}
}
//link output
DA.SetDataTree(0, tree);
DA.SetDataTree(1, IDS);
}
private static DataTree <object> UpdateInfo(
Dictionary <string, Dictionary <string, Dictionary <string, object> > > data)
{
var fieldKey = data.Keys.ToList().First();
var info = "Patch Names:\n";
var i = 0;
var patches = data[fieldKey].Keys.ToList();
foreach (var key in patches)
{
info += $"{{{i};*}} is {key}\n";
i++;
}
var j = 0;
var angles = new List <string>();
var patchKey = patches.First();
info += "\nAngles:\n";
foreach (var key in data[fieldKey][patchKey].Keys)
{
info += $"{{*;{j}}} is {key} degrees\n";
angles.Add(key);
j++;
}
var output = new DataTree <object>();
output.Add(info, new GH_Path(0));
foreach (var patch in patches)
{
output.Add(patch, new GH_Path(1));
}
foreach (var angle in angles)
{
output.Add(angle, new GH_Path(2));
}
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)
{
///////////////////////////////////////////////////////////////////////////////////////////////////声明变量
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 static DataTree<Brep> BrepArray2DToDatatree(Brep[][] array)
{
DataTree<Brep> tree = new DataTree<Brep>();
GH_Path trunk = new GH_Path();
for (int i = 0; i < array.Length; i++)
{
GH_Path branch = trunk.AppendElement(i);
for (int j = 0; j < array[i].Length; j++)
{
tree.Add(array[i][j], branch);
}
}
return tree;
}
/// <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----------------------------------------------------------------------------//
List<IGoal> permanentGoals = new List<IGoal>();
DA.GetDataList(0, permanentGoals);
List<IGoal> loadGoals = new List<IGoal>();
DA.GetDataList(1, loadGoals);
double fStart = 1.0;
DA.GetData(2, ref fStart);
double fStep = 0.1;
DA.GetData(3, ref fStep);
double angle = 15.0;
DA.GetData(4, ref angle);
angle *= Math.PI / 180.0;
double displ = 2.0;
DA.GetData(5, ref displ);
double threshold = 1e-15;
DA.GetData(6, ref threshold);
int equilibriumIter = 100;
DA.GetData(7, ref equilibriumIter);
bool opt = false;
DA.GetData(8, ref opt);
int maxIterations = 1000;
//--------------------------------------------------------------CALCULATE----------------------------------------------------------------------------//
//-------------------VALUES TO STORE----------------------------//
//Position lists
List<Point3d> initialPositions = new List<Point3d>();
List<Point3d> previousPositions = new List<Point3d>();
List<Point3d> currentPositions = new List<Point3d>();
DataTree<Point3d> vertexPositions = new DataTree<Point3d>();
//Goal output lists
List<object> previousGOutput = new List<object>();
List<object> currentGOutput = new List<object>();
DataTree<object> outputGoals = new DataTree<object>();
//Load factors and displacements
List<double> loadfactors = new List<double>();
List<double> displacementsRMS = new List<double>();
//-------------------K2 PHYSICAL SYSTEM----------------------------//
//Initialise Kangaroo solver
var PS = new KangarooSolver.PhysicalSystem();
var GoalList = new List<IGoal>();
//Assign indexes to the particles in each Goal
foreach (IGoal pG in permanentGoals)
{
PS.AssignPIndex(pG, 0.01);
GoalList.Add(pG);
}
foreach (IGoal lG in loadGoals)
{
PS.AssignPIndex(lG, 0.01);
GoalList.Add(lG);
}
//Store initial loads
List<Vector3d> initialLoads = new List<Vector3d>();
for (int i = 0; i < loadGoals.Count; i++)
{
initialLoads.Add(loadGoals[i].Move[0]);
}
//-------------------INITIALISE VALUE LISTS----------------------------//
//Initial vertex positions
Point3d[] initPos = PS.GetPositionArray();
foreach (Point3d pt in initPos)
{
initialPositions.Add(pt);
previousPositions.Add(pt);
currentPositions.Add(pt);
}
//Initial goal output
List<object> initGOutput = PS.GetOutput(GoalList);
for (int i = 0; i < permanentGoals.Count; i++)
{
previousGOutput.Add(initGOutput[i]);
currentGOutput.Add(initGOutput[i]);
}
//-------------------LOAD INCREMENT LOOP----------------------------//
bool run = true;
int iter = 0;
double LF;
double BLF = 0.0;
double preRMS = 0.0;
while (run && iter < maxIterations)
{
LF = fStart + (fStep * iter);
loadfactors.Add(LF);
//Scale load goals in each iteration
for (int i = 0; i < loadGoals.Count; i++)
{
int index = GoalList.Count - loadGoals.Count + i;
Vector3d scaledLoad = initialLoads[i] * LF;
GoalList[index] = new KangarooSolver.Goals.Unary(GoalList[index].PIndex[0], scaledLoad);
}
//Solve equilibrium for given load increment
int counter = 0;
do
{
PS.Step(GoalList, true, threshold);
counter++;
} while (PS.GetvSum() > threshold && counter < equilibriumIter);
//Update value lists
GH_Path path = new GH_Path(iter);
//Get new equilibrium positions and update position lists
Point3d[] newPositions = PS.GetPositionArray();
for (int k = 0; k < initialPositions.Count; k++)
{
previousPositions[k] = currentPositions[k];
currentPositions[k] = newPositions[k];
if (opt)
{
vertexPositions.Add(newPositions[k], path);
}
}
//Get new goal output and update goal output lists
List<object> newGOutput = PS.GetOutput(GoalList);
for (int m = 0; m < permanentGoals.Count; m++)
{
previousGOutput[m] = currentGOutput[m];
currentGOutput[m] = newGOutput[m];
if (opt)
{
outputGoals.Add(newGOutput[m], path);
}
}
//Does buckling occur?
List<Vector3d> nodalDisplacements = calcDisplacement(currentPositions, initialPositions);
double curRMS = calcDisplacementsRMS(nodalDisplacements);
displacementsRMS.Add(curRMS);
bool buckled = isBuckled(curRMS, preRMS, iter, fStart, fStep, angle);
bool deflected = isDeflectionTooBig(nodalDisplacements, displ);
if (buckled || deflected)
{
run = false;
BLF = LF - fStep;
}
//Update
preRMS = curRMS;
iter++;
}
//-----------------------FLAG BUCKLED STATE----------------------------//
if (BLF >= 1.0)
{
this.Message = "Works!";
}
else
{
this.Message = "Buckles!";
}
//-----------------------WARNING----------------------------//
//If the maximum number of iterations has been reached
if (iter == maxIterations)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Buckling did not occur within " + maxIterations + " load increments. Adjust load-step");
}
//-----------------------UPDATE VALUE LISTS----------------------------//
//If opt is false then add results from last two iterations
if (!opt)
{
for (int i = 0; i < currentPositions.Count; i++)
{
vertexPositions.Add(previousPositions[i], new GH_Path(0));
vertexPositions.Add(currentPositions[i], new GH_Path(1));
}
for (int j = 0; j < currentGOutput.Count; j++)
{
outputGoals.Add(previousGOutput[j], new GH_Path(0));
outputGoals.Add(currentGOutput[j], new GH_Path(1));
}
}
//---------------------------------------------------------------OUTPUT-------------------------------------------------------------------------------//
DA.SetData(0, BLF);
DA.SetDataList(1, loadfactors);
DA.SetDataList(2, displacementsRMS);
DA.SetDataTree(3, vertexPositions);
DA.SetDataTree(4, outputGoals);
}
/// <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 DataTree<AgentType> run(Boolean reset, bool liveUpdate, List<T.AgentSystem> systems)
{
int index = 0;
pts.Clear();
if (reset)
{
agentSystems.Clear();
foreach (T.AgentSystem system in systems)
{
agentSystems.Add(new T.AgentSystem(system));
foreach (EmitterType emitter in system.Emitters)
{
if (!emitter.ContinuousFlow)
{
for (int i = 0; i < emitter.NumAgents; i++)
{
agentSystems[index].addAgent(emitter);
}
}
}
index++;
}
}
else
{
if (liveUpdate)
{
if (systems.Count > agentSystems.Count)
{
//Find the system that is not in agentSystems and add it.
foreach (T.AgentSystem system in systems)
{
if (!agentSystems.Contains(system))
{
agentSystems.Add(new T.AgentSystem(system));
}
}
}
else if (systems.Count < agentSystems.Count)
{
foreach (T.AgentSystem agentSystem in agentSystems)
{
if (!systems.Contains(agentSystem))
{
agentSystems.Remove(agentSystem);
}
}
}
foreach (T.AgentSystem system in systems)
{
agentSystems[index].Emitters = systems[index].Emitters;
agentSystems[index].AgentsSettings = systems[index].AgentsSettings;
agentSystems[index].Forces = systems[index].Forces;
agentSystems[index].Environment = systems[index].Environment;
agentSystems[index].Behaviors = systems[index].Behaviors;
index++;
}
}
foreach (T.AgentSystem system in agentSystems)
{
system.run();
}
}
DataTree<AgentType> tree = new DataTree<AgentType>();
int counter = 0;
foreach (T.AgentSystem system in agentSystems)
{
foreach (AgentType agent in system.Agents)
{
tree.Add(agent, new GH_Path(counter));
}
counter++;
}
return tree;
}
DataTree<Curve> GetContourTree(Mesh mesh, List<double> contourZList)
{
DataTree<Curve> contourTree = new DataTree<Curve>();
int i = 0;
foreach (double z in contourZList)
{
Polyline[] contour = Rhino.Geometry.Intersect.Intersection.MeshPlane(mesh, new Plane(new Point3d(0, 0, z), new Vector3d(0, 0, 1)));
foreach (Polyline contourItem in contour)
{
PolylineCurve pCurve = new PolylineCurve(contourItem);
contourTree.Add(pCurve, new GH_Path(0, i));
}
i++;
}
return contourTree;
}
DataTree<Object> GetStepTree(Mesh terrainMesh, List<double> contourZList, DataTree<Curve> contourTree, List<Brep> brepList)
{
DataTree<Object> stepTree = new DataTree<Object>();
Plane basePlane = Plane.WorldXY;
basePlane.OriginZ = terrainMesh.GetBoundingBox(true).Min.Z;
// For each contour-plane
for (int i = 0; i < contourTree.BranchCount; i++)
{
// create higher-Z pt list
Point3dList winPtList = new Point3dList();
foreach (Curve contourCrv in contourTree.Branches[i])
{
Plane frm;
double t;
contourCrv.NormalizedLengthParameter(0.5, out t);
contourCrv.FrameAt(t, out frm);
frm.Transform(Rhino.Geometry.Transform.PlanarProjection(basePlane));
Point3d samplePt0, samplePt1;
samplePt0 = frm.Origin;
samplePt1 = frm.Origin;
samplePt0 += doc.ModelAbsoluteTolerance * frm.YAxis;
samplePt1 -= doc.ModelAbsoluteTolerance * frm.YAxis;
Ray3d ray0 = new Ray3d(samplePt0, Vector3d.ZAxis);
Ray3d ray1 = new Ray3d(samplePt1, Vector3d.ZAxis);
double rayParam0 = Rhino.Geometry.Intersect.Intersection.MeshRay(terrainMesh, ray0);
double rayParam1 = Rhino.Geometry.Intersect.Intersection.MeshRay(terrainMesh, ray1);
winPtList.Add(((rayParam0 > rayParam1) ? samplePt0 : samplePt1));
}
// For each splitted region in contour-plane
foreach (BrepFace brepFace in brepList[i].Faces)
{
Brep testBrep = brepFace.DuplicateFace(false);
foreach (Point3d pt in winPtList)
{
LineCurve testRay = new LineCurve(new Line(pt, Vector3d.ZAxis, 1000));
Point3d[] outPts;
Curve[] outCrvs;
bool ix = Rhino.Geometry.Intersect.Intersection.CurveBrep(testRay, testBrep, doc.ModelAbsoluteTolerance, out outCrvs, out outPts);
if (outPts.Length != 0)
{
stepTree.Add(testBrep, new GH_Path(i));
break;
}
}
}
}
return stepTree;
}
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 can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
// 1. Retrieve and validate data
var cell = new UnitCell();
double radius = 0;
double height = 0;
int nU = 0;
int nV = 0;
int nW = 0;
bool morphed = false;
if (!DA.GetData(0, ref cell)) { return; }
if (!DA.GetData(1, ref radius)) { return; }
if (!DA.GetData(2, ref height)) { return; }
if (!DA.GetData(3, ref nU)) { return; }
if (!DA.GetData(4, ref nV)) { return; }
if (!DA.GetData(5, ref nW)) { return; }
if (!DA.GetData(6, ref morphed)) { return; }
if (!cell.isValid) { return; }
if (radius == 0) { return; }
if (height == 0) { return; }
if (nU == 0) { return; }
if (nV == 0) { return; }
if (nW == 0) { return; }
// 2. Initialize the lattice
var lattice = new Lattice();
// Will contain the morphed uv spaces (as surface-surface, surface-axis or surface-point)
var spaceTree = new DataTree<GeometryBase>();
// 3. Define cylinder
Plane basePlane = Plane.WorldXY;
Surface cylinder = ( new Cylinder(new Circle(basePlane, radius), height) ).ToNurbsSurface();
cylinder = cylinder.Transpose();
LineCurve axis = new LineCurve(basePlane.Origin, basePlane.Origin + height*basePlane.ZAxis);
// 4. Package the number of cells in each direction into an array
float[] N = new float[3] { nU, nV, nW };
// 5. Normalize the UV-domain
Interval unitDomain = new Interval(0, 1);
cylinder.SetDomain(0, unitDomain); // surface u-direction
cylinder.SetDomain(1, unitDomain); // surface v-direction
axis.Domain = unitDomain;
// 6. Prepare cell (this is a UnitCell object)
cell = cell.Duplicate();
cell.FormatTopology();
// 7. Map nodes to design space
// Loop through the uvw cell grid
for (int u = 0; u <= N[0]; u++)
{
for (int v = 0; v <= N[1]; v++)
{
for (int w = 0; w <= N[2]; w++)
{
// Construct cell path in tree
GH_Path treePath = new GH_Path(u, v, w);
// Fetch the list of nodes to append to, or initialise it
var nodeList = lattice.Nodes.EnsurePath(treePath);
// This loop maps each node index in the cell onto the UV-surface maps
for (int i = 0; i < cell.Nodes.Count; i++)
{
double usub = cell.Nodes[i].X; // u-position within unit cell (local)
double vsub = cell.Nodes[i].Y; // v-position within unit cell (local)
double wsub = cell.Nodes[i].Z; // w-position within unit cell (local)
double[] uvw = { u + usub, v + vsub, w + wsub }; // uvw-position (global)
// Check if the node belongs to another cell (i.e. it's relative path points outside the current cell)
bool isOutsideCell = (cell.NodePaths[i][0] > 0 || cell.NodePaths[i][1] > 0 || cell.NodePaths[i][2] > 0);
// Check if current uvw-position is beyond the upper boundary
bool isOutsideSpace = (uvw[0] > N[0] || uvw[1] > N[1] || uvw[2] > N[2]);
if (isOutsideCell || isOutsideSpace)
{
nodeList.Add(null);
}
else
{
Point3d pt1, pt2;
Vector3d[] derivatives;
// Construct z-position vector
Vector3d vectorZ = height * basePlane.ZAxis * uvw[0] / N[0];
// Compute pt1 (on axis)
pt1 = basePlane.Origin + vectorZ;
// Compute pt2 (on surface)
cylinder.Evaluate(uvw[0] / N[0], uvw[1] / N[1], 2, out pt2, out derivatives);
// Create vector joining these two points
Vector3d wVect = pt2 - pt1;
// Instantiate new node
var newNode = new LatticeNode(pt1 + wVect * uvw[2] / N[2]);
// Add new node to tree
nodeList.Add(newNode);
}
}
}
// Define the uv space map tree (used for morphing)
if (morphed && u < N[0] && v < N[1])
{
GH_Path spacePath = new GH_Path(u, v);
// Set trimming interval
var uInterval = new Interval((u) / N[0], (u + 1) / N[0]);
var vInterval = new Interval((v) / N[1], (v + 1) / N[1]);
// Create sub-surface and sub axis
Surface ss1 = cylinder.Trim(uInterval, vInterval);
Curve ss2 = axis.Trim(uInterval);
// Unitize domains
ss1.SetDomain(0, unitDomain); ss1.SetDomain(1, unitDomain);
ss2.Domain = unitDomain;
// Save to the space tree
spaceTree.Add(ss1, spacePath);
spaceTree.Add(ss2, spacePath);
}
}
}
// 8. Map struts to the node tree
if (morphed)
{
lattice.MorphMapping(cell, spaceTree, N);
}
else
{
lattice.ConformMapping(cell, N);
}
// 9. Set output
DA.SetDataList(0, lattice.Struts);
}
/// <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_Point> SofistikPts;
DA.GetDataTree("SofistikPoints", out SofistikPts);
List<Point3d> flatclean = new List<Point3d>();
DA.GetDataList<Point3d>("Flatten Points", flatclean);
DataTree<int> SofistikInt = new DataTree<int>();
//---- End Declareing ---------------------------------------------------------------------------
//---- Functions --------------------------------------------------------------------------------
for (int i = 0; i < flatclean.Count; i++)
{
Point3d fpoint = flatclean[i];
for (int j = 0; j < SofistikPts.Paths.Count; j++)
{
GH_Path pth = SofistikPts.Paths[j];
for (int k = 0; k < SofistikPts[pth].Count; k++)
{
GH_Point ghp = SofistikPts[pth][k];
if ((Math.Abs(fpoint.X - ghp.Value.X) <= 0.01) &&
(Math.Abs(fpoint.Y - ghp.Value.Y) <= 0.01) &&
(Math.Abs(fpoint.Z - ghp.Value.Z) <= 0.01))
{
SofistikInt.Add(i, pth.AppendElement(k));
}
}
}
}
//---- End Functions ----------------------------------------------------------------------------
//---- Set Output -----------------------------------------------------------------------------
DA.SetDataTree(0, SofistikInt);
//---- End Set Output -----------------------------------------------------------------------------
}
public static DataTree<Polyline> makeTiles(Mesh mesh)
{
DataTree < Polyline> Tree = new DataTree<Polyline>();
for(int i = 0;i < mesh.Faces.Count;i++)
{
Vector3d ab = new Vector3d (mesh.Vertices[mesh.Faces[i].B] - mesh.Vertices[mesh.Faces[i].A]);
Vector3d ac = new Vector3d (mesh.Vertices[mesh.Faces[i].C] - mesh.Vertices[mesh.Faces[i].A]);
Point3dList pts = new Point3dList();
pts.Add(mesh.Vertices[mesh.Faces[i].A]);
pts.Add(mesh.Vertices[mesh.Faces[i].C]);
pts.Add(mesh.Vertices[mesh.Faces[i].B]);
Polyline edge = new Polyline(pts);
Tree.Add(edge);
}
return Tree;
}
protected override void SolveInstance(IGH_DataAccess DA)
{
// 1. Declare placeholder
string source = null;
string query = null;
string indexPath = null;
DataTree<string> queryResultTree = new DataTree<string>();
// 2. Abort on invalid inputs.
if (!DA.GetData(0, ref source)) { return; }
if (source == null) { return; }
if (source.Length == 0) { return; }
if (!DA.GetData(1, ref query)) { return; }
if (query == null) { return; }
if (query.Length == 0) { return; }
if (!DA.GetData(2, ref indexPath)) { return; }
if (query == null) { return; }
if (query.Length == 0) { return; }
gh_watcher = new GH_FileWatcher(indexPath, true, gh_watcher_Changed);
// 3. Connect to source & fetch data
MySqlConnection connection = new MySqlConnection(source);
try
{
connection.Open();
}
catch (Exception ex)
{
output.Add("Connection Failed.\n" + ex.ToString());
}
try
{
MySqlCommand command = connection.CreateCommand();
command.CommandText = query;
MySqlDataReader reader = command.ExecuteReader();
int i = 0;
while (reader.Read())
{
for (int j = 0; j < reader.FieldCount; j++)
{
queryResultTree.Add(reader.GetString(j), new GH_Path(i));
}
i++;
}
}
catch (Exception ex)
{
output.Add("Fetching failed.\n" + ex.ToString());
}
connection.Close();
// 4. Output
DA.SetDataTree(0, queryResultTree);
DA.SetDataList(1, output);
}
/// <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)
{
// 1. Retrieve and validate inputs
var cell = new UnitCell();
Surface s1 = null;
Surface s2 = null;
int nU = 0;
int nV = 0;
int nW = 0;
bool morphed = false;
if (!DA.GetData(0, ref cell)) { return; }
if (!DA.GetData(1, ref s1)) { return; }
if (!DA.GetData(2, ref s2)) { return; }
if (!DA.GetData(3, ref nU)) { return; }
if (!DA.GetData(4, ref nV)) { return; }
if (!DA.GetData(5, ref nW)) { return; }
if (!DA.GetData(6, ref morphed)) { return; }
if (!cell.isValid) { return; }
if (!s1.IsValid) { return; }
if (!s2.IsValid) { return; }
if (nU == 0) { return; }
if (nV == 0) { return; }
if (nW == 0) { return; }
// 2. Initialize the lattice
var lattice = new Lattice();
// Will contain the morphed uv spaces (as surface-surface)
var spaceTree = new DataTree<GeometryBase>();
// 3. Package the number of cells in each direction into an array
float[] N = new float[3] { nU, nV, nW };
// 4. Normalize the UV-domain
Interval unitDomain = new Interval(0,1);
s1.SetDomain(0, unitDomain); // s1 u-direction
s1.SetDomain(1, unitDomain); // s1 v-direction
s2.SetDomain(0, unitDomain); // s2 u-direction
s2.SetDomain(1, unitDomain); // s2 v-direction
// 5. Prepare cell (this is a UnitCell object)
cell = cell.Duplicate();
cell.FormatTopology();
// 6. Map nodes to design space
// Loop through the uvw cell grid
for (int u = 0; u <= N[0]; u++)
{
for (int v = 0; v <= N[1]; v++)
{
for (int w = 0; w <= N[2]; w++)
{
// Construct cell path in tree
GH_Path treePath = new GH_Path(u, v, w);
// Fetch the list of nodes to append to, or initialise it
var nodeList = lattice.Nodes.EnsurePath(treePath);
// This loop maps each node in the cell onto the UV-surface maps
for (int i = 0; i < cell.Nodes.Count; i++)
{
double usub = cell.Nodes[i].X; // u-position within unit cell (local)
double vsub = cell.Nodes[i].Y; // v-position within unit cell (local)
double wsub = cell.Nodes[i].Z; // w-position within unit cell (local)
double[] uvw = { u + usub, v + vsub, w + wsub }; // uvw-position (global)
// Check if the node belongs to another cell (i.e. it's relative path points outside the current cell)
bool isOutsideCell = (cell.NodePaths[i][0] > 0 || cell.NodePaths[i][1] > 0 || cell.NodePaths[i][2] > 0);
// Check if current uvw-position is beyond the upper boundary
bool isOutsideSpace = (uvw[0] > N[0] || uvw[1] > N[1] || uvw[2] > N[2]);
if (isOutsideCell || isOutsideSpace)
{
nodeList.Add(null);
}
else
{
// Initialize for surface 1
Point3d pt1; Vector3d[] derivatives1;
// Initialize for surface 2
Point3d pt2; Vector3d[] derivatives2;
// Evaluate point on both surfaces
s1.Evaluate(uvw[0] / N[0], uvw[1] / N[1], 2, out pt1, out derivatives1);
s2.Evaluate(uvw[0] / N[0], uvw[1] / N[1], 2, out pt2, out derivatives2);
// Create vector joining the two points (this is our w-range)
Vector3d wVect = pt2 - pt1;
// Create the node, accounting for the position along the w-direction
var newNode = new LatticeNode(pt1 + wVect * uvw[2] / N[2]);
// Add node to tree
nodeList.Add(newNode);
}
}
}
// Define the uv space tree (used for morphing)
if (morphed && u < N[0] && v < N[1])
{
GH_Path spacePath = new GH_Path(u, v);
// Set trimming interval
var uInterval = new Interval((u) / N[0], (u + 1) / N[0]);
var vInterval = new Interval((v) / N[1], (v + 1) / N[1]);
// Create sub-surfaces
Surface ss1 = s1.Trim(uInterval, vInterval);
Surface ss2 = s2.Trim(uInterval, vInterval);
// Unitize domain
ss1.SetDomain(0, unitDomain); ss1.SetDomain(1, unitDomain);
ss2.SetDomain(0, unitDomain); ss2.SetDomain(1, unitDomain);
// Save to the space tree
spaceTree.Add(ss1, spacePath);
spaceTree.Add(ss2, spacePath);
}
}
}
// 7. Map struts to the node tree
if (morphed) lattice.MorphMapping(cell, spaceTree, N);
else lattice.ConformMapping(cell, N);
// 8. Set output
DA.SetDataList(0, lattice.Struts);
}
/// <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 ---------------------------------------------------------------------------
List<Tri_Loop_Component> All_Components = new List<Tri_Loop_Component>();
DA.GetDataList<Tri_Loop_Component>("Components", All_Components);
DataTree<Point3d> SofistikPoints = new DataTree<Point3d>();
DataTree<int> SofistikIndexies = new DataTree<int>();
DataTree<int> SofistikCrvPtIdx = new DataTree<int>();
DataTree<Point3d> SofistikCrvPtCoo = new DataTree<Point3d>();
DataTree<Brep> SofistikBreps = new DataTree<Brep>();
DataTree<int> SofistikBrepsIdx = new DataTree<int>();
DataTree<Curve> SofistikCurves = new DataTree<Curve>();
//---- End Declareing -----------------------------------------------------------------------
//---- Functions ----------------------------------------------------------------------------
int componentIdx = 0;
foreach (Tri_Loop_Component component in All_Components)
{
GH_Path pth1 = new GH_Path(componentIdx);
// run / generate Informations for Sofistik
component.SofistikInformation();
component.SofistikCreateSurfaces();
// Points
for (int j = 0; j < component.SofistikPlatePoints.BranchCount; j++)
{
foreach (Point3d p in component.SofistikPlatePoints.Branch(j))
{ SofistikPoints.Add(p, pth1.AppendElement(j)); }
foreach (int idx in component.SofistikPlateIndexies.Branch(j))
{ SofistikIndexies.Add(idx, pth1.AppendElement(j)); }
}
// CurvePoints
for (int j = 0; j < component.SofistikCrvPtCoo.BranchCount; j++)
{
GH_Path pth0 = component.SofistikCrvPtCoo.Path(j);
foreach (Point3d pt in component.SofistikCrvPtCoo.Branch(j))
{
//pth1.AppendElement(pth0[0]);
//pth1.AppendElement(pth0[1]);
//SofistikCrvPtCoo.Add(pt, pth1.AppendElement(pth0[0]));
// 2 level Tree
SofistikCrvPtCoo.Add(pt, pth1.AppendElement(pth0[0]));
}
foreach (int idx in component.SofistikCrvPtIdx.Branch(j))
{
//pth1.AppendElement(pth0[0]);
//pth1.AppendElement(pth0[1]);
//SofistikCrvPtIdx.Add(idx, pth1.AppendElement(pth0[0]));
// 2 level Tree
SofistikCrvPtIdx.Add(idx, pth1.AppendElement(pth0[0]));
}
}
// Curves
for (int i = 0; i < component.SofistikCurves.BranchCount; i++)
{
GH_Path pth0 = component.SofistikCurves.Path(i);
foreach (Curve c in component.SofistikCurves.Branch(i))
{
SofistikCurves.Add(c, pth1.AppendElement(pth0[0]));
}
}
// Surfaces
for (int j = 0; j < component.SofistikSurfaces.BranchCount; j++)
{
foreach (Brep[] p in component.SofistikSurfaces.Branch(j))
{ SofistikBreps.Add(p[0], pth1.AppendElement(j)); }
foreach (int idx in component.SofistikSurfacesIdx.Branch(j))
{ SofistikBrepsIdx.Add(idx, pth1.AppendElement(j)); }
}
componentIdx++;
}
//---- End Functions ------------------------------------------------------------------------
//---- Set Output ---------------------------------------------------------------------------
DA.SetDataTree(0, SofistikPoints);
DA.SetDataTree(1, SofistikIndexies);
DA.SetDataTree(2, SofistikCrvPtCoo);
DA.SetDataTree(3, SofistikCrvPtIdx);
DA.SetDataTree(4, SofistikBreps);
DA.SetDataTree(5, SofistikBrepsIdx);
DA.SetDataTree(6, SofistikCurves);
//---- 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 ---------------------------------------------------------------------------
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 ---------------------------------------------------------------------------
List<Tri_Loop_Component> All_Components = new List<Tri_Loop_Component>();
DA.GetDataList<Tri_Loop_Component>("Components", All_Components);
DataTree<Curve> All_Curves = new DataTree<Curve>();
//// =======================================================================================
// Added by Gene
DataTree<Curve> All_ExtendedCurves = new DataTree<Curve>();
DataTree<Brep> All_SingleStripeBreps = new DataTree<Brep>();
//// =======================================================================================
DataTree<Point3d> All_CentrePointsL01 = new DataTree<Point3d>();
DataTree<Point3d> All_CentrePointsL02 = new DataTree<Point3d>();
DataTree<Curve> All_PlateCrv = new DataTree<Curve>();
DataTree<Point3d> All_PentagonPts_L01 = new DataTree<Point3d>();
DataTree<Point3d> All_PentagonPts_L02 = new DataTree<Point3d>();
DataTree<int> All_StripeIds = new DataTree<int>();
DataTree<Brep> All_StripeBreps = new DataTree<Brep>();
DataTree<Curve> All_StripeIntersectCrvs = new DataTree<Curve>();
DataTree<Plane> All_StripeIntersectPlane = new DataTree<Plane>();
//---- End Declareing -----------------------------------------------------------------------
//---- Functions ----------------------------------------------------------------------------
int componentIdx = 0;
foreach (Tri_Loop_Component component in All_Components)
{
GH_Path pth1 = new GH_Path(componentIdx);
// run / generate Informations for Sofistik
// create output information
for (int p = 0; p < component.CentersL01.Count; p++)
{
All_CentrePointsL01.Add(component.CentersL01[p], pth1);
All_CentrePointsL02.Add(component.CentersL02[p], pth1);
}
for (int c = 0; c < component.Curves.BranchCount; c++)
{
All_Curves.Add(component.Curves.Branch(c)[0], pth1.AppendElement(c));
All_Curves.Add(component.Curves.Branch(c)[1], pth1.AppendElement(c));
//// =======================================================================================
// Added by Gene
All_ExtendedCurves.Add(component.ExtendedCurves.Branch(c)[0], pth1.AppendElement(c));
All_ExtendedCurves.Add(component.ExtendedCurves.Branch(c)[1], pth1.AppendElement(c));
//// =======================================================================================
}
for (int sid = 0; sid < component.StripeID.BranchCount; sid++)
{
All_StripeIds.Add(component.StripeID.Branch(sid)[0], pth1.AppendElement(sid));
All_StripeIds.Add(component.StripeID.Branch(sid)[1], pth1.AppendElement(sid));
All_StripeIds.Add(component.StripeID.Branch(sid)[2], pth1.AppendElement(sid));
}
for (int p = 0; p < component.PlateCrv.BranchCount; p++)
{
All_PlateCrv.Add(component.PlateCrv.Branch(p)[0], pth1.AppendElement(p));
All_PlateCrv.Add(component.PlateCrv.Branch(p)[1], pth1.AppendElement(p));
}
for (int pent = 0; pent < component.PlanarPentagonL01.BranchCount; pent++)
{
All_PentagonPts_L01.Add(component.PlanarPentagonL01.Branch(pent)[0], pth1.AppendElement(pent));
All_PentagonPts_L01.Add(component.PlanarPentagonL01.Branch(pent)[1], pth1.AppendElement(pent));
All_PentagonPts_L01.Add(component.PlanarPentagonL01.Branch(pent)[2], pth1.AppendElement(pent));
All_PentagonPts_L01.Add(component.PlanarPentagonL01.Branch(pent)[3], pth1.AppendElement(pent));
All_PentagonPts_L01.Add(component.PlanarPentagonL01.Branch(pent)[4], pth1.AppendElement(pent));
}
for (int pent = 0; pent < component.PlanarPentagonL02.BranchCount; pent++)
{
All_PentagonPts_L02.Add(component.PlanarPentagonL02.Branch(pent)[0], pth1.AppendElement(pent));
All_PentagonPts_L02.Add(component.PlanarPentagonL02.Branch(pent)[1], pth1.AppendElement(pent));
All_PentagonPts_L02.Add(component.PlanarPentagonL02.Branch(pent)[2], pth1.AppendElement(pent));
All_PentagonPts_L02.Add(component.PlanarPentagonL02.Branch(pent)[3], pth1.AppendElement(pent));
All_PentagonPts_L02.Add(component.PlanarPentagonL02.Branch(pent)[4], pth1.AppendElement(pent));
}
// Information from Stripe Class
for (int s = 0; s < component.Stripes.Count; s++)
{
for (int t = 0; t < component.Stripes[s].SurfaceAtLoop.Length; t++)
{ All_StripeBreps.Add(component.Stripes[s].SurfaceAtLoop[t], pth1.AppendElement(s)); }
//for (int u = 0; u < component.Stripes[s].IntersectionCurve.Length; u++)
//{ All_StripeIntersectCrvs.Add(component.Stripes[s].IntersectionCurve[u], pth1.AppendElement(s));}
All_StripeIntersectPlane.Add(component.Stripes[s].IntersectionPlane, pth1.AppendElement(s));
}
// ======================================================================================================
// Gene Added
for (int s = 0; s < component.StripesSingle.Count; s++)
{
All_SingleStripeBreps.Add(component.StripesSingle[s].loop, pth1.AppendElement(s));
//for (int u = 0; u < component.Stripes[s].IntersectionCurve.Length; u++)
//{ All_StripeIntersectCrvs.Add(component.Stripes[s].IntersectionCurve[u], pth1.AppendElement(s));}
//All_StripeIntersectPlane.Add(component.StripesSingle[s].IntersectionPlane, pth1.AppendElement(s));
}
// ======================================================================================================
componentIdx++;
}
//---- End Functions ------------------------------------------------------------------------
//---- Set Output ---------------------------------------------------------------------------
DA.SetDataTree(0, All_CentrePointsL01);
DA.SetDataTree(1, All_CentrePointsL02);
DA.SetDataTree(2, All_Curves);
DA.SetDataTree(3, All_PlateCrv);
DA.SetDataTree(4, All_PentagonPts_L01);
DA.SetDataTree(5, All_PentagonPts_L02);
DA.SetDataTree(6, All_StripeIds);
DA.SetDataTree(7, All_StripeBreps);
DA.SetDataTree(8, All_StripeIntersectPlane);
//// =======================================================================================
// Added by Gene
DA.SetDataTree(9, All_ExtendedCurves);
DA.SetDataTree(10, All_SingleStripeBreps);
//// =======================================================================================
//---- End Set Output -----------------------------------------------------------------------
}
