protected override void SolveInstance(IGH_DataAccess DA) { object raw_g = null; if (!DA.GetData("Glulam", ref raw_g)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid Glulam input."); return; } GH_Glulam ghg = raw_g as GH_Glulam; if (ghg == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid Glulam input."); return; } Glulam g = ghg.Value; double offset = 0.0; DA.GetData("Amount", ref offset); DA.SetData("Output", g.ToBrep(offset)); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam m_glulam = null; if (!DA.GetData <Glulam>("Glulam", ref m_glulam)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Could not get Glulam."); return; } double x = 0.0, y = 0.0; DA.GetData("OffsetX", ref x); DA.GetData("OffsetY", ref y); Curve crv = m_glulam.CreateOffsetCurve(x, y); // GlulamData data = GlulamData.FromCurveLimits(crv,g.Data.NumWidth * g.Data.LamWidth, g.Data.NumHeight * g.Data.LamHeight, g.GetAllPlanes()); //data.Samples = g.Data.Samples; Glulam offset_glulam = Glulam.CreateGlulam(crv, m_glulam.Orientation.Duplicate(), m_glulam.Data.Duplicate()); DA.SetData("Glulam", new GH_Glulam(offset_glulam)); }
protected override void SolveInstance(IGH_DataAccess DA) { Curve crv = null; List <Plane> planes = new List <Plane>(); if (!DA.GetData("Curve", ref crv)) { return; } DA.GetDataList("Frames", planes); Lam.GlulamData data = null; object iData = null; DA.GetData("Data", ref iData); if (iData is GlulamData) { data = iData as GlulamData; } else if (iData is GH_GlulamData) { data = (iData as GH_GlulamData).Value; } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Failed to get GlulamData."); } Glulam blank = Glulam.CreateGlulam(crv, planes.ToArray(), data); DA.SetData("Glulam", new GH_Glulam(blank)); }
protected override void SolveInstance(IGH_DataAccess DA) { object raw_in = null; if (!DA.GetData("Glulam", ref raw_in)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No Glulam specified."); return; } GH_Glulam ghg = raw_in as GH.GH_Glulam; if (ghg == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Input is not valid Glulam object."); return; } Glulam g = ghg.Value; int side = 0; DA.GetData("Side", ref side); double offset = 0.0; DA.GetData("Offset", ref offset); double width = 0.0; DA.GetData("Width", ref width); double extension = 0.0; DA.GetData("Extension", ref extension); Brep b = g.GetSideSurface(side, offset, width, extension); DA.SetData("Brep", b); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam glulam = null; if (!DA.GetData("Glulam", ref glulam)) { return; } string name = "GlulamBeamElement"; DA.GetData("Name", ref name); Plane handle = Plane.Unset; DA.GetData("Plane", ref handle); BeamElement beam_element; if (handle == Plane.Unset) { beam_element = new BeamElement(glulam, name); } else { beam_element = new BeamElement(glulam, handle, name); } DA.SetData("Element", new GH_Element(beam_element)); }
public override bool Evaluate() { Glulam g = GlulamParam.Value as Glulam; bool is_ok_x = false, is_ok_y = false; Glulam gdup = g.Duplicate(); gdup.Data.LamHeight = (double)LHParam.Value; gdup.Data.LamWidth = (double)LWParam.Value; bool res = gdup.InKLimitsComponent(out is_ok_x, out is_ok_y); if (res) { return(res); } else { if (!LHParam.Locked && !LWParam.Locked) { //GlulamData gdata = GlulamData.FromCurveLimits(g.Centreline, g.GetAllPlanes()); GlulamData gdata = GlulamData.Default; LHParam.Value = gdata.LamHeight; LWParam.Value = gdata.LamWidth; return(true); } else { // TODO: Propose new relaxed curve return(false); } } }
protected override void SolveInstance(IGH_DataAccess DA) { Curve crv = null; if (!DA.GetData("Curve", ref crv)) { return; } crv.Domain.MakeIncreasing(); List <object> r_orientation = new List <object>(); DA.GetDataList("Orientation", r_orientation); object r_data = null; DA.GetData("Data", ref r_data); CrossSectionOrientation orientation = ParseGlulamOrientation(r_orientation, crv); AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, orientation.ToString()); GlulamData data = ParseGlulamData(r_data); AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, data.ToString()); data.Samples = (int)Math.Ceiling(crv.GetLength() / GlulamData.DefaultSampleDistance); Glulam glulam = Glulam.CreateGlulam(crv, orientation, data); DA.SetData("Glulam", new GH_Glulam(glulam)); }
protected override void SolveInstance(IGH_DataAccess DA) { Point3d m_point = Point3d.Unset; bool m_flip = false; DA.GetData("Point", ref m_point); DA.GetData("Flip", ref m_flip); // Get Glulam Glulam m_glulam = null; DA.GetData <Glulam>("Glulam", ref m_glulam); if (m_glulam == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid glulam input."); return; } Plane plane = m_glulam.GetPlane(m_point); if (m_flip) { plane = plane.FlipAroundYAxis(); } DA.SetData("Plane", plane); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam m_glulam = null; if (!DA.GetData("Glulam", ref m_glulam)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No glulam input."); return; } Mesh m = m_glulam.ToMesh(); double m_ratio = 200.0; DA.GetData("Ratio", ref m_ratio); if (m_ratio <= 0.0) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Ratio values must be greater than 0."); return; } double min_rx = m_glulam.Data.LamWidth * m_ratio; double min_ry = m_glulam.Data.LamHeight * m_ratio; double max_kx = 1 / min_rx; double max_ky = 1 / min_ry; List <double> f_values = new List <double>(); double t; for (int i = 0; i < m.Vertices.Count; ++i) { m_glulam.Centreline.ClosestPoint(m.Vertices[i], out t); Plane frame = m_glulam.GetPlane(t); Vector3d offset = m.Vertices[i] - frame.Origin; double offset_x = offset * frame.XAxis; double offset_y = offset * frame.YAxis; Vector3d kv = m_glulam.Centreline.CurvatureAt(t); double k = kv.Length; kv.Unitize(); double r = (1 / k) - offset * kv; k = 1 / r; double kx = k * (kv * frame.XAxis); double ky = k * (kv * frame.YAxis); f_values.Add(Math.Max(Math.Abs(kx / max_kx), Math.Abs(ky / max_ky))); } DA.SetData("Mesh", m); DA.SetDataList("Factor", f_values); }
public EndLapJoint(Glulam glulam, int end, double length, double incline, double extension) { m_glulam = glulam; m_length = length; m_incline = incline; m_extension = extension; m_end = end.Modulus(2) == 0; }
public CrossJoint(Glulam glulamA, Glulam glulamB, double offset1, double offset2) { m_glulamA = glulamA; m_glulamB = glulamB; m_offset1 = offset1; m_offset2 = offset2; offset_center = 10; }
protected void MapObjectToGlulam(List <object> input, Glulam g, IGH_DataAccess DA) { if (input == null || input.Count < 1) { return; } if (input.Count == 1) { object single = input[0]; AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, single.ToString()); if (single is Point3d) { DA.SetDataList("Geometry", new object[] { g.ToBeamSpace((Point3d)single) }); } else if (single is GH_Point) { DA.SetDataList("Geometry", new object[] { g.ToBeamSpace((single as GH_Point).Value) }); } else if (single is Plane) { DA.SetDataList("Geometry", new object[] { g.ToBeamSpace((Plane)single) }); } else if (single is GH_Plane) { DA.SetDataList("Geometry", new object[] { g.ToBeamSpace((single as GH_Plane).Value) }); } if (single is GH_Mesh) { DA.SetDataList("Geometry", new object[] { g.ToBeamSpace((single as GH_Mesh).Value) }); } if (single is Mesh) { DA.SetDataList("Geometry", new object[] { g.ToBeamSpace(single as Mesh) }); } return; } if (input.First() is GH_Plane) { DA.SetDataList("Geometry", g.ToBeamSpace(input.Select(x => (x as GH_Plane).Value).ToList())); } else if (input.First() is Plane) { DA.SetDataList("Geometry", g.ToBeamSpace(input.Select(x => (Plane)x).ToList())); } else if (input.First() is GH_Point) { DA.SetDataList("Geometry", g.ToBeamSpace(input.Select(x => (x as GH_Point).Value).ToList())); } else if (input.First() is Point3d) { DA.SetDataList("Geometry", g.ToBeamSpace(input.Select(x => (Point3d)x).ToList())); } }
protected override void SolveInstance(IGH_DataAccess DA) { // Get Glulam Glulam m_glulam = null; DA.GetData <Glulam>("Glulam", ref m_glulam); if (m_glulam == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid glulam input."); return; } List <double> m_params = new List <double>(); DA.GetDataList("Parameter", m_params); if (m_params.Count < 1) { return; } double m_overlap = 0; DA.GetData("Overlap", ref m_overlap); m_params.Sort(); List <Glulam> m_glulams = new List <Glulam>(); //m_glulams = g.Split(m_params.ToArray(), m_overlap); List <Interval> domains = new List <Interval>(); double dmin = m_glulam.Centreline.Domain.Min; domains.Add(new Interval(dmin, m_params.First())); for (int i = 0; i < m_params.Count - 1; ++i) { domains.Add(new Interval(m_params[i], m_params[i + 1])); } domains.Add(new Interval(m_params.Last(), m_glulam.Centreline.Domain.Max)); //domains = domains.Where(x => m_glulam.Centreline.GetLength(x) > m_overlap).ToList(); for (int i = 0; i < domains.Count; ++i) { Glulam temp = m_glulam.Trim(domains[i], m_overlap); if (temp == null) { continue; } m_glulams.Add(temp); } DA.SetDataList("Glulams", m_glulams.Select(x => new GH_Glulam(x))); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam gA = null, gB = null; if (!DA.GetData <Glulam>("GlulamA", ref gA) || !DA.GetData <Glulam>("GlulamB", ref gB)) { return; } //gA.Centreline.ClosestPoints(gB.Centreline, out Point3d pA, out Point3d pB); double search_distance = Math.Max(Math.Max(gA.Height, gB.Height), Math.Max(gA.Width, gB.Width)); var intersections = Rhino.Geometry.Intersect.Intersection.CurveCurve(gA.Centreline, gB.Centreline, search_distance, search_distance); if (intersections == null || intersections.Count < 1) { return; } var intersection = intersections[0]; if (!intersection.IsOverlap) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Glulams are not overlapping. Might create unexpected results."); } Point3d pA = (intersection.PointA + intersection.PointA2) / 2; Point3d pB = (intersection.PointB + intersection.PointB2) / 2; gA.Centreline.ClosestPoint(pA, out double tA); gB.Centreline.ClosestPoint(pB, out double tB); //Point3d pC = (pA + pB) / 2; //gA.Centreline.ClosestPoint(pC, out double tA); //gB.Centreline.ClosestPoint(pC, out double tB); double m_length = 100.0, m_incline = 20.0; DA.GetData("Length", ref m_length); DA.GetData("Incline", ref m_incline); EndLapJoint2 scarf_joint = new EndLapJoint2(gA, gB, tA, tB, m_length, m_incline); scarf_joint.Compute(); List <Brep> breps = scarf_joint.GetCuttingGeometry(); if (breps.Count > 0) { DA.SetData("Brep", breps[0]); } }
public CrossJoint2(Glulam glulamA, Glulam glulamB, double offset1 = 10.0, double offset2 = 10.0, double extension = 5.0, double drill_depth = 100.0) { m_glulam1 = glulamA; m_glulam2 = glulamB; m_offset1 = offset1; m_offset2 = offset2; m_extension = extension; offset_center = 10; m_drill_depth = drill_depth; }
public EndLapJoint2(Glulam glulam1, Glulam glulam2, double t1, double t2, double length, double incline, double extension = 5.0, double drill_depth = 200.0) { m_glulam1 = glulam1; m_glulam2 = glulam2; m_t1 = t1; m_t2 = t2; m_length = length; m_incline = incline; m_extension = extension; m_drill_depth = drill_depth; }
protected override void SolveInstance(IGH_DataAccess DA) { Curve crv = null; Brep brep = null; //double lw = 0, lh = 0; double w = 0, h = 0; int samples = 0; List <Plane> planes = new List <Plane>(); if (!DA.GetData("Curve", ref crv)) { return; } if (!DA.GetData("Brep", ref brep)) { return; } //DA.GetData("LamWidth", ref lw); //DA.GetData("LamHeight", ref lh); DA.GetData("Width", ref w); DA.GetData("Height", ref h); DA.GetData("Samples", ref samples); samples = Math.Max(samples, 2); Plane[] frames = tas.Core.Util.Misc.FramesNormalToSurface(crv, brep); GlulamData data = null; if (calculate_data) { data = Lam.GlulamData.FromCurveLimits(crv, w, h, frames); } else { data = new Lam.GlulamData(1, 1, w, h, samples); } //data.LamHeight = lh > 0.001 ? lh : 20.0; //data.LamWidth = lw > 0.001 ? lw : 20.0; //data.NumHeight = h > 0 ? (int)Math.Ceiling(h / lh) : 4; //data.NumWidth = w > 0 ? (int)Math.Ceiling(w / lw) : 4; data.InterpolationType = GlulamData.Interpolation.HERMITE; Glulam blank = Glulam.CreateGlulam(crv, frames, data); //Lam.Glulam blank = Lam.Glulam.CreateGlulamNormalToSurface(crv, brep, 20, null); DA.SetData("Glulam", new GH_Glulam(blank)); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam gA = null, gB = null; double extension = 10.0; bool normalized = false; if (!DA.GetData <Glulam>("Glulam A", ref gA) || !DA.GetData <Glulam>("Glulam B", ref gB)) { return; } Brep bi = Glulam.GetGlulamBisector(gA, gB, extension, normalized); DA.SetData("Brep", bi); }
protected override void SolveInstance(IGH_DataAccess DA) { object m_obj = null; Mesh m_mesh = null; double m_angle = Rhino.RhinoMath.ToRadians(5); DA.GetData("Angle", ref m_angle); DA.GetData("Mesh", ref m_mesh); DA.GetData("Glulam", ref m_obj); while (true) { GH_Glulam m_ghglulam = m_obj as GH_Glulam; if (m_ghglulam != null) { m_mesh = m_ghglulam.Value.MapToCurveSpace(m_mesh); break; } GH_Curve m_ghcurve = m_obj as GH_Curve; if (m_ghcurve != null) { m_mesh = m_ghcurve.Value.MapToCurveSpace(m_mesh); break; } Glulam m_glulam = m_obj as Glulam; if (m_glulam != null) { m_mesh = m_glulam.MapToCurveSpace(m_mesh); break; } Curve m_curve = m_obj as Curve; if (m_curve != null) { m_mesh = m_curve.MapToCurveSpace(m_mesh); break; } throw new Exception("Input must be either Glulam or Curve!"); } var indices = m_mesh.CheckFibreCuttingAngle(m_angle); DA.SetDataList("Face Indices", indices); DA.SetData("debug", m_mesh); }
protected override void SolveInstance(IGH_DataAccess DA) { object m_obj = null; Mesh m_mesh = null; bool m_faces = false; DA.GetData("Mesh", ref m_mesh); DA.GetData("Glulam", ref m_obj); DA.GetData("Faces", ref m_faces); Curve m_curve = null; while (true) { GH_Glulam m_ghglulam = m_obj as GH_Glulam; if (m_ghglulam != null) { m_curve = m_ghglulam.Value.Centreline; break; } GH_Curve m_ghcurve = m_obj as GH_Curve; if (m_ghcurve != null) { m_curve = m_ghcurve.Value; break; } Glulam m_glulam = m_obj as Glulam; if (m_glulam != null) { m_curve = m_glulam.Centreline; break; } m_curve = m_obj as Curve; if (m_curve != null) { break; } throw new Exception("Input must be either Glulam or Curve!"); } List <Vector3d> deviations = m_mesh.CalculateTangentVector(m_curve, m_faces); DA.SetDataList("Vectors", deviations); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam glulam = null; if (!DA.GetData <Glulam>("Glulam", ref glulam)) { return; } int side = 0; DA.GetData("Side", ref side); Brep[] breps = glulam.GetGlulamFaces(side); DA.SetDataList("Faces", breps); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam m_glulam = null; if (!DA.GetData("Glulam", ref m_glulam)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No glulam input."); return; } Mesh m = m_glulam.GetBoundingMesh(); List <double> kx_values = new List <double>(); List <double> ky_values = new List <double>(); double t; for (int i = 0; i < m.Vertices.Count; ++i) { m_glulam.Centreline.ClosestPoint(m.Vertices[i], out t); Plane frame = m_glulam.GetPlane(t); Vector3d offset = m.Vertices[i] - frame.Origin; double offset_x = offset * frame.XAxis; double offset_y = offset * frame.YAxis; Vector3d kv = m_glulam.Centreline.CurvatureAt(t); double k = kv.Length; kv.Unitize(); double r = (1 / k) - offset * kv; k = 1 / r; double kx = k * (kv * frame.XAxis); double ky = k * (kv * frame.YAxis); kx_values.Add(Math.Abs(kx)); ky_values.Add(Math.Abs(ky)); } DA.SetData("Mesh", m); DA.SetDataList("Curvature X", kx_values); DA.SetDataList("Curvature Y", ky_values); }
public static void CreateElementOrientations(this Glulam g, List <Node> nodes, List <Element> elements, out List <ElementOrientation> orientations) { orientations = new List <ElementOrientation>(elements.Count); foreach (Element ele in elements) { Point3d centre = new Point3d( ele.Data.Select(x => nodes[x - 1].X).ToArray().Sum() / 8, ele.Data.Select(x => nodes[x - 1].Y).ToArray().Sum() / 8, ele.Data.Select(x => nodes[x - 1].Z).ToArray().Sum() / 8 ); //Plane ori = Plane.Unset; GetOrientation(g, centre, out Plane ori); orientations.Add(new ElementOrientation(ori, ele.Id)); } }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam g = null; if (!DA.GetData <Glulam>("Glulam", ref g)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "No glulam blank connected."); return; } List <object> m_objects = new List <object>(); if (!DA.GetDataList("Geo", m_objects)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Invalid geometry specified."); return; } MapObjectToGlulam(m_objects, g, DA); }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam gA = null, gB = null; if (!DA.GetData <Glulam>("GlulamA", ref gA) || !DA.GetData <Glulam>("GlulamB", ref gB)) { return; } CrossJoint2 cross_joint = new CrossJoint2(gA, gB); cross_joint.Compute(); List <Brep> breps = cross_joint.GetCuttingGeometry(); if (breps.Count > 0) { DA.SetData("Brep", breps[0]); } }
protected override void SolveInstance(IGH_DataAccess DA) { Glulam m_glulam = null; if (!DA.GetData <Glulam>("Glulam", ref m_glulam)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Invalid glulam input."); return; } List <double> m_parameters = new List <double>(); DA.GetDataList("Parameters", m_parameters); //double[] tt = g.Centreline.DivideByCount(N, true); Plane[] planes = m_parameters.Select(x => m_glulam.GetPlane(x)).ToArray(); DA.SetDataList("Planes", planes); }
protected override void SolveInstance(IGH_DataAccess DA) { Mesh mesh_input = null; Curve c = null; double extra = 0.0; GeometryBase geo = null; if (!DA.GetData("Geo", ref geo)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No input geometry."); } if (!DA.GetData("Curve", ref c)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No guide curve."); } DA.GetData("Extra", ref extra); if (geo is Brep) { mesh_input = Mesh.CreateFromBrep(geo as Brep, MeshingParameters.QualityRenderMesh).Amalgamate(); } else if (geo is Mesh) { mesh_input = geo as Mesh; } else { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Failed to parse geometry."); } double w, h, l; Glulam g = Glulam.CreateGlulamFromBeamGeometry2(c, mesh_input, out w, out h, out l, extra); DA.SetData("Glulam", new GH_Glulam(g)); DA.SetDataList("Dimensions", new double[] { w, h, l }); }
public ArchivableDictionary GlulamPropertiesToArchivableDictionary(Glulam g) { ArchivableDictionary ad = new ArchivableDictionary(); var gd = g.GetProperties(); //ad.Set("id", g.ID); ad.Set("centreline", g.Centreline); ad.Set("width", g.Width); ad.Set("height", g.Height); ad.Set("lamella_width", g.Data.LamWidth); ad.Set("lamella_height", g.Data.LamHeight); ad.Set("lamella_count_width", g.Data.NumWidth); ad.Set("lamella_count_height", g.Data.NumHeight); ad.Set("volume", g.GetVolume()); ad.Set("samples", g.Data.Samples); /* * var planes = g.GetAllPlanes(); * ArchivableDictionary pd = new ArchivableDictionary(); * * for (int i = 0; i < planes.Length; ++i) * { * pd.Set(string.Format("Frame_{0}", i), planes[i]); * } * ad.Set("frames", pd); * */ double max_kw = 0.0, max_kh = 0.0; ad.Set("max_curvature", g.GetMaxCurvature(ref max_kw, ref max_kh)); ad.Set("max_curvature_width", max_kw); ad.Set("max_curvature_height", max_kh); ad.Set("type", g.ToString()); ad.Set("type_id", (int)g.Type()); return(ad); }
protected override void BeforeSolveInstance() { if (valueList == null) { if (parameter.Sources.Count == 0) { valueList = new GH_ValueList(); } else { foreach (var source in parameter.Sources) { if (source is GH_ValueList) { valueList = source as GH_ValueList; } return; } } valueList.CreateAttributes(); valueList.Attributes.Pivot = new PointF(this.Attributes.Pivot.X - 200, this.Attributes.Pivot.Y - 1); valueList.ListItems.Clear(); var glulamParameters = Glulam.ListProperties(); foreach (string param in glulamParameters) { valueList.ListItems.Add(new GH_ValueListItem(param, $"\"{param}\"")); } Instances.ActiveCanvas.Document.AddObject(valueList, false); parameter.AddSource(valueList); parameter.CollectData(); } }
public static void CreateGlulamNodesAndElements(this Glulam g, out List <Node> nodes, out List <Element> elements, int Nx = 4, int Ny = 4, int Nz = 50) { double hWidth = g.Width / 2; double hHeight = g.Height / 2; double stepX = g.Width / Nx; double stepY = g.Height / Ny; List <Point3d> xPts = new List <Point3d>(); for (int y = 0; y <= Ny; ++y) { for (int x = 0; x <= Nx; ++x) { Point3d pt = new Point3d( -hWidth + x * stepX, -hHeight + y * stepY, 0); xPts.Add(pt); } } Plane[] xplanes; double[] xt; int N = Nz + 1; g.GenerateCrossSectionPlanes(N, out xplanes, out xt, GlulamData.Interpolation.LINEAR); nodes = new List <Node>(); int i = 0; for (int z = 0; z < N; ++z) { Transform xform = Transform.PlaneToPlane(Plane.WorldXY, xplanes[z]); for (int j = 0; j < xPts.Count; ++j) { Point3d pt = new Point3d(xPts[j]); pt.Transform(xform); nodes.Add(new Node(pt.X, pt.Y, pt.Z, i + 1)); i++; } } elements = new List <Element>(); int sz = (Nx + 1) * (Ny + 1); int sy = (Nx + 1); i = 0; for (int z = 0; z < Nz; ++z) { int cz = z * sz; for (int y = 0; y < Ny; ++y) { int cy = y * sy; for (int x = 0; x < Nx; ++x) { int[] indices = new int[] { cz + cy + x, cz + cy + x + 1, cz + cy + x + sy + 1, cz + cy + x + sy, cz + sz + cy + x, cz + sz + cy + x + 1, cz + sz + cy + x + sy + 1, cz + sz + cy + x + sy }; for (int ii = 0; ii < 8; ++ii) { indices[ii] = nodes[indices[ii]].Id; } Element ele = new C3D8 { Data = indices, Id = i + 1 }; elements.Add(ele); ++i; } } } }