/// <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);
}
