/// <summary>
/// Returns a list of desk Revit family instances using the Desk stored in the DeskArrangement.
/// </summary>
/// <param name="deskArrangement"> The DeskArrangement object.</param>
/// <param name="deskType"> The desk type.</param>
/// <param name="hostLevel"> The host hostLevel for the new desks.</param>
public static List <DynamoElement> Generate(DeskArrangement deskArrangement, DynamoFamilyType deskType, DynamoLevel hostLevel)
{
Document doc = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(doc);
FamilySymbol newDeskType = FamilyTypeCreator.Desk((FamilySymbol)deskType.InternalElement, deskArrangement, "AU 2019 Vegas Desk");
// Get the Revit Document factory object from the Autodesk.Revit.DB.Creation namespace.
// This object is used to instantiate most Revit Elements.
var revitFactory = doc.Create;
var revitDesks = new List <DynamoElement>();
foreach (var desk in deskArrangement.Desks)
{
XYZ location = desk.Origin.ToXyz();
var familyInstance = revitFactory.NewFamilyInstance(location, newDeskType, hostLevel.InternalElement, StructuralType.NonStructural);
// Wrap and bind the new desk instance.
revitDesks.Add(familyInstance.ToDSType(false));
}
TransactionManager.Instance.TransactionTaskDone();
return(revitDesks);
}
public static Element ByFaceAndPoint(FamilyType familyType, Point point, Surface surface)
{
if (familyType == null)
{
throw new ArgumentNullException(nameof(familyType));
}
if (point == null)
{
throw new ArgumentNullException(nameof(point));
}
if (surface == null)
{
throw new ArgumentNullException(nameof(surface));
}
var symbol = familyType.InternalElement as Autodesk.Revit.DB.FamilySymbol;
var pt = point.ToRevitType();
var reference = surface.Tags.LookupTag("RevitFaceReference") as Autodesk.Revit.DB.Reference;
var faceNormal = surface.NormalAtPoint(point);
var up = Vector.ZAxis();
Autodesk.Revit.DB.XYZ referenceDir;
if (Math.Abs(faceNormal.Dot(up)) > 0.9999) // horizontal
{
referenceDir = Autodesk.Revit.DB.XYZ.BasisX;
}
else
{
referenceDir = faceNormal.Cross(up).ToXyz();
}
return(new FamilyInstances(symbol, pt, reference, referenceDir).InternalElement.ToDSType(true));
}
public void ByPoints_PointArray_ProducesValidAdaptiveComponentAndLocations()
{
var pts = new Point[][]
{
new Point[]
{
Point.ByCoordinates(0, 0, 0),
Point.ByCoordinates(10, 0, 10),
Point.ByCoordinates(20, 0, 0)
}
};
var fs = FamilyType.ByName("3PointAC");
var ac = AdaptiveComponent.ByPoints(pts, fs);
var locs = ac.First().Locations;
var pairs = locs.Zip(pts.First(), (point, point1) => new Tuple <Point, Point>(point, point1));
// compares after unit conversion
foreach (var pair in pairs)
{
pair.Item1.ShouldBeApproximately(pair.Item2);
}
var unconvertedPairs = pts.First().Zip(GetInternalPoints((FamilyInstance)ac.First().InternalElement),
(point, point1) => new Tuple <Point, XYZ>(point, point1));
foreach (var pair in unconvertedPairs)
{
pair.Item1.ShouldBeApproximately(pair.Item2 * UnitConverter.HostToDynamoFactor(SpecTypeId.Length));
}
Assert.NotNull(ac);
}
/// <summary>
/// Create a column.
/// </summary>
/// <param name="curve">The curve which defines the center line of the column.</param>
/// <param name="level">The level with which you'd like the column to be associated.</param>
/// <param name="structuralColumnType">The structural column type representing the column.</param>
/// <returns></returns>
public static StructuralFraming ColumnByCurve(
Autodesk.DesignScript.Geometry.Curve curve, Level level, FamilyType structuralColumnType)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if (level == null)
{
throw new ArgumentNullException("level");
}
if (structuralColumnType == null)
{
throw new ArgumentNullException("structuralColumnType");
}
var start = curve.PointAtParameter(0);
var end = curve.PointAtParameter(1);
// Revit will throw an exception if you attempt to create a column whose
// base is above its top.
if (end.Z <= start.Z)
{
throw new Exception(Properties.Resources.InvalidColumnBaseLocation);
}
return(new StructuralFraming(curve.ToRevitType(), level.InternalLevel, Autodesk.Revit.DB.Structure.StructuralType.Column, structuralColumnType.InternalFamilySymbol));
}
public void Rotate_ZAxis()
{
var famSym = FamilyType.ByName("Box");
var pt = Point.ByCoordinates(0, 1, 2);
var famInst = FamilyInstance.ByPoint(famSym, pt);
Assert.NotNull(famInst);
var transform = famInst.InternalFamilyInstance.GetTransform();
double[] rotationAngles;
TransformUtils.ExtractEularAnglesFromTransform(transform, out rotationAngles);
Assert.AreEqual(0.0, rotationAngles[0]);
RevitServices.Persistence.DocumentManager.Instance.CurrentDBDocument.Regenerate();
famInst.SetRotation(30);
transform = famInst.InternalFamilyInstance.GetTransform();
TransformUtils.ExtractEularAnglesFromTransform(transform, out rotationAngles);
Assert.AreEqual(30.0, rotationAngles[0] * 180 / Math.PI, 1.0e-6);
famInst.SetRotation(60);
transform = famInst.InternalFamilyInstance.GetTransform();
TransformUtils.ExtractEularAnglesFromTransform(transform, out rotationAngles);
Assert.AreEqual(60.0, rotationAngles[0] * 180 / Math.PI, 1.0e-6);
}
public void ByParametersOnFace_CreatesValidACFromElementFaceReference()
{
var ele = ElementSelector.ByType <Autodesk.Revit.DB.Form>(true).FirstOrDefault();
Assert.NotNull(ele);
var form = ele as Form;
var faces = form.ElementFaceReferences;
Assert.IsTrue(faces.All(x => x != null));
Assert.AreEqual(6, faces.Length);
var ft = FamilyType.ByName("3PointAC");
var uvs = new[]
{
Autodesk.DesignScript.Geometry.UV.ByCoordinates(0, 0),
Autodesk.DesignScript.Geometry.UV.ByCoordinates(0.5, 0.5),
Autodesk.DesignScript.Geometry.UV.ByCoordinates(0.5, 0)
};
var ac = AdaptiveComponent.ByParametersOnFace(uvs, faces.First(), ft);
Assert.NotNull(ac);
}
/// <summary>
/// Set the family symbol for the internal family instance
/// </summary>
/// <param name="ft"></param>
private void InternalSetFamilySymbol(FamilyType ft)
{
TransactionManager.Instance.EnsureInTransaction(Document);
InternalFamilyInstance.Symbol = ft.InternalFamilySymbol;
TransactionManager.Instance.TransactionTaskDone();
}
/// <summary>
/// Place a Revit FamilyInstance given the FamilyType (also known as the FamilySymbol in the Revit API), it's coordinates in world space, and the Level
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <param name="point">Point in meters.</param>
/// <param name="level">Level to host Family Instance.</param>
/// <returns></returns>
public static FamilyInstance ByPointAndLevel(FamilyType familyType, Point point, Level level)
{
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
return(new FamilyInstance(familyType.InternalFamilySymbol, point.ToXyz(), level.InternalLevel));
}
/// <summary>
/// Place a Revit FamilyInstance given the FamilyType (also known as the FamilySymbol in the Revit API) and its coordinates in world space
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <param name="x">X coordinate in meters</param>
/// <param name="y">Y coordinate in meters</param>
/// <param name="z">Z coordinate in meters</param>
/// <returns></returns>
public static FamilyInstance ByCoordinates(FamilyType familyType, double x = 0, double y = 0, double z = 0)
{
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
var pt = Point.ByCoordinates(x, y, z);
return(ByPoint(familyType, pt));
}
public void ByPoints_ShouldThrowExceptionWithNonMatchingNumberOfPoints()
{
var pts = new Point[]
{
Point.ByCoordinates(0, 0, 0),
Point.ByCoordinates(10, 0, 10)
};
var ft = FamilyType.ByName("3PointAC");
Assert.Throws(typeof(ArgumentException), () => AdaptiveComponent.ByPoints(pts, ft));
}
public void FacingOrientation()
{
var famSym = FamilyType.ByName("Box");
var pt = Point.ByCoordinates(0, 1, 2);
var famInst = FamilyInstance.ByPoint(famSym, pt);
Assert.NotNull(famInst);
var dir = famInst.FacingOrientation;
dir.IsAlmostEqualTo(Vector.ByCoordinates(0.0, 0.0, 1.0));
}
/// <summary>
/// New Family Instance by Curve
/// </summary>
/// <param name="familyType">Family Type to be applied to new Family Instance.</param>
/// <param name="line">Line to place Family Instance at.</param>
/// <param name="level">Level to associate Family Instance with.</param>
/// <returns>New Family Instance.</returns>
public static Element ByLine(FamilyType familyType, Line line, Level level)
{
if (familyType == null)
{
throw new ArgumentNullException(nameof(familyType));
}
var symbol = familyType.InternalElement as Autodesk.Revit.DB.FamilySymbol;
var locationLine = line.ToRevitType() as Autodesk.Revit.DB.Line;
var hostLevel = level.InternalElement as Autodesk.Revit.DB.Level;
return(new FamilyInstances(symbol, locationLine, hostLevel));
}
/// <summary>
/// Obtain a collection of FamilyInstances from the Revit Document and use them in the Dynamo graph
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <returns></returns>
/// <search>
/// byfamilysymbol,ByFamilySymbol
/// </search>
public static FamilyInstance[] ByFamilyType(FamilyType familyType)
{
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
return(DocumentManager.Instance
.ElementsOfType <Autodesk.Revit.DB.FamilyInstance>()
.Where(x => x.Symbol.Id == familyType.InternalFamilySymbol.Id)
.Select(x => FromExisting(x, true))
.ToArray());
}
public void CanSuccessfullySetAndGetElement()
{
var wall = ElementSelector.ByElementId(184176, true);
var famSym = FamilyType.ByName("18\" x 18\"");
var name = "Column";
wall.SetParameterByName(name, famSym);
var sym = wall.GetParameterValueByName(name) as Element;
Assert.NotNull(sym);
Assert.AreEqual(sym.Name, "18\" x 18\"");
}
public static AdaptiveComponent[] ByPoints(Point[][] points, FamilyType familyType)
{
if (points == null)
{
throw new ArgumentNullException("points");
}
if (familyType == null)
{
throw new ArgumentNullException("familtType");
}
return(InternalByPoints(points, familyType));
}
/// <summary>
/// Place a Revit FamilyInstance given the FamilyType (also known as the FamilySymbol in the Revit API) and its coordinates in world space
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <param name="point">Point in meters.</param>
/// <returns></returns>
public static FamilyInstance ByPoint(FamilyType familyType, Point point)
{
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
if (point == null)
{
throw new ArgumentNullException("point");
}
return(new FamilyInstance(familyType.InternalFamilySymbol, point.ToXyz()));
}
public static Revit.Elements.FamilyInstance ChangeType(
Revit.Elements.FamilyInstance familyInstance,
Revit.Elements.FamilyType familyType)
{
// Unwrap input parameters
Autodesk.Revit.DB.FamilyInstance instance = familyInstance.InternalElement as Autodesk.Revit.DB.FamilyInstance;
Autodesk.Revit.DB.Element anotherType = familyType.InternalElement;
TransactionManager.Instance.EnsureInTransaction(DocumentManager.Instance.CurrentDBDocument);
instance.ChangeTypeId(anotherType.Id);
TransactionManager.Instance.TransactionTaskDone();
return(familyInstance);
}
/// <summary>
/// Place a Revit FamilyInstance given the FamilyType (also known as the FamilySymbol in the Revit API) and its coordinate system.
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <param name="coordinateSystem">Coordinates system to place the new family instance in.</param>
/// <returns>New family instance.</returns>
public static FamilyInstance ByCoordinateSystem(FamilyType familyType, CoordinateSystem coordinateSystem)
{
var transform = coordinateSystem.ToTransform() as Autodesk.Revit.DB.Transform;
double[] newRotationAngles;
TransformUtils.ExtractEularAnglesFromTransform(transform, out newRotationAngles);
double rotation = ConvertEularToAngleDegrees(newRotationAngles.FirstOrDefault());
Point location = transform.ToCoordinateSystem().Origin;
FamilyInstance familyInstance = ByPoint(familyType, location);
familyInstance.SetRotation(rotation);
return(familyInstance);
}
public void ByPointsOnCurve_ProducesValidAdaptiveComponentAndLocations()
{
// create spline
var pts = new Autodesk.DesignScript.Geometry.Point[]
{
Point.ByCoordinates(0, 0, 0),
Point.ByCoordinates(1, 0, 0),
Point.ByCoordinates(3, 0, 0),
Point.ByCoordinates(10, 0, 0),
Point.ByCoordinates(12, 0, 0),
};
var spline = NurbsCurve.ByControlPoints(pts, 3);
Assert.NotNull(spline);
// build model curve from spline
var modCurve = ModelCurve.ByCurve(spline);
Assert.NotNull(modCurve);
// obtain the family from the document
var ft = FamilyType.ByName("3PointAC");
// build the AC
var parms = new double[]
{
0, 0.5, 1
};
var ac = AdaptiveComponent.ByParametersOnCurveReference(parms, modCurve.ElementCurveReference, ft);
// with unit conversion
foreach (var pt in ac.Locations)
{
spline.DistanceTo(pt).ShouldBeApproximately(0);
}
// without unit conversion
var unconvertedPoints = GetInternalPoints((FamilyInstance)ac.InternalElement);
foreach (var pt in unconvertedPoints)
{
spline.DistanceTo(pt.ToPoint()).ShouldBeApproximately(0);
}
Assert.NotNull(ac);
}
public void ByCoordinates_ProducesValidFamilyInstanceWithCorrectLocation()
{
var famSym = FamilyType.ByName("Box");
var famInst = FamilyInstance.ByCoordinates(famSym, 0, 1, 2);
Assert.NotNull(famInst);
var position = famInst.Location;
position.ShouldBeApproximately(Point.ByCoordinates(0, 1, 2));
// no unit conversion
var internalPos =
InternalLocation(famInst.InternalElement as Autodesk.Revit.DB.FamilyInstance);
(internalPos * UnitConverter.HostToDynamoFactor(SpecTypeId.Length)).ShouldBeApproximately(
Point.ByCoordinates(0, 1, 2));
}
/// <summary>
/// Place a Revit family instance of the given the FamilyType (also known as the FamilySymbol in the Revit API)
/// on a surface derived from a backing Revit face as reference and a line as reference for its position.
///
/// Note: The FamilyPlacementType must be CurveBased and the input surface must be created from a Revit Face
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <param name="face">Surface geometry derived from a Revit face as reference element</param>
/// <param name="line">A line on the face defining where the symbol is to be placed</param>
/// <returns>FamilyInstance</returns>
public static FamilyInstance ByFace(FamilyType familyType, Surface face, Autodesk.DesignScript.Geometry.Line line)
{
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
if (face == null)
{
throw new ArgumentNullException("face");
}
if (line == null)
{
throw new ArgumentNullException("line");
}
var reference = ElementFaceReference.TryGetFaceReference(face);
return(new FamilyInstance(familyType.InternalFamilySymbol, reference.InternalReference, (Autodesk.Revit.DB.Line)line.ToRevitType()));
}
/// <summary>
/// Initialize an AdaptiveComponent element
/// </summary>
/// <param name="pts">Points to use as reference</param>
/// <param name="ft">familyType to place</param>
private void InitAdaptiveComponent(Point[] pts, FamilyType ft)
{
// if the family instance is present in trace...
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
// just mutate it...
if (oldFam != null)
{
InternalSetFamilyInstance(oldFam);
if (ft.InternalFamilySymbol.Id != oldFam.Symbol.Id)
{
InternalSetFamilySymbol(ft);
}
InternalSetPositions(pts.ToXyzs());
return;
}
// otherwise create a new family instance...
TransactionManager.Instance.EnsureInTransaction(Document);
using (Autodesk.Revit.DB.SubTransaction st = new SubTransaction(Document))
{
try
{
st.Start();
var fam = AdaptiveComponentInstanceUtils.CreateAdaptiveComponentInstance(Element.Document, ft.InternalFamilySymbol);
InternalSetFamilyInstance(fam);
InternalSetPositions(pts.ToXyzs());
st.Commit();
}
catch (Exception ex)
{
st.RollBack();
throw new ArgumentException(Revit.Properties.Resources.Adaptive_Component_Creation_Failed + ex.Message);
}
}
TransactionManager.Instance.TransactionTaskDone();
// remember this value
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
///
/// </summary>
/// <param name="familyType"></param>
/// <param name="point"></param>
/// <param name="view"></param>
/// <returns></returns>
public static Element ByView(FamilyType familyType, Point point, View view)
{
if (familyType == null)
{
throw new ArgumentNullException(nameof(familyType));
}
if (point == null)
{
throw new ArgumentNullException(nameof(point));
}
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
var symbol = familyType.InternalElement as Autodesk.Revit.DB.FamilySymbol;
var pt = point.ToRevitType();
var v = view.InternalElement as Autodesk.Revit.DB.View;
return(new FamilyInstances(symbol, pt, v));
}
public static Element ByHostAndPoint(FamilyType familyType, Point point, Element host)
{
if (familyType == null)
{
throw new ArgumentNullException(nameof(familyType));
}
if (point == null)
{
throw new ArgumentNullException(nameof(point));
}
if (host == null)
{
throw new ArgumentNullException(nameof(host));
}
var doc = DocumentManager.Instance.CurrentDBDocument;
var symbol = familyType.InternalElement as Autodesk.Revit.DB.FamilySymbol;
var pt = point.ToRevitType();
var h = host.InternalElement;
var level = doc.GetElement(h.LevelId) as Autodesk.Revit.DB.Level;
return(new FamilyInstances(symbol, pt, h, level).InternalElement.ToDSType(true));
}
/// <summary>
/// Place a Revit family instance given the FamilyType (also known as the FamilySymbol in the Revit API)
/// on a surface derived from a backing Revit face as reference, a reference direction and a point location where to place the family.
///
/// Note: The FamilyType should be workplane based and the input surface must be created from a Revit Face. The reference direction defines the rotation of the instance on the reference, and thus cannot be perpendicular to the face.
/// </summary>
/// <param name="familyType">Family Type. Also called Family Symbol.</param>
/// <param name="face">Surface geometry derived from a Revit face as reference element</param>
/// <param name="location">Point on the face where the instance is to be placed</param>
/// <param name="referenceDirection">A vector that defines the direction of placement of the family instance</param>
/// <returns>FamilyInstance</returns>
public static FamilyInstance ByFace(FamilyType familyType, Surface face, Point location,
Vector referenceDirection)
{
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
if (face == null)
{
throw new ArgumentNullException("face");
}
if (location == null)
{
throw new ArgumentNullException("location");
}
if (referenceDirection == null)
{
throw new ArgumentNullException("referenceDirection");
}
var reference = ElementFaceReference.TryGetFaceReference(face);
return(new FamilyInstance(familyType.InternalFamilySymbol, reference.InternalReference,
location.ToXyz(), referenceDirection.ToXyz()));
}
public void ByPoints_NullPts()
{
var ft = FamilyType.ByName("3PointAC");
Assert.Throws(typeof(ArgumentNullException), () => AdaptiveComponent.ByPoints(null, ft));
}
public static FamilyType Wrap(Autodesk.Revit.DB.FamilySymbol ele, bool isRevitOwned)
{
return(FamilyType.FromExisting(ele, isRevitOwned));
}
/// <summary>
/// Create a list of adaptive components from two-dimensional array of points
/// </summary>
/// <param name="points">a two-dimensional array of points</param>
/// <param name="familyType">a family type to use to create the adaptive components</param>
/// <returns></returns>
private static AdaptiveComponent[] InternalByPoints(Point[][] points, FamilyType familyType)
{
var oldInstances = ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
int countToBeCreated = points.Count();
int countOfOldInstances = 0;
if (oldInstances != null)
{
countOfOldInstances = oldInstances.Count();
}
int reusableCount = Math.Min(countToBeCreated, countOfOldInstances);
TransactionManager.Instance.EnsureInTransaction(Document);
List <Autodesk.Revit.DB.FamilyInstance> instances = new List <Autodesk.Revit.DB.FamilyInstance>();
List <AdaptiveComponent> components = new List <AdaptiveComponent>();
try
{
// Reuse the adaptive components that can be reused if possible
for (int i = 0; i < reusableCount; i++)
{
var fi = oldInstances.ElementAt(i);
var comp = new AdaptiveComponent(fi);
components.Add(comp);
//Update the family symbol
if (familyType.InternalFamilySymbol.Id != fi.Symbol.Id)
{
fi.Symbol = familyType.InternalFamilySymbol;
}
UpdatePlacementPoints(fi, points[i].ToXyzs());
instances.Add(fi);
}
// Delete the redundant adaptive components if any
for (int i = reusableCount; i < countOfOldInstances; i++)
{
var fi = oldInstances.ElementAt(i);
Document.Delete(fi.Id);
}
// Create new adaptive components
if (countToBeCreated > countOfOldInstances)
{
var remainingPoints = points.Skip(reusableCount).ToArray();
// Prepare the creation data for batch processing
int numOfComponents = remainingPoints.Count();
List <FamilyInstanceCreationData> creationDatas = new List <FamilyInstanceCreationData>(numOfComponents);
for (int i = 0; i < numOfComponents; ++i)
{
int numOfPoints = remainingPoints[i].Length;
var aPoints = remainingPoints[i].ToXyzs();
var creationData = DocumentManager.Instance.CurrentUIApplication.Application.Create.
NewFamilyInstanceCreationData(familyType.InternalFamilySymbol, aPoints);
if (creationData != null)
{
creationDatas.Add(creationData);
}
}
// Create elements based on the creation data in a batch
ICollection <ElementId> elements;
if (creationDatas.Count > 0)
{
if (Document.IsFamilyDocument)
{
elements = DocumentManager.Instance.CurrentDBDocument.FamilyCreate.NewFamilyInstances2(creationDatas);
}
else
{
elements = DocumentManager.Instance.CurrentDBDocument.Create.NewFamilyInstances2(creationDatas);
}
foreach (var id in elements)
{
Autodesk.Revit.DB.FamilyInstance instance;
if (ElementUtils.TryGetElement <Autodesk.Revit.DB.FamilyInstance>(
DocumentManager.Instance.CurrentDBDocument, id, out instance))
{
instances.Add(instance);
components.Add(new AdaptiveComponent(instance));
}
}
}
}
ElementBinder.SetElementsForTrace(instances);
}
catch (Exception e)
{
// Unregister the elements from the element life cycle manager and delete the elements
var elementManager = ElementIDLifecycleManager <int> .GetInstance();
foreach (var component in components)
{
elementManager.UnRegisterAssociation(component.InternalElementId.IntegerValue, component);
}
foreach (var instance in instances)
{
Document.Delete(instance.Id);
}
if (e is Autodesk.Revit.Exceptions.ArgumentException)
{
throw new ArgumentException("The arguments have issues", e);
}
else
{
throw e;
}
}
finally
{
TransactionManager.Instance.TransactionTaskDone();
}
return(components.ToArray());
}
/// <summary>
/// Internal constructor for the AdaptiveComponent wrapper
/// </summary>
/// <param name="parms">Params on curve to reference</param>
/// <param name="c">Curve to use as reference</param>
/// <param name="ft">familyType to place</param>
private AdaptiveComponent(double[] parms, Reference c, FamilyType ft)
{
SafeInit(() => InitAdaptiveComponent(parms, c, ft));
}
/// <summary>
/// Create an adaptive component referencing the parameters on a Curve reference
/// </summary>
/// <param name="parameters">The parameters on the curve</param>
/// <param name="curve">The curve to reference</param>
/// <param name="familyType">The family type to construct</param>
/// <returns></returns>
public static AdaptiveComponent ByParametersOnCurveReference(double[] parameters, Autodesk.DesignScript.Geometry.Curve curve, FamilyType familyType)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if (familyType == null)
{
throw new ArgumentNullException("familyType");
}
return(new AdaptiveComponent(parameters, ElementCurveReference.TryGetCurveReference(curve).InternalReference, familyType));
}
