/// <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 = new Polygon(newVertices); var grid2d = new Grid2d(path, definition.OrientationGuide); GridCreationRule(grid2d); var cells = grid2d.GetCells().Where(c => !c.IsTrimmed()).SelectMany(c => c.GetTrimmedCellGeometry()).OfType <Polygon>().Where(c => c.Area().ApproximatelyEquals(CellDefinition.CellLength * CellDefinition.CellWidth)); foreach (var element in CellDefinition.Elements) { foreach (var cell in cells) { var transform = new Transform(element.Transform); transform.Concatenate(definition.OrientationGuide); transform.Concatenate(new Transform(cell.Vertices[2])); element.IsElementDefinition = true; var instance = element.CreateInstance(transform, null); arrayElements.Add(instance); } } arrayElements.AddRange(cells.Select(c => new ModelCurve(c))); return(arrayElements); }
/// <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 transformedVertices = PolylinePlacementRule.TransformPolyline(this, definition); var newVertices = AnchorTransformer == null ? transformedVertices : AnchorTransformer(transformedVertices); return(Component.Instantiate(newVertices).Instances); }
/// <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 transformedCurves = new List <Element>(); List <Vector3> newVertices = TransformPolyline(this, definition); transformedCurves.Add(new ModelCurve(IsPolygon ? new Polygon(newVertices) : new Polyline(newVertices))); return(transformedCurves); }
/// <summary> /// Construct a new ComponentPlacementRule from scratch. /// </summary> /// <param name="component">The component to place.</param> /// <param name="polyline">The polyline boundary used to determine placement.</param> /// <param name="anchorIndices">For each vertex, the index of the corresponding anchor.</param> /// <param name="anchorDisplacements">For each vertex, the displacement from its anchor.</param> /// <param name="name">The name.</param> /// <param name="anchorTransformer">An optional function to tweak anchor placement.</param> public ComponentPlacementRule(ComponentDefinition component, Polyline polyline, IList <int> anchorIndices, IList <Vector3> anchorDisplacements, string name, Func <List <Vector3>, List <Vector3> > anchorTransformer = null) { Component = component; Curve = polyline; AnchorIndices = anchorIndices; AnchorDisplacements = anchorDisplacements; Name = name; AnchorTransformer = anchorTransformer; }
/// <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 t = GenerateTransform(definition.OrientationGuide, definition.ReferenceAnchors, definition.AnchorDisplacements); List <Element> instances = new List <Element>(); Definition.IsElementDefinition = true; instances.Add(Definition.CreateInstance(t, this.Name)); return(instances); }
/// <summary> /// Create a component placement rule by associating anchors with the closest vertex on the bounding polyline. /// </summary> /// <param name="component">The component to place.</param> /// <param name="polyline">The polyline boundary used to determine placement.</param> /// <param name="Anchors">The reference anchors from which to calculate the associations.</param> /// <param name="name">The name of the rule.</param> /// <param name="anchorTransformer">An optional function to tweak anchor placement.</param> public static IComponentPlacementRule FromClosestPoints(ComponentDefinition component, Polyline polyline, IList <Vector3> Anchors, string name, Func <List <Vector3>, List <Vector3> > anchorTransformer = null) { var anchorIndices = new List <int>(); var anchorDisplacements = new List <Vector3>(); foreach (var v in polyline.Vertices) { var closestAnchorIndex = Enumerable.Range(0, Anchors.Count).OrderBy(a => Anchors[a].DistanceTo(v)).First(); anchorIndices.Add(closestAnchorIndex); var closestAnchor = Anchors[closestAnchorIndex]; anchorDisplacements.Add(v - closestAnchor); } return(new ComponentPlacementRule(component, polyline, anchorIndices, anchorDisplacements, name, anchorTransformer)); }
/// <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); }
internal static List <Vector3> TransformPolyline(ICurveBasedComponentPlacementRule rule, ComponentDefinition definition) { var newVertices = new List <Vector3>(); for (int i = 0; i < rule.Curve.Vertices.Count; i++) { var anchorIndex = rule.AnchorIndices[i]; var anchorForVertex = definition.ReferenceAnchors[anchorIndex]; var displacementForVertex = definition.AnchorDisplacements[anchorIndex]; // transform from reference anchor to polyline vertex var transform = new Transform(definition.OrientationGuide.OfVector(rule.AnchorDisplacements[i])); transform.Concatenate(new Transform(displacementForVertex)); newVertices.Add(transform.OfPoint(anchorForVertex)); } return(newVertices); }