public void DivideFromPoint() { var grid = new Grid1d(new Line(new Vector3(-5, -5), new Vector3(5, 5))); grid.DivideByFixedLengthFromPoint(3, new Vector3(-4, 4)); Assert.Equal(6, grid.Cells.Count); }
public void GridFromCurves() { var a = Vector3.Origin; var b = new Vector3(5, 0, 1); var c = new Vector3(5, 5, 2); var d = new Vector3(0, 5, 3); var e = new Vector3(0, 0, 4); var f = new Vector3(5, 0, 5); var ctrlPts = new List <Vector3> { a, b, c, d, e, f }; var bezier1 = new Bezier(ctrlPts); var grid = new Grid1d(bezier1); grid.DivideByApproximateLength(0.5, EvenDivisionMode.RoundUp); var cellGeometry = grid.GetCells().Select(cl => cl.GetCellGeometry()); Assert.Equal(25, cellGeometry.Count()); var r = 2.0; var a1 = new Arc(new Vector3(5, 0), r, -90.0, 90.0); var arcGrid = new Grid1d(a1); arcGrid.DivideByApproximateLength(1, EvenDivisionMode.RoundDown); arcGrid.Cells[1].DivideByCount(4); var arcCellGeometry = arcGrid.GetCells().Select(cl => cl.GetCellGeometry()); Assert.Equal(9, arcCellGeometry.Count()); }
private static void PanelGroundFloor(double bottomElevation, double topElevation, Line[] boundarySegments, double panelWidth, Model model) { foreach (var segment in boundarySegments) { var u = new Grid1d(segment); var v = new Grid1d(new Line(segment.Start, new Vector3(segment.Start.X, segment.Start.Y, segment.Start.Z + topElevation))); var grid2d = new Grid2d(u, v); grid2d.U.DivideByFixedLength(1.5); grid2d.V.DivideByCount(2); foreach (var sep in grid2d.GetCellSeparators(GridDirection.U)) { var mullion = new Beam((Line)sep, Polygon.Rectangle(0.05, 0.05), BuiltInMaterials.Black); model.AddElement(mullion); } foreach (var sep in grid2d.GetCellSeparators(GridDirection.V)) { var mullion = new Beam((Line)sep, Polygon.Rectangle(0.05, 0.05), BuiltInMaterials.Black); model.AddElement(mullion); } var panel = new Panel(new Polygon(new[] { segment.Start, segment.End, new Vector3(segment.End.X, segment.End.Y, segment.End.Z + topElevation), new Vector3(segment.Start.X, segment.Start.Y, segment.Start.Z + topElevation) }), BuiltInMaterials.Glass); model.AddElement(panel); } }
public void Grid1dFixedDivisions() { var length = 10; var panelTarget = 3; var sacrificial = 0; var inMiddle = new Grid1d(new Line(new Vector3(0, 0, 0), new Vector3(length, 0, 0))); var atStart = new Grid1d(new Line(new Vector3(0, 1, 0), new Vector3(length, 1, 0))); var atEnd = new Grid1d(new Line(new Vector3(0, 2, 0), new Vector3(length, 2, 0))); var atBothEnds = new Grid1d(new Line(new Vector3(0, 3, 0), new Vector3(length, 3, 0))); inMiddle.DivideByFixedLength(panelTarget, FixedDivisionMode.RemainderNearMiddle, sacrificial); atStart.DivideByFixedLength(panelTarget, FixedDivisionMode.RemainderAtStart, sacrificial); atEnd.DivideByFixedLength(panelTarget, FixedDivisionMode.RemainderAtEnd, sacrificial); atBothEnds.DivideByFixedLength(panelTarget, FixedDivisionMode.RemainderAtBothEnds, sacrificial); Assert.Equal(panelTarget, inMiddle.Cells.First().Domain.Length); Assert.Equal(panelTarget, inMiddle.Cells.Last().Domain.Length); Assert.NotEqual(panelTarget, atStart.Cells.First().Domain.Length); Assert.Equal(panelTarget, atStart.Cells.Last().Domain.Length); Assert.Equal(panelTarget, atEnd.Cells.First().Domain.Length); Assert.NotEqual(panelTarget, atEnd.Cells.Last().Domain.Length); Assert.NotEqual(panelTarget, atBothEnds.Cells.First().Domain.Length); Assert.NotEqual(panelTarget, atBothEnds.Cells.Last().Domain.Length); }
/// <summary> /// Add graph section using polygon, extruded in given direction. /// Any vertices that already exist are not created but reused. /// This way new region is connected with the rest of the graph. /// </summary> /// <param name="boundingPolygon">Base polygon</param> /// <param name="extrusionAxis">Extrusion direction</param> /// <param name="distance">Height of polygon extrusion</param> /// <param name="keyPoints">Set of 3D points, region is split with.</param> public void AddFromExtrude(Polygon boundingPolygon, Vector3 extrusionAxis, double distance, List <Vector3> keyPoints) { var gridZ = new Grid1d(new Line(boundingPolygon.Start, boundingPolygon.Start + distance * extrusionAxis)); gridZ.SplitAtPoints(keyPoints); var edgesBefore = GetEdges(); var zCells = gridZ.GetCells(); for (var i = 0; i < zCells.Count; i++) { var elevationVector = zCells[i].Domain.Min * extrusionAxis; var transformedPolygonBottom = boundingPolygon.TransformedPolygon(new Transform(elevationVector)); var grid = CreateGridFromPolygon(transformedPolygonBottom); SplitGrid(grid, keyPoints); SplitGridAtIntersectionPoints(boundingPolygon, grid, edgesBefore); var addedEdges = AddFromGrid(grid, edgesBefore); AddVerticalEdges(extrusionAxis, zCells[i].Domain.Length, addedEdges); if (i == zCells.Count - 1) { var transformedPolygonTop = boundingPolygon.TransformedPolygon( new Transform(zCells[i].Domain.Max * extrusionAxis)); grid = CreateGridFromPolygon(transformedPolygonTop); SplitGrid(grid, keyPoints); SplitGridAtIntersectionPoints(boundingPolygon, grid, edgesBefore); AddFromGrid(grid, edgesBefore); } } }
public void Grid2dSerializes() { Name = "grid2d serializes"; var polyline = new Polyline(new[] { new Vector3(0, 0, 0), new Vector3(10, 2, 0), new Vector3(30, 4, 0), }); var uGrid = new Grid1d(polyline); var p2 = new Line(Vector3.Origin, new Vector3(0, 20, 0)); var vGrid = new Grid1d(p2); var grid2d = new Grid2d(uGrid, vGrid); grid2d.U.DivideByCount(10); grid2d.V.DivideByCount(3); grid2d[2, 2].U.DivideByCount(4); var json = JsonConvert.SerializeObject(grid2d); var deserialized = JsonConvert.DeserializeObject <Grid2d>(json); Assert.Equal(grid2d.GetCells().Count, deserialized.GetCells().Count); var grid2dElem = new Grid2dElement(grid2d, Guid.NewGuid(), "Grid"); Model.AddElement(grid2dElem); }
public void DivideFromPosition() { var grid = new Grid1d(new Domain1d(-8, 8)); Assert.Throws <ArgumentException>(() => grid.DivideByFixedLengthFromPosition(1, 10)); grid.DivideByFixedLengthFromPosition(4, 0); Assert.Equal(4, grid.Cells.Count); }
public void Grid1d() { this.Name = "Elements_Spatial_Grid1d"; // <example> // Create a 1d Grid from a line var line = new Line(new Vector3(5, 0, 0), new Vector3(60, 0, 0)); var grid = new Grid1d(line); // Divide the grid into sections of length 10, and leave remainders // at both ends grid.DivideByFixedLength(10, FixedDivisionMode.RemainderAtBothEnds); // Take the second grid segment and subdivide it // into 5 equal length segments grid[1].DivideByCount(5); // Take the third grid segment and subdivide it into // segments of approximate length 3 grid[2].DivideByApproximateLength(3); // Take the fourth grid segment and subdivide it by a repeating pattern var pattern = new[] { 1.0, 1.5 }; grid[3].DivideByPattern(pattern); // Retrieve all bottom-level cells. // Note that grid.Cells gets the top-level cells only, and // grid.GetCells() recursively gets the bottom-level individual cells. var cells = grid.GetCells(); // Get lines representing each cell var lines = cells.Select(c => c.GetCellGeometry()).OfType <Line>(); // Create walls from lines, and assign a random color material List <Wall> walls = new List <Wall>(); var rand = new Random(); foreach (var wallLine in lines) { var color = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble(), 1.0); walls.Add(new StandardWall(wallLine, 0.1, 3.0, new Material(color.ToString(), color, 0, 0, null, false, false))); } // Create rectangles from top-level grid cells var topLevelCells = grid.Cells.Select(c => c.GetCellGeometry()).OfType <Line>(); var cellRects = new List <ModelCurve>(); foreach (var topLevelCell in topLevelCells) { var rect = Polygon.Rectangle(topLevelCell.Start - new Vector3(0, 2, 0), topLevelCell.End + new Vector3(0, 2, 0)); cellRects.Add(new ModelCurve(rect)); } // </example> this.Model.AddElements(cellRects); this.Model.AddElements(walls); }
public void AlreadySplitGridsThrowsExceptionWhenDividedByN() { var grid = new Grid1d(); grid.SplitAtParameter(0.25); var ex = Assert.Throws <Exception>(() => grid.DivideByCount(10)); Assert.Equal("This grid already has subdivisions. Maybe you meant to select a subgrid to divide?", ex.Message); }
public void DivideFromPosition() { var grid = new Grid1d(new Domain1d(-8, 8)); grid.DivideByFixedLengthFromPosition(20, 10); Assert.Null(grid.Cells); // this should have been left undivided grid.DivideByFixedLengthFromPosition(4, 0); Assert.Equal(4, grid.Cells.Count); }
public void SplitAtOffset() { var grid = new Grid1d(30); grid.SplitAtOffset(5); grid.SplitAtOffset(5, true); Assert.Equal(5, grid.Cells[0].Domain.Length); Assert.Equal(20, grid.Cells[1].Domain.Length); Assert.Equal(5, grid.Cells[2].Domain.Length); }
public void ChildGridUpdatesParent() { var u = new Grid1d(10); var v = new Grid1d(5); var grid2d = new Grid2d(u, v); Assert.Single(grid2d.CellsFlat); grid2d.U.DivideByCount(10); grid2d.V.DivideByCount(5); Assert.Equal(50, grid2d.CellsFlat.Count); }
public void SplitAtPositions() { var positions = new[] { 3.0, 8, 5, 4 }; var grid = new Grid1d(10); grid.SplitAtPositions(positions); Assert.Equal(5, grid.Cells.Count); Assert.Equal(1, grid[1].Domain.Length); grid.SplitAtPosition(8); // should do nothing but not throw an error Assert.Equal(5, grid.Cells.Count); }
public void DivideGridFromOrigin() { var grid1 = new Grid1d(10); grid1.DivideByFixedLengthFromPosition(3, 5); var cellGeo = grid1.GetCells().Select(c => c.GetCellGeometry()); Assert.Equal(4, cellGeo.Count()); Assert.Equal(2, cellGeo.Last().Length()); Assert.Equal(3, cellGeo.ToArray()[1].Length()); }
public void PatternTooLongThrowsException() { var grid = new Grid1d(4); var pattern = new List <(string, double)> { ("Solid", 1), ("Glazing", 3), ("Fin", 0.2) }; Exception ex = Assert.Throws <ArgumentException>(() => grid.DivideByPattern(pattern, PatternMode.None, FixedDivisionMode.RemainderAtBothEnds)); Assert.Equal("The grid could not be constructed. Pattern length exceeds grid length.", ex.Message); }
public void SplitGridAtParameters() { var grid = new Grid1d(new Domain1d(50, 100)); grid.SplitAtParameter(0.25); var subCell = grid.Cells[1]; subCell.DivideByCount(5); subCell.Cells[3].DivideByApproximateLength(1.2, EvenDivisionMode.Nearest); var allCells = grid.GetCells(); var cellGeometry = allCells.Select(c => c.GetCellGeometry()); Assert.Equal(11, allCells.Count); }
public void Grid1dApproximateLength() { var grid1 = new Grid1d(10.5); var grid2 = new Grid1d(10.5); var grid3 = new Grid1d(10.2); grid1.DivideByApproximateLength(6, EvenDivisionMode.Nearest); Assert.Equal(2, grid1.Cells.Count); grid2.DivideByApproximateLength(4, EvenDivisionMode.RoundUp); Assert.Equal(3, grid2.Cells.Count); grid3.DivideByApproximateLength(1, EvenDivisionMode.RoundDown); Assert.Equal(10, grid3.Cells.Count); }
private void AddEdge(long key, long startVertexId, long endVertexId) { if (this.Points.TryGetValue(startVertexId, out var start) && this.Points.TryGetValue(endVertexId, out var end)) { var dist = start.DistanceTo(end); var line = new Line(start, end); if (!SkipSubdivide && dist > DivisionLength && (start.X != end.X || start.Y != end.Y)) { var indices = new List <long>() { startVertexId }; var grid = new Grid1d(line); grid.DivideByFixedLength(DivisionLength, FixedDivisionMode.RemainderAtBothEnds); var cells = grid.GetCells(); // Get lines representing each 10' cell var cellLines = cells.Select(c => c.GetCellGeometry()).OfType <Line>().ToArray(); // Add end of each division except for last point foreach (var cellLine in cellLines.SkipLast(1)) { var index = this._maxVertexKey + 1; var point = cellLine.PointAt(1.0); this.Points.Add(index, point); indices.Add(index); this._maxVertexKey = index; } // Add right point indices.Add(endVertexId); this.Lines.Add(key, indices); } else { this.Lines.Add(key, new List <long>() { startVertexId, endVertexId }); } } else { throw new Exception("Malformed geometry found: no vertex found at address for this edge."); } }
public void SplitAtPositionsInRightPlace() { var simpleLine = new Line(Vector3.Origin, new Vector3(10, 0, 0)); var lineGrid = new Grid1d(simpleLine); var splitLocation = new Vector3(3, 0, 0); lineGrid.SplitAtPoint(splitLocation); Assert.True(lineGrid[0].GetCellGeometry().PointAt(1.0).DistanceTo(splitLocation) < 0.01); var polyline = new Polyline(new[] { Vector3.Origin, new Vector3(3, 5), new Vector3(6, 2), new Vector3(10, -3) }); var polylineGrid = new Grid1d(polyline); var polylineSplitLocation = new Vector3(3, 5); polylineGrid.SplitAtPoint(polylineSplitLocation); Assert.True(polylineGrid[0].GetCellGeometry().PointAt(1.0).DistanceTo(polylineSplitLocation) < 0.01); }
public void GetSeparators() { var grid = new Grid1d(100); grid.DivideByCount(5); var pts = grid.GetCellSeparators(); Assert.Equal(6, pts.Count); Assert.Equal(pts[0], new Vector3(0, 0, 0)); Assert.Equal(pts[1], new Vector3(20, 0, 0)); Assert.Equal(pts[5], new Vector3(100, 0, 0)); grid[1].DivideByCount(3); var pts2 = grid.GetCellSeparators(true); Assert.Equal(8, pts2.Count); }
public void Grid1dSerializes() { var polyline = new Polyline(new[] { new Vector3(0, 0, 0), new Vector3(10, 2, 0), new Vector3(30, 4, 0), }); var grid = new Grid1d(polyline); grid.DivideByCount(4); grid[3].DivideByFixedLength(0.4); var json = JsonConvert.SerializeObject(grid); var deserialized = JsonConvert.DeserializeObject <Grid1d>(json); Assert.Equal(grid.GetCells().Count, deserialized.GetCells().Count); Assert.Equal(0, (grid.Curve as Polyline).Start.DistanceTo((deserialized.Curve as Polyline).Start)); }
public void DivideByPatternWithoutRemainder() { var grid = new Grid1d(6); var pattern = new List <(string typename, double length)> { ("A", 2), ("B", 1) }; grid.DivideByPattern(pattern, PatternMode.Cycle, FixedDivisionMode.RemainderAtEnd); var cells = grid.GetCells(); for (int i = 0; i < cells.Count; i++) { Assert.Equal(pattern[i % pattern.Count].typename, cells[i].Type); Assert.Equal(pattern[i % pattern.Count].length, cells[i].Domain.Length, 3); } }
public void DivideByPattern() { var grid = new Grid1d(new Domain1d(60, 150)); var pattern = new List <(string typename, double length)> { ("Solid", 1), ("Glazing", 3), ("Fin", 0.2) }; grid.DivideByPattern(pattern, PatternMode.Cycle, FixedDivisionMode.RemainderAtBothEnds); var cells = grid.GetCells(); var types = cells.Select(c => c.Type); for (int i = 0; i < 10; i++) { Assert.Equal(pattern[i % pattern.Count].length, cells[i + 1].Domain.Length, 3); Assert.Equal(pattern[i % pattern.Count].typename, cells[i + 1].Type); } }
/// <summary> /// The BallonaBridge function. /// </summary> /// <param name="model">The input model.</param> /// <param name="input">The arguments to the execution.</param> /// <returns>A BallonaBridgeOutputs instance containing computed results and the model with any new elements.</returns> public static BallonaBridgeOutputs Execute(Dictionary <string, Model> inputModels, BallonaBridgeInputs input) { /// Your code here. var output = new BallonaBridgeOutputs(1.0); Elements.Material brdigeMaterial = null; switch (input.Material) { case Material.Red: brdigeMaterial = new Elements.Material("Red", Colors.Red, 0.0f, 0.0f); break; case Material.Steel: brdigeMaterial = BuiltInMaterials.Steel; break; case Material.Wood: brdigeMaterial = BuiltInMaterials.Wood; break; } var beam = new Beam(input.CenterLine, Polygon.Rectangle(input.BridgeWidth, input.BridgeHeight), brdigeMaterial); var offsetCrv = input.CenterLine.Offset(5, EndType.Square); // output.model.AddElement(offsetCrv); var grid = new Grid1d(offsetCrv[0]); grid.DivideByApproximateLength(1.0); foreach (var pt in grid.GetCellSeparators()) { var column = new Column(pt, 5, Polygon.Rectangle(0.05, 0.05)); output.model.AddElement(column); } output.model.AddElement(beam); return(output); }
public void TryToSplitButAlreadySplitAtLowerLevel() { //var grid = new Grid1d(100); //grid.DivideByCount(2); //now split at 50 //grid[1].SplitAtParameter(0.5); // splitting child cell at halfway mark = 75 on the parent //grid.SplitAtPosition(75); // should silently do nothing. //Assert.Equal(3, grid.GetCells().Count); var grid2 = new Grid1d(256); grid2.DivideByCount(2); //split at 128 grid2[0].DivideByCount(2); // split at 64 grid2[0][0].DivideByCount(2); // split at 32 grid2[0][0][0].DivideByCount(2); // split at 16 grid2.SplitAtPosition(32); Assert.Equal(5, grid2.GetCells().Count); Assert.Equal(3, grid2.Cells.Count); Assert.Single(grid2[0].Cells); Assert.Equal(2, grid2[1].Cells.Count); Assert.Single(grid2[0][0].Cells); Assert.Equal(2, grid2[0][0][0].Cells.Count); }
/// <summary> /// Construct a set of elements from this rule for a given definition. /// </summary> /// <param name="definition">The definition to instantiate.</param> public List <Element> Instantiate(ComponentDefinition definition) { var arrayElements = new List <Element>(); var newVertices = PolylinePlacementRule.TransformPolyline(this, definition); var path = IsClosed ? new Polygon(newVertices) : new Polyline(newVertices); var grid1d = new Grid1d(path); switch (SpacingRule.SpacingMode) { case SpacingMode.ByLength: grid1d.DivideByFixedLength(SpacingRule.Value); break; case SpacingMode.ByApproximateLength: grid1d.DivideByApproximateLength(SpacingRule.Value); break; case SpacingMode.ByCount: grid1d.DivideByCount((int)SpacingRule.Value); break; } var separators = grid1d.GetCellSeparators(); foreach (var sep in separators) { ElementDefinition.IsElementDefinition = true; var transform = new Transform(definition.OrientationGuide); transform.Concatenate(new Transform(sep)); var instance = ElementDefinition.CreateInstance(transform, Guid.NewGuid().ToString()); arrayElements.Add(instance); } return(arrayElements); }
/** * Does the computation */ protected override void SolveRabbitInstance(IGH_DataAccess DA) { List <GH_Point> pointsList = new List <GH_Point>(); DA.GetDataList(1, pointsList); int XDimension = pointsList.Count; IList <Point3d> genericPoints = GH_PointUtils.ConvertToOnPoints(pointsList); //Get the cell prototype------------------------------------------------------------ GH_ObjectWrapper cellPrototypeWrapper = null; DA.GetData <GH_ObjectWrapper>(0, ref cellPrototypeWrapper); ICell cellPrototype = (ICell)cellPrototypeWrapper.Value; //---------------------------------------------------------------------------------- List <GH_ObjectWrapper> stateConfigurations = new List <GH_ObjectWrapper>(); DA.GetDataList(2, stateConfigurations); GH_ObjectWrapper stateConfigWrapper1; OnStateConfig stateConfig = null; foreach (GH_ObjectWrapper stateConfigWrapper in stateConfigurations) { if (stateConfigWrapper != null)// Custom configuration defined { if (stateConfigWrapper.Value.GetType() == typeof(OnStateConfig)) { stateConfig = (OnStateConfig)stateConfigWrapper.Value; //get the user-defined points that define custom Cell State IList <Point3d> userConfigurationGHPoints = stateConfig.GetPoints(); //get the real configuration points, by finding the points that are closer to the user defined configuration points IList <Point3d> realConfigurationPoints = PointUtils.GetClosestPoints(userConfigurationGHPoints, genericPoints); stateConfig.SetPoints(realConfigurationPoints); } } } //---------------------------------------------------------------------------------- //build the grid Grid1d <ICell> space1d = new Grid1d <ICell>(XDimension); CellState ghAliveState = new GH_CellState(new GH_Boolean(true)); CellState ghDeadState = new GH_CellState(new GH_Boolean(false)); //populate the grid for (int i = 0; i < XDimension; i++) { ICell cell = cellPrototype.Clone(); cell.SetId(i);//very important as this identifies the cell if (stateConfig != null) { foreach (Point3d configurationPoint in stateConfig.GetPoints()) { if (pointsList[i].Value.X == configurationPoint.X && pointsList[i].Value.Y == configurationPoint.Y && pointsList[i].Value.Z == configurationPoint.Z) { cell.SetState(stateConfig.GetState()); } } } cell.SetAttachedObject(pointsList[i]); space1d.Add(cell, i); } //build neighborhood for (int i = 0; i < XDimension; i++) { ElementaryCell cell = (ElementaryCell)space1d.GetObjectAt(i); //IList<ICell> neighbors = new List<ICell>(2); if (i > 0) { cell.SetLeftNeighbor((ElementaryCell)space1d.GetObjectAt(i - 1));//neighbors.Add(cells[(i - 1)%XDimension]); } else if (i == 0) { cell.SetLeftNeighbor((ElementaryCell)space1d.GetObjectAt(XDimension - 1));//neighbors.Add(cells[(i - 1)%XDimension]); } if (i < XDimension - 1) { cell.SetRightNeighbor((ElementaryCell)space1d.GetObjectAt(i + 1));//neighbors.Add(cells[(i + 1)%XDimension]); } else if (i == XDimension - 1) { cell.SetRightNeighbor((ElementaryCell)space1d.GetObjectAt(0)); } } CA ca = new CA(space1d); //set the output parameters DA.SetData(0, ca); }
/// <summary> /// The Testfunction1 function. /// </summary> /// <param name="model">The input model.</param> /// <param name="input">The arguments to the execution.</param> /// <returns>A Testfunction1Outputs instance containing computed results and the model with any new elements.</returns> public static Testfunction1Outputs Execute(Dictionary <string, Model> inputModels, Testfunction1Inputs input) { /// Your code here. var output = new Testfunction1Outputs(1.0); List <ModelCurve> modelCurves = new List <ModelCurve>(); List <Curve> Curves = new List <Curve>(); Elements.Material brdigeMaterial = null; switch (input.Material) { case Material.Red: brdigeMaterial = new Elements.Material("Red", Colors.Red, 0.0f, 0.0f); break; case Material.Steel: brdigeMaterial = BuiltInMaterials.Steel; break; case Material.Wood: brdigeMaterial = BuiltInMaterials.Wood; break; } var profile = WideFlangeProfileServer.Instance.GetProfileByType(WideFlangeProfileType.W10x100); var pts = new List <Vector3>(); var centerCrv = input.CenterLine; var offsetCrv = input.CenterLine.Offset(input.OffsetWidth, EndType.Square)[0]; var offsetCrv2 = input.CenterLine.Offset(input.OffsetWidth / 2, EndType.Square)[0]; var rebuildOffsetCrv = new Polygon(offsetCrv.Vertices); var LGon = Polygon.L(15, 15, 5); var ltransform = new Transform(15, 0, 0); List <Polygon> testPoly = new List <Polygon>(); testPoly.AddRange(new[] { rebuildOffsetCrv, Polygon.Rectangle(15, 15), ltransform.OfPolygon(LGon) }); foreach (var poly in testPoly) { var beam = new Beam(poly, Polygon.Rectangle(input.BridgeWidth, input.BridgeHeight), brdigeMaterial); // var beam = new Beam(poly, profile, brdigeMaterial); output.Model.AddElement(beam); var grid = new Grid1d(poly); grid.DivideByApproximateLength(3); foreach (var pt in grid.GetCellSeparators()) { var column = new Column(pt, 5, Polygon.Rectangle(0.1, 0.1)); output.Model.AddElement(column); } } var secLine = new Line(new Vector3(-input.OffsetWidth * 2, 0, 0), new Vector3(input.OffsetWidth * 2, 0, 0)); // List<Plane> planes = new List<Plane>(); List <Line> secLines = new List <Line>(); var crvSegments = centerCrv.Segments(); foreach (var crv in crvSegments) { var grid = new Grid1d(crv); grid.DivideByApproximateLength(3); foreach (var pt in grid.GetCellSeparators()) { // planes.Add(new Plane(pt, Vector3.XAxis(pt))) // pts.Add(pt); var transform = new Transform(pt, crv.Direction()); secLines.Add(transform.OfLine(secLine)); // planes.Add(new Plane(pt, crv.Direction())); var column = new Column(pt, 5, Polygon.Rectangle(0.1, 0.1)); output.Model.AddElement(column); } } Curves.AddRange(new[] { centerCrv, offsetCrv, (Curve)secLine }); Curves.AddRange(secLines); foreach (var crv in Curves) { modelCurves.Add(new ModelCurve(crv)); } // var pink = new Elements.Material("pink", Colors.Pink); // var modelPoints = new ModelPoints(pts, pink); // var crvs = new List<Curve>{Polygon.Rectangle(10,10), offsetCrv[0]}; // foreach(var crv in crvs) { // modelCurves.Add(new ModelCurve(crv)); // var grid = new Grid1d(crv); // grid.DivideByApproximateLength(1.0); // foreach(var pt in grid.GetCellSeparators()) // { // var column = new Column(pt, 5, Polygon.Rectangle(0.05, 0.05)); // output.Model.AddElement(column); // } // } // output.Model.AddElements(modelPoints); output.Model.AddElements(modelCurves); // output.Model.AddElement(beam); return(output); }
/// <summary> /// The BigBoxFacade function. /// </summary> /// <param name="model">The input model.</param> /// <param name="input">The arguments to the execution.</param> /// <returns>A BigBoxFacadeOutputs instance containing computed results and the model with any new elements.</returns> public static BigBoxFacadeOutputs Execute(Dictionary <string, Model> inputModels, BigBoxFacadeInputs input) { Envelope envelope = null; inputModels.TryGetValue("Envelope", out var envelopeModel); if (envelopeModel != null) { var envelopes = new List <Envelope>(); envelopes.AddRange(envelopeModel.AllElementsOfType <Envelope>()); var aboveGradeEnvelopes = envelopes.Where(e => e.Elevation >= 0.0).ToList(); if (aboveGradeEnvelopes.Count() > 0) { envelope = aboveGradeEnvelopes.First(); } } if (envelope == null) { var envMatl = new Material("envelope", new Color(1.0, 1.0, 1.0, 0.2), 0.0f, 0.0f); var height = 15.0; var footprint = Polygon.Rectangle(60, 40); var extrude = new Elements.Geometry.Solids.Extrude(footprint, height, Vector3.ZAxis, false); var geomRep = new Representation(new List <Elements.Geometry.Solids.SolidOperation>() { extrude }); envelope = new Envelope(footprint, 0.0, height, Vector3.ZAxis, 0.0, new Transform(), envMatl, geomRep, false, Guid.NewGuid(), ""); } var output = new BigBoxFacadeOutputs(envelope.Profile.Perimeter.Area()); var boundarySegments = envelope.Profile.Perimeter.Segments(); var panelMat = new Material("envelope", new Color(1.0, 1.0, 1.0, 1), 0.5f, 0.5f); var lowestSegment = boundarySegments.OrderBy((s) => s.Start.Average(s.End).Y).First(); foreach (var s in boundarySegments) { var d = s.Direction(); try { var t = new Transform(s.Start + new Vector3(0, 0, 0), d, d.Cross(Vector3.ZAxis)); var l = s.Length(); if (lowestSegment == s) { var grid = new Grid1d(s); var doorWidth = 4; var backwardsLine = s.Start.X > s.End.X; var reverseDirection = backwardsLine != input.EntranceOnRight; var leftDoor = 0.0; var rightDoor = 0.0; var leftDoorWidth = 0.0; var rightDoorWidth = 0.9; if (reverseDirection) { leftDoor = l / 10 * 2; rightDoor = l / 10 * 6; leftDoorWidth = doorWidth; rightDoorWidth = doorWidth * 2.0; } else { leftDoor = l / 10 * 4; rightDoor = l / 10 * 8; leftDoorWidth = doorWidth * 2.0; rightDoorWidth = doorWidth; } grid.SplitAtPositions(new [] { leftDoor - leftDoorWidth / 2.0, leftDoor + leftDoorWidth / 2.0, rightDoor - rightDoorWidth / 2.0, rightDoor + rightDoorWidth / 2.0 }); var lines = grid.GetCells().Select(c => c.GetCellGeometry()).OfType <Line>(); if (reverseDirection) { lines = lines.Reverse(); } var wallIdx = 0; foreach (var wallLine in lines) { var segmentLength = wallLine.Length(); var segmentTransform = new Transform(wallLine.Start + new Vector3(0, 0, 0), d, d.Cross(Vector3.ZAxis)); if (wallIdx == 1) { CreateStandardPanel(segmentLength, 6, envelope.Height - 6, 0.1, segmentTransform, panelMat, out FacadePanel panel); output.model.AddElement(panel); CreateBranding(envelope.Height, 10, 28, true, new Transform(wallLine.Start.Average(wallLine.End), Vector3.ZAxis, 0), output.model); } else if (wallIdx == 3) { CreateStandardPanel(segmentLength, 6, envelope.Height - 6, 0.1, segmentTransform, panelMat, out FacadePanel panel); output.model.AddElement(panel); CreateBranding(envelope.Height * 0.7, 5.5, 6, false, new Transform(wallLine.Start.Average(wallLine.End), Vector3.ZAxis, 0), output.model); } else { CreateStandardPanel(segmentLength, 0, envelope.Height, 0.1, segmentTransform, panelMat, out FacadePanel panel); output.model.AddElement(panel); } wallIdx++; } } else { CreateStandardPanel(l, 0, envelope.Height, 0.1, t, panelMat, out FacadePanel panel); output.model.AddElement(panel); } var parapetLine = new Line(new Vector3(s.Start.X, s.Start.Y, envelope.Height), new Vector3(s.End.X, s.End.Y, envelope.Height)); var parapet = new StandardWall(parapetLine, 0.4, 0.9, panelMat); output.model.AddElement(parapet); } catch (System.Exception ex) { System.Console.WriteLine(ex); } } return(output); }
private static List <WallPanel> ProcessWallsAndStandardWalls(PanelsFromWallsInputs input, List <Wall> allWalls, out int totalCount, out int uniqueCount, out int nonStandardCount) { var wallCenterlines = allWalls.Select(TryGetCenterlineFromWall).Where(s => s != null); var endPoints = wallCenterlines.SelectMany(l => new[] { l.Start, l.End }); var network = new Network(wallCenterlines); Dictionary <Elements.Spatial.Edge, Grid1d> edgeGrids = new Dictionary <Elements.Spatial.Edge, Grid1d>(); foreach (var edge in network.Edges) { var edgeLine = network.GetEdgeLine(edge); var grid = new Grid1d(edgeLine); edgeGrids.Add(edge, grid); var cornerAtStart = network[edge.From].Valence > 1; var cornerAtEnd = network[edge.To].Valence > 1; var cornerCount = (cornerAtStart ? 1 : 0) + (cornerAtEnd ? 1 : 0); var cornerLength = input.CornerLength; if (cornerLength * cornerCount > edgeLine.Length()) { cornerLength = edgeLine.Length() / cornerCount; } if (cornerAtStart) { grid.SplitAtOffset(cornerLength); } if (cornerAtEnd) { grid.SplitAtOffset(cornerLength, true); } Grid1d gridToSubdivide = null; if (!grid.IsSingleCell) { switch (grid.Cells.Count) { case 3: gridToSubdivide = grid[1]; break; case 2: if (cornerCount == 1) { if (cornerAtStart) { gridToSubdivide = grid[1]; } if (cornerAtEnd) { gridToSubdivide = grid[0]; } } break; default: gridToSubdivide = grid; break; } if (gridToSubdivide != null) { gridToSubdivide.DivideByFixedLength(input.PanelLength, FixedDivisionMode.RemainderAtEnd); } } } List <Line> lines = new List <Line>(); foreach (var edgeGrid in edgeGrids) { if (edgeGrid.Value == null) { continue; } var cells = edgeGrid.Value.IsSingleCell ? new List <Grid1d> { edgeGrid.Value } : edgeGrid.Value.GetCells(); var cellGeometry = cells.Select(c => c.GetCellGeometry()).OfType <Line>(); lines.AddRange(cellGeometry); } // Create walls from lines, and assign a random color material var walls = new List <WallPanel>(); var rand = new Random(); var colorMap = new Dictionary <int, Color>(); colorMap.Add(KeyFromLength(input.CornerLength), Colors.Red); if (input.CornerLength != input.PanelLength) { colorMap.Add(KeyFromLength(input.PanelLength), Colors.Blue); } foreach (var wallLine in lines) { var color = default(Color); var lengthKey = KeyFromLength(wallLine.Length()); if (colorMap.ContainsKey(lengthKey)) { color = colorMap[lengthKey]; } else { color = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble(), 1.0); colorMap.Add(lengthKey, color); } var mat = input.ColorCodeByLength ? new Material(color, 0, 0, false, null, true, Guid.NewGuid(), color.ToString()) : BuiltInMaterials.Concrete; walls.Add(CreateSimpleWallPanel(wallLine, 0.1, 3.0, mat)); } nonStandardCount = lines.Where(l => KeyFromLength(l.Length()) != KeyFromLength(input.PanelLength) && KeyFromLength(l.Length()) != KeyFromLength(input.CornerLength)).Count(); totalCount = walls.Count; uniqueCount = Math.Min(totalCount, colorMap.Count()); return(walls); }