/// <summary>
/// This method is used to create ReferencePlane along to a host referenceplane with a offset parameter
/// </summary>
/// <param name="doc">the document</param>
/// <param name="host">the host ReferencePlane</param>
/// <param name="view">the view</param>
/// <param name="offSet">the offset of the host</param>
/// <param name="cutVec">the cutVec of the ReferencePlane</param>
/// <param name="name">the name of the ReferencePlane</param>
/// <returns>ReferencePlane</returns>
public ReferencePlane Create(Document doc, ReferencePlane host, View view, Autodesk.Revit.DB.XYZ offSet, Autodesk.Revit.DB.XYZ cutVec, string name)
{
Autodesk.Revit.DB.XYZ bubbleEnd = new Autodesk.Revit.DB.XYZ ();
Autodesk.Revit.DB.XYZ freeEnd = new Autodesk.Revit.DB.XYZ ();
ReferencePlane refPlane;
try
{
refPlane = host as ReferencePlane;
if (refPlane != null)
{
bubbleEnd = refPlane.BubbleEnd.Add(offSet);
freeEnd = refPlane.FreeEnd.Add(offSet);
SubTransaction subTransaction = new SubTransaction(doc);
subTransaction.Start();
refPlane = doc.FamilyCreate.NewReferencePlane(bubbleEnd, freeEnd, cutVec, view);
refPlane.Name = name;
subTransaction.Commit();
}
return refPlane;
}
catch
{
return null;
}
}
/// <summary>
/// create Opening on wall
/// </summary>
/// <param name="points">points used to create Opening</param>
/// <returns>newly created Opening</returns>
public override Opening CreateOpening(List<Vector4> points)
{
//create Opening on wall
Autodesk.Revit.DB.XYZ p1 = new Autodesk.Revit.DB.XYZ (points[0].X, points[0].Y, points[0].Z);
Autodesk.Revit.DB.XYZ p2 = new Autodesk.Revit.DB.XYZ (points[1].X, points[1].Y, points[1].Z);
return m_docCreator.NewOpening(m_data, p1, p2);
}
/// <summary>
/// This method is used to create dimension among three reference planes
/// </summary>
/// <param name="view">the view</param>
/// <param name="refPlane1">the first reference plane</param>
/// <param name="refPlane2">the second reference plane</param>
/// <param name="refPlane">the middle reference plane</param>
/// <returns>the new dimension</returns>
public Dimension AddDimension(View view, ReferencePlane refPlane1, ReferencePlane refPlane2, ReferencePlane refPlane)
{
Dimension dim;
Autodesk.Revit.DB.XYZ startPoint = new Autodesk.Revit.DB.XYZ ();
Autodesk.Revit.DB.XYZ endPoint = new Autodesk.Revit.DB.XYZ ();
Line line;
Reference ref1;
Reference ref2;
Reference ref3;
ReferenceArray refArray = new ReferenceArray();
ref1 = refPlane1.Reference;
ref2 = refPlane2.Reference;
ref3 = refPlane.Reference;
startPoint = refPlane1.FreeEnd;
endPoint = refPlane2.FreeEnd;
line = m_application.Create.NewLineBound(startPoint, endPoint);
if (null != ref1 && null != ref2 && null != ref3)
{
refArray.Append(ref1);
refArray.Append(ref3);
refArray.Append(ref2);
}
SubTransaction subTransaction = new SubTransaction(m_document);
subTransaction.Start();
dim = m_document.FamilyCreate.NewDimension(view, line, refArray);
subTransaction.Commit();
return dim;
}
/// <summary>
/// Private constructor, just be called in static factory method BuildSections.
/// </summary>
/// <param name="dir">Pipe's direction</param>
private Section(Autodesk.Revit.DB.XYZ dir)
{
m_dir = dir;
m_startFactor = 0;
m_endFactor = 0;
m_refs = new List<ReferenceWithContext>();
m_pipes = new List<Pipe>();
}
/// <summary>
/// Add two Autodesk.Revit.DB.XYZ as Matrix
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static Autodesk.Revit.DB.XYZ AddXYZ(Autodesk.Revit.DB.XYZ lhs, Autodesk.Revit.DB.XYZ rhs)
{
double x = lhs.X + rhs.X;
double y = lhs.Y + rhs.Y;
double z = lhs.Z + rhs.Z;
Autodesk.Revit.DB.XYZ result = new Autodesk.Revit.DB.XYZ (x, y, z);
return result;
}
const Double PRECISION = 0.0000000001; // Define a precision of double data
#endregion Fields
#region Methods
/// <summary>
/// Find the direction vector from first point to second point
/// </summary>
/// <param name="first">the first point</param>
/// <param name="second">the second point</param>
/// <returns>the direction vector</returns>
public static Autodesk.Revit.DB.XYZ FindDirection(Autodesk.Revit.DB.XYZ first, Autodesk.Revit.DB.XYZ second)
{
double x = second.X - first.X;
double y = second.Y - first.Y;
double z = second.Z - first.Z;
double distance = FindDistance(first, second);
Autodesk.Revit.DB.XYZ direction = new Autodesk.Revit.DB.XYZ (x / distance, y / distance, z / distance);
return direction;
}
/// <summary>
/// Create opening on wall
/// </summary>
/// <param name="points">Points use to create Opening</param>
/// <param name="type">Tool type</param>
public override void DrawOpening(List<Vector4> points, ToolType type)
{
//get the rectangle two points
Autodesk.Revit.DB.XYZ p1 = new Autodesk.Revit.DB.XYZ (points[0].X, points[0].Y, points[0].Z);
Autodesk.Revit.DB.XYZ p2 = new Autodesk.Revit.DB.XYZ (points[2].X, points[2].Y, points[2].Z);
//draw opening on wall
m_docCreator.NewOpening(m_data, p1, p2);
}
/// <summary>
/// create 3D and 2D data of given GeometryElement
/// </summary>
/// <param name="elem"></param>
/// <param name="detail"></param>
/// <param name="currentView"></param>
public GeometryData(Element elem, DetailLevels detail, View currentView)
{
Options opt = Command.CommandData.Application.Application.Create.NewGeometryOptions();
opt.DetailLevel = detail;
opt.ComputeReferences = false;
GeometryElement geoElement = elem.get_Geometry(opt);
Autodesk.Revit.DB.XYZ xyz = new Autodesk.Revit.DB.XYZ (0, 0, 0);
Transform transform = Transform.get_Translation(xyz);
AddGeoElement(geoElement, transform);
m_bbox = elem.get_BoundingBox(currentView);
}
/// <summary>
/// Create PathReinforcement on floor
/// </summary>
/// <param name="points">points used to create PathReinforcement</param>
/// <param name="flip">used to specify whether new PathReinforcement is Filp</param>
/// <returns>new created PathReinforcement</returns>
public override PathReinforcement CreatePathReinforcement(List<Vector4> points, bool flip)
{
Autodesk.Revit.DB.XYZ p1, p2; Line curve;
CurveArray curves = m_appCreator.NewCurveArray();
for (int i = 0; i < points.Count - 1; i++)
{
p1 = new Autodesk.Revit.DB.XYZ (points[i].X, points[i].Y, points[i].Z);
p2 = new Autodesk.Revit.DB.XYZ (points[i + 1].X, points[i + 1].Y, points[i + 1].Z);
curve = m_appCreator.NewLine(p1, p2, true);
curves.Append(curve);
}
return m_docCreator.NewPathReinforcement(m_data, curves, flip);
}
/// <summary>
/// Create Opening on floor
/// </summary>
/// <param name="points">points used to create Opening</param>
/// <returns>newly created Opening</returns>
public override Opening CreateOpening(List<Vector4> points)
{
Autodesk.Revit.DB.XYZ p1, p2; Line curve;
CurveArray curves = m_appCreator.NewCurveArray();
for (int i = 0; i < points.Count - 1; i++)
{
p1 = new Autodesk.Revit.DB.XYZ (points[i].X, points[i].Y, points[i].Z);
p2 = new Autodesk.Revit.DB.XYZ (points[i + 1].X, points[i + 1].Y, points[i + 1].Z);
curve = m_appCreator.NewLine(p1, p2, true);
curves.Append(curve);
}
//close the curve
p1 = new Autodesk.Revit.DB.XYZ (points[0].X, points[0].Y, points[0].Z);
p2 = new Autodesk.Revit.DB.XYZ (points[points.Count - 1].X,
points[points.Count - 1].Y, points[points.Count - 1].Z);
curve = m_appCreator.NewLine(p1, p2, true);
curves.Append(curve);
return m_docCreator.NewOpening(m_data, curves, true);
}
/// <summary>
/// The function set value to rotation of the beams and braces
/// and rotate columns.
/// </summary>
public void RotateElement()
{
ElementSet selection = new ElementSet();
foreach (ElementId elementid in m_doc.Selection.GetElementIds())
{
selection.Insert(m_doc.Document.GetElement(elementid));
}
foreach (Autodesk.Revit.DB.Element e in selection)
{
FamilyInstance familyComponent = e as FamilyInstance;
if (familyComponent == null)
{
//is not a familyInstance
continue;
}
// if be familyInstance,judge the types of familyInstance
if (Autodesk.Revit.DB.Structure.StructuralType.Beam == familyComponent.StructuralType ||
Autodesk.Revit.DB.Structure.StructuralType.Brace == familyComponent.StructuralType)
{
// selection is a beam or Brace
ParameterSetIterator j = familyComponent.Parameters.ForwardIterator();
j.Reset();
bool jMoreAttribute = j.MoveNext();
while (jMoreAttribute)
{
object a = j.Current;
Parameter objectAttribute = a as Parameter;
//set generic property named ¡°Angle¡±
int p = objectAttribute.Definition.Name.CompareTo("Angle");
if (0 == p)
{
Double temp = objectAttribute.AsDouble();
double rotateDegree = m_receiveRotationTextBox * Math.PI / 180;
if (!m_isAbsoluteChecked)
{
// absolute rotation
rotateDegree += temp;
}
objectAttribute.Set(rotateDegree);
// relative rotation
}
jMoreAttribute = j.MoveNext();
}
}
else if (Autodesk.Revit.DB.Structure.StructuralType.Column == familyComponent.StructuralType)
{
// rotate a column
Autodesk.Revit.DB.Location columnLocation = familyComponent.Location;
// get the location object
Autodesk.Revit.DB.LocationPoint pointLocation = columnLocation as Autodesk.Revit.DB.LocationPoint;
Autodesk.Revit.DB.XYZ insertPoint = pointLocation.Point;
// get the location point
double temp = pointLocation.Rotation;
//existing rotation
XYZ directionPoint = m_doc.Document.Application.Create.NewXYZ(0, 0, 1);
// define the vector of axis
Autodesk.Revit.DB.Line rotateAxis = Line.CreateBound(insertPoint, directionPoint);
double rotateDegree = m_receiveRotationTextBox * Math.PI / 180;
// rotate column by rotate method
if (m_isAbsoluteChecked)
{
rotateDegree -= temp;
}
bool rotateResult = pointLocation.Rotate(rotateAxis, rotateDegree);
if (rotateResult == false)
{
MessageBox.Show("Rotate Failed.");
}
}
}
}
/// <summary>
/// Set the point data of this user control
/// </summary>
/// <param name="data">the point data</param>
public void SetPointData(Autodesk.Revit.DB.XYZ data)
{
xCoordinateTextBox.Text = data.X.ToString("F2");
yCoordinateTextBox.Text = data.Y.ToString("F2");
zCoordinateTextBox.Text = data.Z.ToString("F2");
}
public void Arc_Basic()
{
var o = new Autodesk.Revit.DB.XYZ(5,2,3);
var x = (new Autodesk.Revit.DB.XYZ(0, 0, 1)).Normalize();
var y = (new Autodesk.Revit.DB.XYZ(0,-1, 0)).Normalize();
var r = 10;
var sp = 0.1;
var ep = 2.5;
var re = Autodesk.Revit.DB.Arc.Create(o, r, sp, ep, x, y);
var pc = re.ToProtoType(false);
Assert.NotNull(pc);
Assert.IsAssignableFrom<Autodesk.DesignScript.Geometry.Arc>(pc);
var pa = (Autodesk.DesignScript.Geometry.Arc)pc;
(pa.SweepAngle * Math.PI / 180).ShouldBeApproximately(ep - sp);
pa.StartPoint.ShouldBeApproximately(re.GetEndPoint(0));
pa.EndPoint.ShouldBeApproximately(re.GetEndPoint(1));
//var tessPts = re.Tessellate();
//// assert the tesselation is very close to original curve
//foreach (var pt in tessPts)
//{
// var closestPt = pa.ClosestPointTo(pt.ToPoint(false));
// Assert.Less(closestPt.DistanceTo(pt.ToPoint(false)), 1e-6);
//}
}
public static Point3D RevitPointToWindowsPoint(Autodesk.Revit.DB.XYZ xyz)
{
return(new Point3D(xyz.X, xyz.Y, xyz.Z));
}
/// <summary>
/// move the BoundingBox to the center of the Coordinate System,
/// modify its size to the size of Geometry's BoundingBox
/// </summary>
/// <param name="bbox"></param>
private void InitializeBBox(BoundingBoxXYZ bbox)
{
Autodesk.Revit.DB.XYZ size = MathUtil.SubXYZ(bbox.Max, bbox.Min);
m_bbox.Max = MathUtil.DivideXYZ(size, 2.0);
m_bbox.Min = MathUtil.DivideXYZ(size, -2.0);
}
/// <summary>
/// Get a matrix which can transform points to 2D
/// </summary>
/// <returns>matrix which can transform points to 2D</returns>
public Matrix4 GetTo2DMatrix()
{
Line trussLocation = (m_truss.Location as LocationCurve).Curve as Line;
startLocation = trussLocation.get_EndPoint(0);
endLocation = trussLocation.get_EndPoint(1);
//use baseline of truss as the X axis
XYZ diff = endLocation - startLocation;
Vector4 xAxis = new Vector4(new Autodesk.Revit.DB.XYZ(diff.X, diff.Y, diff.Z));
xAxis.Normalize();
//get Z Axis
Vector4 zAxis = Vector4.CrossProduct(xAxis, new Vector4(new Autodesk.Revit.DB.XYZ (0, 0, 1)));
zAxis.Normalize();
//get Y Axis, downward
Vector4 yAxis = Vector4.CrossProduct(xAxis, zAxis);
yAxis.Normalize();
//get original point, first point
m_origin = new Vector4(m_points[0]);
return new Matrix4(xAxis, yAxis, zAxis, m_origin);
}
public static Vector3d ToVector3d(this DB.XYZ value)
{
return(new Vector3d(value.X, value.Y, value.Z));
}
PlaceColumn(Autodesk.Revit.ApplicationServices.Application rvtApp, Document rvtDoc, Autodesk.Revit.DB.XYZ point2, double angle, FamilySymbol columnType, ElementId baseLevelId, ElementId topLevelId)
{
Autodesk.Revit.DB.XYZ point = point2;
// Note: Must use level-hosted NewFamilyInstance!
Level instLevel = (Level)rvtDoc.GetElement(baseLevelId);
Autodesk.Revit.DB.FamilyInstance column = rvtDoc.Create.NewFamilyInstance(point, columnType, instLevel, StructuralType.Column);
if (column == null)
{
MessageBox.Show("failed to create an instance of a column.");
return;
}
Autodesk.Revit.DB.XYZ zVec = new Autodesk.Revit.DB.XYZ(0, 0, 1);
Autodesk.Revit.DB.Line axis = Line.CreateUnbound(point, zVec);
column.Location.Rotate(axis, angle);
// Set the level Ids
Parameter baseLevelParameter = column.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.FAMILY_BASE_LEVEL_PARAM);
Parameter topLevelParameter = column.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.FAMILY_TOP_LEVEL_PARAM);;
baseLevelParameter.Set(baseLevelId);
topLevelParameter.Set(topLevelId);
}
/// <summary>
/// Get common informations for batch creation
/// </summary>
private void PreCreate()
{
try
{
Autodesk.Revit.Creation.Application appCreation = m_cmdData.Application.Application.Create;
//Try to get Level named "Level 1" which will be used in most creations
m_level = (from elem in
new FilteredElementCollector(m_doc).OfClass(typeof(Level)).ToElements()
let level = elem as Level
where level != null && "Level 1" == level.Name
select level).First();
//If ViewPlan "Level 1" does not exist, try to create one.
if (null != m_level)
{
ElementId AreaSchemeId = new FilteredElementCollector(m_doc).OfClass(typeof(AreaScheme)).FirstOrDefault(a => a.Name == "Rentable").Id;
try
{
m_viewPlan = ViewPlan.CreateAreaPlan(m_doc, AreaSchemeId, m_level.Id);
m_viewPlan.Name = "Level 1";
}
catch
{
}
}
if (null == m_level && null == m_viewPlan)
{
return;
}
//List of Curve is used to store Area's boundary lines
List <Curve> curves = new List <Curve>();
Autodesk.Revit.DB.XYZ pt1 = new Autodesk.Revit.DB.XYZ(-4, 95, 0);
Autodesk.Revit.DB.XYZ pt2 = new Autodesk.Revit.DB.XYZ(-106, 95, 0);
Line line = Line.CreateBound(pt1, pt2);
curves.Add(line);
pt1 = new Autodesk.Revit.DB.XYZ(-4, 105, 0);
pt2 = new Autodesk.Revit.DB.XYZ(-106, 105, 0);
line = Line.CreateBound(pt1, pt2);
curves.Add(line);
for (int i = 0; i < 11; i++)
{
pt1 = new Autodesk.Revit.DB.XYZ(-5 - i * 10, 94, 0);
pt2 = new Autodesk.Revit.DB.XYZ(-5 - i * 10, 106, 0);
line = Line.CreateBound(pt1, pt2);
if (null != line)
{
curves.Add(line);
}
}
// Create Area Boundary Line for Area
// It is necessary if need to create closed region for Area
// But for Room, it is not necessary.
Autodesk.Revit.DB.XYZ origin = new Autodesk.Revit.DB.XYZ(0, 0, 0);
Autodesk.Revit.DB.XYZ norm = new Autodesk.Revit.DB.XYZ(0, 0, 1);
Plane plane = appCreation.NewPlane(norm, origin);
if (null != plane)
{
SketchPlane sketchPlane = SketchPlane.Create(m_doc, plane);
if (null != sketchPlane)
{
foreach (Curve curve in curves)
{
m_doc.Create.NewAreaBoundaryLine(sketchPlane, curve, m_viewPlan);
}
}
}
//Create enclosed region using Walls for Room
pt1 = new Autodesk.Revit.DB.XYZ(5, -5, 0);
pt2 = new Autodesk.Revit.DB.XYZ(55, -5, 0);
line = Line.CreateBound(pt1, pt2);
Wall.Create(m_doc, line, m_level.Id, true);
pt1 = new Autodesk.Revit.DB.XYZ(5, 5, 0);
pt2 = new Autodesk.Revit.DB.XYZ(55, 5, 0);
line = Line.CreateBound(pt1, pt2);
Wall.Create(m_doc, line, m_level.Id, true);
for (int i = 0; i < 6; i++)
{
pt1 = new Autodesk.Revit.DB.XYZ(5 + i * 10, -5, 0);
pt2 = new Autodesk.Revit.DB.XYZ(5 + i * 10, 5, 0);
line = Line.CreateBound(pt1, pt2);
Wall.Create(m_doc, line, m_level.Id, true);
}
}
catch (Exception)
{
}
}
/// <summary>
/// Get the geometry information of vertical rebar
/// </summary>
/// <param name="location">the location of vertical rebar</param>
/// <param name="rebarNumber">the spacing value of the rebar</param>
/// <returns>the gotted geometry information</returns>
public RebarGeometry GetVerticalRebar(VerticalRebarLocation location, int rebarNumber)
{
// sort the points of the swept profile
XYZHeightComparer comparer = new XYZHeightComparer();
m_points.Sort(comparer);
// Get the offset and rebar length of rebar
double offset = ColumnRebarData.VerticalOffset;
double rebarLength = m_columnHeight + 3; //the length of rebar
// Get the start point of the vertical rebar curve
Autodesk.Revit.DB.XYZ startPoint = m_drivingLine.GetEndPoint(0);
List <Autodesk.Revit.DB.XYZ> movedPoints = OffsetPoints(offset);
movedPoints.Sort(comparer);
Autodesk.Revit.DB.XYZ normal = new Autodesk.Revit.DB.XYZ(); // the normal parameter
double rebarOffset = 0; // rebar offset, equal to rebarNumber* spacing
// get the normal, start point and rebar offset of vertical rebar
switch (location)
{
case VerticalRebarLocation.East: //vertical rebar in east
normal = new Autodesk.Revit.DB.XYZ(0, 1, 0);
rebarOffset = m_columnWidth - 2 * offset;
startPoint = movedPoints[1];
break;
case VerticalRebarLocation.North: //vertical rebar in north
normal = new Autodesk.Revit.DB.XYZ(-1, 0, 0);
rebarOffset = m_columnLength - 2 * offset;
startPoint = movedPoints[3];
break;
case VerticalRebarLocation.West: //vertical rebar in west
normal = new Autodesk.Revit.DB.XYZ(0, -1, 0);
rebarOffset = m_columnWidth - 2 * offset;
startPoint = movedPoints[2];
break;
case VerticalRebarLocation.South: //vertical rebar in south
normal = new Autodesk.Revit.DB.XYZ(1, 0, 0);
rebarOffset = m_columnLength - 2 * offset;
startPoint = movedPoints[0];
break;
default:
break;
}
double spacing = rebarOffset / rebarNumber; //spacing value of the rebar
Autodesk.Revit.DB.XYZ endPoint = GeomUtil.OffsetPoint(startPoint, m_drivingVector, rebarLength);
IList <Curve> curves = new List <Curve>(); //profile of the rebar
curves.Add(Line.CreateBound(startPoint, endPoint));
// return the rebar geometry information
return(new RebarGeometry(normal, curves, rebarNumber, spacing));
}
/// <summary>
/// Get the geometry information of the transverse rebar
/// </summary>
/// <param name="location">the location of transverse rebar</param>
/// <param name="spacing">the spacing value of the rebar</param>
/// <returns>the gotted geometry information</returns>
public RebarGeometry GetTransverseRebar(TransverseRebarLocation location, double spacing)
{
// sort the points of the swept profile
XYZHeightComparer comparer = new XYZHeightComparer();
m_points.Sort(comparer);
// the offset from the column surface to the rebar
double offset = ColumnRebarData.TransverseOffset;
//the length of the transverse rebar
double rebarLength = 0;
// get the origin and normal parameter for rebar creation
Autodesk.Revit.DB.XYZ normal = m_drivingVector;
double curveOffset = 0;
//set rebar length and origin according to the location of rebar
switch (location)
{
case TransverseRebarLocation.Start: // start transverse rebar
rebarLength = m_columnHeight / 4;
break;
case TransverseRebarLocation.Center: // center transverse rebar
rebarLength = m_columnHeight / 2;
curveOffset = m_columnHeight / 4 + (rebarLength % spacing) / 2;
break;
case TransverseRebarLocation.End: // end transverse rebar
rebarLength = m_columnHeight / 4;
curveOffset = m_columnHeight - rebarLength + (rebarLength % spacing);
break;
default:
throw new Exception("The program should never go here.");
}
// the number of the transverse rebar
int rebarNumber = (int)(rebarLength / spacing) + 1;
// get the profile of the transverse rebar
List <Autodesk.Revit.DB.XYZ> movedPoints = OffsetPoints(offset);
List <Autodesk.Revit.DB.XYZ> translatedPoints = new List <Autodesk.Revit.DB.XYZ>();
foreach (Autodesk.Revit.DB.XYZ point in movedPoints)
{
translatedPoints.Add(GeomUtil.OffsetPoint(point, m_drivingVector, curveOffset));
}
IList <Curve> curves = new List <Curve>(); //the profile of the transverse rebar
Autodesk.Revit.DB.XYZ first = translatedPoints[0];
Autodesk.Revit.DB.XYZ second = translatedPoints[1];
Autodesk.Revit.DB.XYZ third = translatedPoints[2];
Autodesk.Revit.DB.XYZ fourth = translatedPoints[3];
curves.Add(Line.CreateBound(first, second));
curves.Add(Line.CreateBound(second, fourth));
curves.Add(Line.CreateBound(fourth, third));
curves.Add(Line.CreateBound(third, first));
// return the rebar geometry information
return(new RebarGeometry(normal, curves, rebarNumber, spacing));
}
/// <summary>
/// Located the buttom of a slab object.
/// </summary>
/// <param name="floor">A floor object.</param>
/// <param name="bubbleEnd">The bubble end of new reference plane.</param>
/// <param name="freeEnd">The free end of new reference plane.</param>
/// <param name="thirdPnt">The third point of new reference plane.</param>
private void LocateSlab(Floor floor, ref Autodesk.Revit.DB.XYZ bubbleEnd, ref Autodesk.Revit.DB.XYZ freeEnd, ref Autodesk.Revit.DB.XYZ thirdPnt)
{
//Obtain the geometry data of the floor.
GElement geometry = floor.get_Geometry(m_options);
Face buttomFace = null;
//foreach (GeometryObject go in geometry.Objects)
IEnumerator <GeometryObject> Objects = geometry.GetEnumerator();
while (Objects.MoveNext())
{
GeometryObject go = Objects.Current;
Solid solid = go as Solid;
if (null == solid)
{
continue;
}
else
{
//Get the bottom face of this floor.
buttomFace = GeoHelper.GetBottomFace(solid.Faces);
}
}
Mesh mesh = buttomFace.Triangulate();
GeoHelper.Distribute(mesh, ref bubbleEnd, ref freeEnd, ref thirdPnt);
}
/// <summary>
/// Located the exterior of a wall object.
/// </summary>
/// <param name="wall">A wall object</param>
/// <param name="bubbleEnd">The bubble end of new reference plane.</param>
/// <param name="freeEnd">The free end of new reference plane.</param>
/// <param name="cutVec">The cut vector of new reference plane.</param>
private void LocateWall(Wall wall, ref Autodesk.Revit.DB.XYZ bubbleEnd, ref Autodesk.Revit.DB.XYZ freeEnd, ref Autodesk.Revit.DB.XYZ cutVec)
{
LocationCurve location = wall.Location as LocationCurve;
Curve locaCurve = location.Curve;
//Not work for wall without location.
if (null == locaCurve)
{
throw new Exception("This wall has no location.");
}
//Not work for arc wall.
Line line = locaCurve as Line;
if (null == line)
{
throw new Exception("Just work for straight wall.");
}
//Calculate offset by law of cosines.
double halfThickness = wall.Width / 2;
double length = GeoHelper.GetLength(locaCurve.GetEndPoint(0), locaCurve.GetEndPoint(1));
double xAxis = GeoHelper.GetDistance(locaCurve.GetEndPoint(0).X, locaCurve.GetEndPoint(1).X);
double yAxis = GeoHelper.GetDistance(locaCurve.GetEndPoint(0).Y, locaCurve.GetEndPoint(1).Y);
double xOffset = yAxis * halfThickness / length;
double yOffset = xAxis * halfThickness / length;
if (locaCurve.GetEndPoint(0).X < locaCurve.GetEndPoint(1).X &&
locaCurve.GetEndPoint(0).Y < locaCurve.GetEndPoint(1).Y)
{
xOffset = -xOffset;
}
if (locaCurve.GetEndPoint(0).X > locaCurve.GetEndPoint(1).X &&
locaCurve.GetEndPoint(0).Y > locaCurve.GetEndPoint(1).Y)
{
yOffset = -yOffset;
}
if (locaCurve.GetEndPoint(0).X > locaCurve.GetEndPoint(1).X &&
locaCurve.GetEndPoint(0).Y < locaCurve.GetEndPoint(1).Y)
{
xOffset = -xOffset;
yOffset = -yOffset;
}
//Three necessary parameters for generate a reference plane.
bubbleEnd = new Autodesk.Revit.DB.XYZ(locaCurve.GetEndPoint(0).X + xOffset,
locaCurve.GetEndPoint(0).Y + yOffset, locaCurve.GetEndPoint(0).Z);
freeEnd = new Autodesk.Revit.DB.XYZ(locaCurve.GetEndPoint(1).X + xOffset,
locaCurve.GetEndPoint(1).Y + yOffset, locaCurve.GetEndPoint(1).Z);
cutVec = new Autodesk.Revit.DB.XYZ(0, 0, 1);
}
/// <summary>
/// Format the output string for a point.
/// </summary>
/// <param name="point">A point to show in UI.</param>
/// <returns>The display string for a point.</returns>
private string Format(Autodesk.Revit.DB.XYZ point)
{
return("(" + Math.Round(point.X, 2).ToString() +
", " + Math.Round(point.Y, 2).ToString() +
", " + Math.Round(point.Z, 2).ToString() + ")");
}
private Group(DB.XYZ point, DB.GroupType groupType)
{
SafeInit(() => InitGroup(point, groupType));
}
/// <summary>
/// get a bounding box which covers all the input points
/// </summary>
/// <param name="points">
/// the source points
/// </param>
/// <param name="minXYZ">
/// one of the bounding box points
/// </param>
/// <param name="maxXYZ">
/// one of the bounding box points
/// </param>
private void GetVertexesByPoints(List <Autodesk.Revit.DB.XYZ> points, ref Autodesk.Revit.DB.XYZ minXYZ, ref Autodesk.Revit.DB.XYZ maxXYZ)
{
if (null == points || 0 == points.Count)
{
return;
}
double minX = minXYZ.X;
double minY = minXYZ.Y;
double minZ = minXYZ.Z;
double maxX = maxXYZ.X;
double maxY = maxXYZ.Y;
double maxZ = maxXYZ.Z;
foreach (Autodesk.Revit.DB.XYZ xyz in points)
{
// compare the values and update the min and max value
if (xyz.X < minX)
{
minX = xyz.X;
minY = xyz.Y;
}
if (xyz.X > maxX)
{
maxX = xyz.X;
maxY = xyz.Y;
}
if (xyz.Z < minZ)
{
minZ = xyz.Z;
}
if (xyz.Z > maxZ)
{
maxZ = xyz.Z;
}
} // end of loop
minXYZ = new Autodesk.Revit.DB.XYZ(minX, minY, minZ);
maxXYZ = new Autodesk.Revit.DB.XYZ(maxX, maxY, maxZ);
}
/// <summary>
/// Create vertical grids
/// </summary>
/// <param name="failureReasons">ArrayList contains failure reasons</param>
/// <returns>Number of grids failed to create</returns>
private int CreateYGrids(ref ArrayList failureReasons)
{
int errorCount = 0;
// Curve array which stores all curves for batch creation
CurveArray curves = new CurveArray();
for (int j = 0; j < m_yNumber; ++j)
{
Autodesk.Revit.DB.XYZ startPoint;
Autodesk.Revit.DB.XYZ endPoint;
Line line;
try
{
if (m_xNumber != 0)
{
startPoint = new Autodesk.Revit.DB.XYZ(m_xOrigin + j * m_ySpacing, m_yOrigin - m_xSpacing / 2, 0);
endPoint = new Autodesk.Revit.DB.XYZ(m_xOrigin + j * m_ySpacing, m_yOrigin + (m_xNumber - 1) * m_xSpacing + m_xSpacing / 2, 0);
}
else
{
startPoint = new Autodesk.Revit.DB.XYZ(m_xOrigin + j * m_ySpacing, m_yOrigin, 0);
endPoint = new Autodesk.Revit.DB.XYZ(m_xOrigin + j * m_ySpacing, m_yOrigin + m_ySpacing / 2, 0);
}
try
{
// Create a line according to the bubble location
if (m_yBubbleLoc == BubbleLocation.StartPoint)
{
line = NewLine(startPoint, endPoint);
}
else
{
line = NewLine(endPoint, startPoint);
}
}
catch (System.ArgumentException)
{
String failureReason = resManager.GetString("SpacingsTooSmall");
if (!failureReasons.Contains(failureReason))
{
failureReasons.Add(failureReason);
}
errorCount++;
continue;
}
if (j == 0)
{
Grid grid;
// Create grid with line
grid = NewGrid(line);
try
{
// Set label of first vertical grid
grid.Name = m_yFirstLabel;
}
catch (System.ArgumentException)
{
ShowMessage(resManager.GetString("FailedToSetLabel") + m_yFirstLabel + "!",
resManager.GetString("FailureCaptionSetLabel"));
}
}
else
{
// Add the line to curve array
curves.Append(line);
}
}
catch (Exception)
{
++errorCount;
continue;
}
}
// Create grids with curves
CreateGrids(curves);
return(errorCount);
}
/// <summary>
/// get the vertexes of the bounding box which covers all the curtain cells
/// </summary>
/// <param name="cells">
/// the source curtain cells
/// </param>
/// <param name="minXYZ">
/// the result bounding point
/// </param>
/// <param name="maxXYZ">
/// the result bounding point
/// </param>
private void GetVertexesByCells(ICollection <CurtainCell> cells, ref Autodesk.Revit.DB.XYZ minXYZ, ref Autodesk.Revit.DB.XYZ maxXYZ)
{
if (null == cells || cells.Count == 0)
{
return;
}
List <Autodesk.Revit.DB.XYZ> points = GetPoints(cells);
GetVertexesByPoints(points, ref minXYZ, ref maxXYZ);
}
/// <summary>
/// Get the swept profile(face) of the host object(family instance)
/// </summary>
/// <param name="solid">the solid reference</param>
/// <returns>the swept profile</returns>
private Face GetSweptProfileFace(Solid solid)
{
// Get a point on the swept profile from all points in solid
Autodesk.Revit.DB.XYZ refPoint = new Autodesk.Revit.DB.XYZ (); // the point on swept profile
foreach (Edge edge in solid.Edges)
{
List<XYZ> points = edge.Tessellate() as List<XYZ>; //get end points of the edge
if (2 != points.Count) // make sure all edges are lines
{
throw new Exception("All edge should be line.");
}
// get two points of the edge. All points in solid should be transform first
Autodesk.Revit.DB.XYZ first = Transform(points[0]); // start point of edge
Autodesk.Revit.DB.XYZ second = Transform(points[1]); // end point of edge
// some edges should be parallelled with the driving line,
// and the start point of that edge should be the wanted point
Autodesk.Revit.DB.XYZ edgeVector = GeomUtil.SubXYZ(second, first);
if (GeomUtil.IsSameDirection(edgeVector, m_drivingVector))
{
refPoint = first;
break;
}
if (GeomUtil.IsOppositeDirection(edgeVector, m_drivingVector))
{
refPoint = second;
break;
}
}
// Find swept profile(face)
Face sweptFace = null; // define the swept face
foreach (Face face in solid.Faces)
{
if (null != sweptFace)
{
break;
}
// the swept face should be perpendicular with the driving line
if (!GeomUtil.IsVertical(face, m_drivingLine, m_transform, null))
{
continue;
}
// use the gotted point to get the swept face
foreach (Autodesk.Revit.DB.XYZ point in face.Triangulate().Vertices)
{
Autodesk.Revit.DB.XYZ pnt = Transform(point); // all points in solid should be transform
if (GeomUtil.IsEqual(refPoint, pnt))
{
sweptFace = face;
break;
}
}
}
return sweptFace;
}
/// <summary>
/// move the selected grid line to the location of the mouse cursor
/// </summary>
/// <param name="mousePosition">
/// indicates the destination position of the grid line
/// </param>
/// <returns>
/// return whether the grid line be moved successfully
/// </returns>
public bool MoveGridLine(System.Drawing.Point mousePosition)
{
// verify that the mouse location is valid: it's inside the curtain grid area
// & it doesn't lap over another grid line (it's not allowed to move a grid line to lap over another one)
if (false == m_drawing.MouseLocationValid)
{
return(false);
}
if (null == m_lineToBeMoved)
{
return(false);
}
// move a U line along the V direction
if (-1 != m_drawing.SelectedUIndex)
{
// convert the 2D data to 3D
Autodesk.Revit.DB.XYZ xyz = new Autodesk.Revit.DB.XYZ(mousePosition.X, mousePosition.Y, 0);
Vector4 vec = new Vector4(xyz);
vec = m_drawing.Coordinates.RestoreMatrix.Transform(vec);
double offset = vec.Z - m_lineToBeMoved.FullCurve.GetEndPoint(0).Z;
xyz = new Autodesk.Revit.DB.XYZ(0, 0, offset);
Transaction act = new Transaction(m_activeDocument, Guid.NewGuid().GetHashCode().ToString());
act.Start();
try
{
m_lineToBeMoved.Move(xyz);
}
catch (System.Exception e)
{
TaskDialog.Show("Exception", e.Message);
return(false);
}
act.Commit();
// update the grid line 2d
GridLine2D line = m_drawing.UGridLines2D[m_drawing.SelectedUIndex];
line.StartPoint = new System.Drawing.Point(line.StartPoint.X, line.StartPoint.Y + m_moveOffset);
line.EndPoint = new System.Drawing.Point(line.EndPoint.X, line.EndPoint.Y + m_moveOffset);
// update the mapped grid line graphics path
GraphicsPath path = new GraphicsPath();
path.AddLine(line.StartPoint, line.EndPoint);
m_drawing.ULinePathList[m_drawing.SelectedUIndex] = path;
// update the mapped segment line and its graphics path
List <GraphicsPath> pathList = m_drawing.USegLinePathListList[m_drawing.SelectedUIndex];
List <SegmentLine2D> segLineList = line.Segments;
for (int i = 0; i < segLineList.Count; i++)
{
// update the segment
SegmentLine2D segLine2D = segLineList[i];
segLine2D.StartPoint = new System.Drawing.Point(segLine2D.StartPoint.X, segLine2D.StartPoint.Y + m_moveOffset);
segLine2D.EndPoint = new System.Drawing.Point(segLine2D.EndPoint.X, segLine2D.EndPoint.Y + m_moveOffset);
// update the segment's graphics path
GraphicsPath gpath = new GraphicsPath();
path.AddLine(segLine2D.StartPoint, segLine2D.EndPoint);
pathList[i] = gpath;
}
}
// move a V line along the U direction
else if (-1 != m_drawing.SelectedVIndex)
{
// convert the 2D data to 3D
Autodesk.Revit.DB.XYZ xyz = new Autodesk.Revit.DB.XYZ(mousePosition.X, mousePosition.Y, 0);
Vector4 vec = new Vector4(xyz);
vec = m_drawing.Coordinates.RestoreMatrix.Transform(vec);
double offset = vec.X - m_lineToBeMoved.FullCurve.GetEndPoint(0).X;
xyz = new Autodesk.Revit.DB.XYZ(offset, 0, 0);
Transaction act = new Transaction(m_activeDocument, Guid.NewGuid().GetHashCode().ToString());
act.Start();
try
{
m_lineToBeMoved.Move(xyz);
}
catch (System.Exception e)
{
TaskDialog.Show("Exception", e.Message);
return(false);
}
act.Commit();
// update the grid line 2d
GridLine2D line = m_drawing.VGridLines2D[m_drawing.SelectedVIndex];
line.StartPoint = new System.Drawing.Point(line.StartPoint.X + m_moveOffset, line.StartPoint.Y);
line.EndPoint = new System.Drawing.Point(line.EndPoint.X + m_moveOffset, line.EndPoint.Y);
// update the mapped grid line graphics path
GraphicsPath path = new GraphicsPath();
path.AddLine(line.StartPoint, line.EndPoint);
m_drawing.VLinePathList[m_drawing.SelectedVIndex] = path;
// update the mapped segment line and its graphics path
List <GraphicsPath> pathList = m_drawing.VSegLinePathListList[m_drawing.SelectedVIndex];
List <SegmentLine2D> segLineList = line.Segments;
for (int i = 0; i < segLineList.Count; i++)
{
// update the segment
SegmentLine2D segLine2D = segLineList[i];
segLine2D.StartPoint = new System.Drawing.Point(segLine2D.StartPoint.X + m_moveOffset, segLine2D.StartPoint.Y);
segLine2D.EndPoint = new System.Drawing.Point(segLine2D.EndPoint.X + m_moveOffset, segLine2D.EndPoint.Y);
// update the segment's graphics path
GraphicsPath gpath = new GraphicsPath();
path.AddLine(segLine2D.StartPoint, segLine2D.EndPoint);
pathList[i] = gpath;
}
}
// line moved, the segment information changed, so reload all the geometry data
this.ReloadGeometryData();
m_drawing.DrawObject.Clear();
return(true);
}
public bool AllowReference(Autodesk.Revit.DB.Reference reference, Autodesk.Revit.DB.XYZ position)
{
return(false);
}
/// <summary>
/// get all of the 4 vertexes of the curtain grid
/// </summary>
/// <returns></returns>
private bool GetCurtainGridVertexes()
{
// even in "ReloadGeometryData()" method, no need to reload the boundary information
// (as the boundary of the curtain grid won't be changed in the sample)
// just need to load it after the curtain wall been created
if (null != m_GridVertexesXYZ && 0 < m_GridVertexesXYZ.Count)
{
return(true);
}
// the curtain grid is from "Curtain Wall: Curtain Wall 1" (by default, the "Curtain Wall 1" has no U/V grid lines)
if (m_uGridLines.Count <= 0 || m_vGridLines.Count <= 0)
{
// special handling for "Curtain Wall: Curtain Wall 1"
// as the "Curtain Wall: Curtain Wall 1" has no U/V grid lines, so we can't compute the boundary from the grid lines
// as that kind of curtain wall contains only one curtain cell
// so we compute the boundary from the data of the curtain cell
// Obtain the geometry information of the curtain wall
// also works with some curtain grids with only U grid lines or only V grid lines
Transaction act = new Transaction(m_activeDocument, Guid.NewGuid().GetHashCode().ToString());
act.Start();
ICollection <CurtainCell> cells = m_activeGrid.GetCurtainCells();
act.Commit();
Autodesk.Revit.DB.XYZ minXYZ = new Autodesk.Revit.DB.XYZ(Double.MaxValue, Double.MaxValue, Double.MaxValue);
Autodesk.Revit.DB.XYZ maxXYZ = new Autodesk.Revit.DB.XYZ(Double.MinValue, Double.MinValue, Double.MinValue);
GetVertexesByCells(cells, ref minXYZ, ref maxXYZ);
// move the U & V lines to the boundary of the curtain grid, and get their end points as the vertexes of the curtain grid
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(minXYZ.X, minXYZ.Y, minXYZ.Z));
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(maxXYZ.X, maxXYZ.Y, minXYZ.Z));
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(maxXYZ.X, maxXYZ.Y, maxXYZ.Z));
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(minXYZ.X, minXYZ.Y, maxXYZ.Z));
return(true);
}
else
{
// handling for the other kinds of curtain walls (contains U&V grid lines by default)
CurtainGridLine uLine = m_uGridLines[0];
CurtainGridLine vLine = m_vGridLines[0];
List <Autodesk.Revit.DB.XYZ> points = new List <Autodesk.Revit.DB.XYZ>();
Autodesk.Revit.DB.XYZ uStartPoint = uLine.FullCurve.GetEndPoint(0);
Autodesk.Revit.DB.XYZ uEndPoint = uLine.FullCurve.GetEndPoint(1);
Autodesk.Revit.DB.XYZ vStartPoint = vLine.FullCurve.GetEndPoint(0);
Autodesk.Revit.DB.XYZ vEndPoint = vLine.FullCurve.GetEndPoint(1);
points.Add(uStartPoint);
points.Add(uEndPoint);
points.Add(vStartPoint);
points.Add(vEndPoint);
//move the U & V lines to the boundary of the curtain grid, and get their end points as the vertexes of the curtain grid
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(uStartPoint.X, uStartPoint.Y, vStartPoint.Z));
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(uEndPoint.X, uEndPoint.Y, vStartPoint.Z));
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(uEndPoint.X, uEndPoint.Y, vEndPoint.Z));
m_GridVertexesXYZ.Add(new Autodesk.Revit.DB.XYZ(uStartPoint.X, uStartPoint.Y, vEndPoint.Z));
return(true);
}
}
/// <summary>
/// Create a new Room by Level and location
/// </summary>
/// <param name="level"></param>
/// <param name="location"></param>
/// <param name="name"></param>
/// <param name="number"></param>
private Room(Autodesk.Revit.DB.Level level, Autodesk.Revit.DB.XYZ location, string name, string number)
{
SafeInit(() => Init(level, location, name, number));
}
/// <summary>
/// create simple AreaReinforcement on horizontal floor
/// </summary>
/// <param name="floor"></param>
/// <returns>is successful</returns>
private bool CreateAreaReinOnFloor(Floor floor)
{
GeomHelper helper = new GeomHelper();
Reference refer = null;
CurveArray curves = null;
//check whether floor is horizontal rectangular
//and prepare necessary to create AreaReinforcement
if (!helper.GetFloorGeom(floor, ref refer, ref curves))
{
ApplicationException appEx = new ApplicationException(
"Your selection is not a horizontal rectangular slab.");
throw appEx;
}
AreaReinDataOnFloor dataOnFloor = new AreaReinDataOnFloor();
CreateSimpleAreaReinForm createForm =
new CreateSimpleAreaReinForm(dataOnFloor);
//allow use select parameters to create
if (createForm.ShowDialog() == DialogResult.OK)
{
//define the Major Direction of AreaReinforcement,
//we get direction of first Line on the Floor as the Major Direction
Line firstLine = (Line)(curves.get_Item(0));
Autodesk.Revit.DB.XYZ majorDirection = new Autodesk.Revit.DB.XYZ (
firstLine.get_EndPoint(1).X - firstLine.get_EndPoint(0).X,
firstLine.get_EndPoint(1).Y - firstLine.get_EndPoint(0).Y,
firstLine.get_EndPoint(1).Z - firstLine.get_EndPoint(0).Z);
//crete AreaReinforcement by NewAreaReinforcement function
DocCreator creator = m_revit.Application.ActiveUIDocument.Document.Create;
AreaReinforcement areaRein = creator.NewAreaReinforcement(floor, curves, majorDirection);
//set AreaReinforcement and it's AreaReinforcementCurves parameters
dataOnFloor.FillIn(areaRein);
return true;
}
return false;
}
/// <summary>
/// find the center of the BoundingBox
/// </summary>
/// <param name="bbox">BoundingBox</param>
/// <returns>center Point</returns>
private Vector FindBBoxCenter(BoundingBoxXYZ bbox)
{
Autodesk.Revit.DB.XYZ center = MathUtil.DivideXYZ(MathUtil.AddXYZ(bbox.Max, bbox.Min), 2.0);
return(MathUtil.XYZ2Vector(center));
}
/// <summary>
/// create simple AreaReinforcement on vertical straight rectangular wall
/// </summary>
/// <param name="wall"></param>
/// <returns>is successful</returns>
private bool CreateAreaReinOnWall(Wall wall)
{
//make sure selected is basic wall
if (wall.WallType.Kind != WallKind.Basic)
{
MessageBox.Show("Selected wall is not a basic wall.");
return false;
}
GeomHelper helper = new GeomHelper();
Reference refer = null;
CurveArray curves = null;
//check whether wall is vertical rectangular and analytical model shape is line
if (!helper.GetWallGeom(wall, ref refer, ref curves))
{
ApplicationException appEx = new ApplicationException(
"Your selection is not a structural straight rectangular wall.");
throw appEx;
}
AreaReinDataOnWall dataOnWall = new AreaReinDataOnWall();
CreateSimpleAreaReinForm createForm = new
CreateSimpleAreaReinForm(dataOnWall);
//allow use select parameters to create
if (createForm.ShowDialog() == DialogResult.OK)
{
DocCreator creator = m_revit.Application.ActiveUIDocument.Document.Create;
//define the Major Direction of AreaReinforcement,
//we get direction of first Line on the Floor as the Major Direction
Line firstLine = (Line)(curves.get_Item(0));
Autodesk.Revit.DB.XYZ majorDirection = new Autodesk.Revit.DB.XYZ (
firstLine.get_EndPoint(1).X - firstLine.get_EndPoint(0).X,
firstLine.get_EndPoint(1).Y - firstLine.get_EndPoint(0).Y,
firstLine.get_EndPoint(1).Z - firstLine.get_EndPoint(0).Z);
//create AreaReinforcement by NewAreaReinforcement function
AreaReinforcement areaRein = creator.NewAreaReinforcement(wall, curves, majorDirection);
dataOnWall.FillIn(areaRein);
return true;
}
return false;
}
public void Line_Basic()
{
var s = new Autodesk.Revit.DB.XYZ(5, 2, 3);
var e = new Autodesk.Revit.DB.XYZ(10,20,1);
var rl = Autodesk.Revit.DB.Line.CreateBound(s, e);
var pc = rl.ToProtoType(false);
Assert.NotNull(pc);
Assert.IsAssignableFrom<Autodesk.DesignScript.Geometry.Line>(pc);
var pl = (Autodesk.DesignScript.Geometry.Line) pc;
Assert.AreEqual(rl.GetEndPoint(0).ToPoint(false), pl.StartPoint );
Assert.AreEqual(rl.GetEndPoint(1).ToPoint(false), pl.EndPoint );
}
/// <summary>
/// Add 2 Transform Matrix
/// </summary>
/// <param name="tran1"></param>
/// <param name="tran2"></param>
/// <returns></returns>
private Transform AddTransform(Transform tran1, Transform tran2)
{
Autodesk.Revit.DB.XYZ xyz = new Autodesk.Revit.DB.XYZ (0, 0, 0);
Transform result = Transform.get_Translation(xyz);
result.Origin = MathUtil.AddXYZ(tran1.Origin, tran2.Origin);
Autodesk.Revit.DB.XYZ[] left = new Autodesk.Revit.DB.XYZ[3];
Autodesk.Revit.DB.XYZ[] right = new Autodesk.Revit.DB.XYZ[3];
for (int i = 0; i < 3; i++)
{
left[i] = tran1.get_Basis(i);
right[i] = tran2.get_Basis(i);
}
Autodesk.Revit.DB.XYZ[] temp = MathUtil.MultiCross(left, right);
for (int i = 0; i < 3; i++)
{
result.set_Basis(i, temp[i]);
}
return result;
}
public void Ellipse_Basic()
{
var c = new Autodesk.Revit.DB.XYZ(5, 2, 3);
var rx = 10;
var ry = 2.5;
var x = new Autodesk.Revit.DB.XYZ(1,0,0);
var y = new Autodesk.Revit.DB.XYZ(0,1,0);
var sp = 0;
var ep = Math.PI * 2;
var re = Autodesk.Revit.DB.Ellipse.Create(c, rx, ry, x, y, sp, ep);
re.MakeBound(sp, ep);
var pc = re.ToProtoType(false);
Assert.NotNull(pc);
Assert.IsAssignableFrom<Autodesk.DesignScript.Geometry.Ellipse>(pc);
var pa = (Autodesk.DesignScript.Geometry.Ellipse) pc;
// no elliptical arcs yet
//(pa.SweepAngle * Math.PI / 180).AssertShouldBeApproximately(ep - sp);
pa.StartPoint.ShouldBeApproximately(re.GetEndPoint(0));
pa.EndPoint.ShouldBeApproximately(re.GetEndPoint(1));
pa.MajorAxis.Length.ShouldBeApproximately(rx);
pa.MinorAxis.Length.ShouldBeApproximately(ry);
pa.CenterPoint.ShouldBeApproximately(re.Center);
//var tessPts = re.Tessellate();
//// assert the tesselation is very close to original curve
//foreach (var pt in tessPts)
//{
// var closestPt = pa.ClosestPointTo(pt.ToPoint(false));
// Assert.Less(closestPt.DistanceTo(pt.ToPoint(false)), 1e-6);
//}
}
/// <summary>
/// divide a Autodesk.Revit.DB.XYZ by a number
/// </summary>
/// <param name="lhs">divided XYZ</param>
/// <param name="rhs">number</param>
/// <returns>result</returns>
public static Autodesk.Revit.DB.XYZ DivideXYZ(Autodesk.Revit.DB.XYZ lhs, double rhs)
{
return(new Autodesk.Revit.DB.XYZ(lhs.X / rhs, lhs.Y / rhs, lhs.Z / rhs));
}
/// <summary>
/// Place an instance of a Revit group
/// </summary>
/// <param name="point">Location point for the group instance</param>
/// <param name="groupType">The type of the group</param>
/// <returns></returns>
public static Group PlaceGroupInstance(Point point, GroupType groupType)
{
DB.XYZ revitPoint = GeometryPrimitiveConverter.ToXyz(point);
return(new Group(revitPoint, groupType.InternalGroupType));
}
/// <summary>
/// Get max and min coordinates of all points
/// </summary>
/// <returns>points array stores the bound of all points</returns>
public Autodesk.Revit.DB.XYZ[] GetBoundsPoints()
{
Matrix4 matrix = m_to2DMatrix;
Matrix4 inverseMatrix = matrix.Inverse();
double minX = 0, maxX = 0, minY = 0, maxY = 0;
bool bFirstPoint = true;
//get the max and min point on the face
foreach (Autodesk.Revit.DB.XYZ point in m_points)
{
Vector4 v = new Vector4(point);
Vector4 v1 = inverseMatrix.Transform(v);
if (bFirstPoint)
{
minX = maxX = v1.X;
minY = maxY = v1.Y;
bFirstPoint = false;
}
else
{
if (v1.X < minX) { minX = v1.X; }
else if (v1.X > maxX) { maxX = v1.X; }
if (v1.Y < minY) { minY = v1.Y; }
else if (v1.Y > maxY) { maxY = v1.Y; }
}
}
//return an array with max and min value of all points
Autodesk.Revit.DB.XYZ[] resultPoints = new Autodesk.Revit.DB.XYZ[2] {
new Autodesk.Revit.DB.XYZ (minX, minY, 0), new Autodesk.Revit.DB.XYZ (maxX, maxY, 0) };
return resultPoints;
}
/// <summary>
/// Constructor, transform Autodesk.Revit.DB.XYZ to vector
/// </summary>
public Vector4(Autodesk.Revit.DB.XYZ v)
{
this.X = (float)v.X; this.Y = (float)v.Y; this.Z = (float)v.Z;
}
/// <summary>
/// Move a point a give offset along a given direction
/// </summary>
/// <param name="point">The point need to move</param>
/// <param name="direction">The direction the point move to</param>
/// <param name="offset">Tndicate how long to move</param>
/// <returns>The moved point</returns>
public static Autodesk.Revit.DB.XYZ OffsetPoint(Autodesk.Revit.DB.XYZ point, Autodesk.Revit.DB.XYZ direction, double offset)
{
Autodesk.Revit.DB.XYZ directUnit = UnitVector(direction);
Autodesk.Revit.DB.XYZ offsetVect = MultiplyVector(directUnit, offset);
return(AddXYZ(point, offsetVect));
}
/// <summary>
/// transform a Autodesk.Revit.DB.XYZ instance to a Vector instance
/// </summary>
/// <param name="pnt">transformed XYZ</param>
/// <returns>result Vector</returns>
public static Vector XYZ2Vector(Autodesk.Revit.DB.XYZ pnt)
{
return(new Vector(pnt.X, pnt.Y, pnt.Z));
}
/// <summary>
/// Determines whether a edge is vertical.
/// </summary>
/// <param name="edge">The edge to be determined.</param>
/// <returns>Return true if this edge is vertical, or else return false.</returns>
public static bool IsVerticalEdge(Edge edge)
{
List<XYZ> polyline = edge.Tessellate() as List<XYZ>;
Autodesk.Revit.DB.XYZ verticalVct = new Autodesk.Revit.DB.XYZ (0, 0, 1);
Autodesk.Revit.DB.XYZ pointBuffer = polyline[0];
for (int i = 1; i < polyline.Count; i = i + 1)
{
Autodesk.Revit.DB.XYZ temp = polyline[i];
Autodesk.Revit.DB.XYZ vector = GetVector(pointBuffer, temp);
if (Equal(vector, verticalVct))
{
return true;
}
else
{
continue;
}
}
return false;
}
/// <summary>
/// Get a matrix which can move points to center
/// </summary>
/// <returns>matrix used to move point to center of graphics</returns>
public Matrix4 GetMoveToCenterMatrix()
{
//translate the origin to bound center
Autodesk.Revit.DB.XYZ[] bounds = GetBoundsPoints();
Autodesk.Revit.DB.XYZ min = bounds[0];
Autodesk.Revit.DB.XYZ max = bounds[1];
Autodesk.Revit.DB.XYZ center = new Autodesk.Revit.DB.XYZ ((min.X + max.X) / 2, (min.Y + max.Y) / 2, 0);
return new Matrix4(new Vector4(center.X, center.Y, 0));
}
/// <summary>
/// create brace of certain type in certain position between two adjacent columns
/// </summary>
/// <param name="point2D1">one point of the location line in 2D</param>
/// <param name="point2D2">another point of the location line in 2D</param>
/// <param name="baseLevel">the base level of the brace</param>
/// <param name="topLevel">the top level of the brace</param>
/// <param name="braceType">type of beam</param>
/// <param name="isXDirection">whether the location line is in x direction</param>
private void PlaceBrace(Autodesk.Revit.DB.UV point2D1, Autodesk.Revit.DB.UV point2D2, Level baseLevel, Level topLevel, FamilySymbol braceType, bool isXDirection)
{
//get the start points and end points of location lines of two braces
double topHeight = topLevel.Elevation;
double baseHeight = baseLevel.Elevation;
double middleElevation = (topHeight + baseHeight) / 2;
double middleHeight = (topHeight - baseHeight) / 2;
Autodesk.Revit.DB.XYZ startPoint = new Autodesk.Revit.DB.XYZ (point2D1.U, point2D1.V, middleElevation);
Autodesk.Revit.DB.XYZ endPoint = new Autodesk.Revit.DB.XYZ (point2D2.U, point2D2.V, middleElevation);
Autodesk.Revit.DB.XYZ middlePoint;
if (isXDirection)
{
middlePoint = new Autodesk.Revit.DB.XYZ ((point2D1.U + point2D2.U) / 2, point2D2.V, topHeight);
}
else
{
middlePoint = new Autodesk.Revit.DB.XYZ (point2D2.U, (point2D1.V + point2D2.V) / 2, topHeight);
}
//create two brace and set their location line
STRUCTURALTYPE structuralType = Autodesk.Revit.DB.Structure.StructuralType.Brace;
Autodesk.Revit.DB.ElementId levelId = topLevel.Id;
Autodesk.Revit.DB.ElementId startLevelId = baseLevel.Id;
Autodesk.Revit.DB.ElementId endLevelId = topLevel.Id;
Line line1 = m_revit.Application.Create.NewLineBound(startPoint, middlePoint);
FamilyInstance firstBrace = m_revit.ActiveUIDocument.Document.Create.NewFamilyInstance(line1, braceType, baseLevel, structuralType);
Parameter referenceLevel1 = firstBrace.get_Parameter(BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM);
if (null != referenceLevel1)
{
referenceLevel1.Set(levelId);
}
Line line2 = m_revit.Application.Create.NewLineBound(endPoint, middlePoint);
FamilyInstance secondBrace = m_revit.ActiveUIDocument.Document.Create.NewFamilyInstance(line2, braceType, baseLevel, structuralType);
Parameter referenceLevel2 = secondBrace.get_Parameter(BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM);
if (null != referenceLevel2)
{
referenceLevel2.Set(levelId);
}
}
private void GetChordPoints(LineTool chord, CurveArray curves, Autodesk.Revit.Creation.Application createApp)
{
//get coordinates of top chord from lineTool
for (int i = 0; i < chord.Points.Count - 1; i++)
{
Point point = (Point)chord.Points[i];
Point point2 = (Point)chord.Points[i + 1];
Autodesk.Revit.DB.XYZ xyz = new Autodesk.Revit.DB.XYZ (point.X, point.Y, 0);
Autodesk.Revit.DB.XYZ xyz2 = new Autodesk.Revit.DB.XYZ (point2.X, point2.Y, 0);
Vector4 v1 = new Vector4(xyz);
Vector4 v2 = new Vector4(xyz2);
v1 = m_restoreMatrix.Transform(v1);
v2 = m_restoreMatrix.Transform(v2);
try
{
Line line = createApp.NewLineBound(
new Autodesk.Revit.DB.XYZ (v1.X, v1.Y, v1.Z), new Autodesk.Revit.DB.XYZ (v2.X, v2.Y, v2.Z));
curves.Append(line);
}
catch (System.ArgumentException)
{
MessageBox.Show(
"The start point and the end point of the line are too close, please re-draw it.");
ClearChords();
}
}
}
/// <summary>
/// Move a wall, append a node to tree view
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void moveWallButton_Click(object sender, EventArgs e)
{
if (m_lastCreatedWall == null)
return;
// a sub-transaction is not necessary in this case
// it is used for illustration purposes only
using (SubTransaction subTransaction = new SubTransaction(m_document))
{
// if not handled explicitly, the sub-transaction will be rolled back when leaving this block
try
{
if (subTransaction.Start() == TransactionStatus.Started)
{
Autodesk.Revit.DB.XYZ translationVec = new Autodesk.Revit.DB.XYZ(10, 10, 0);
ElementTransformUtils.MoveElement(m_document, m_lastCreatedWall.Id, translationVec);
updateModel(true); // immediately update the view to see the changes
if (subTransaction.Commit() == TransactionStatus.Committed)
{
AddNode(OperationType.ObjectModification, "Moved wall " + m_lastCreatedWall.Id.IntegerValue.ToString());
return;
}
}
}
catch (System.Exception ex)
{
MessageBox.Show("Exception when moving a wall: " + ex.Message);
}
}
MessageBox.Show("Moving wall failed.");
}
/// <summary>
/// constructor
/// </summary>
/// <param name="element">the host object, must be family instance</param>
/// <param name="geoOptions">the geometry option</param>
public GeometrySupport(FamilyInstance element, Options geoOptions)
{
// get the geometry element of the selected element
Autodesk.Revit.DB.GeometryElement geoElement = element.get_Geometry(new Options());
if (null == geoElement || 0 == geoElement.Objects.Size)
{
throw new Exception("Can't get the geometry of selected element.");
}
AnalyticalModel aModel = element.GetAnalyticalModel();
if (aModel == null)
{
throw new Exception("The selected FamilyInstance don't have AnalyticalModel.");
}
AnalyticalModelSweptProfile swProfile = aModel.GetSweptProfile();
if (swProfile == null || !(swProfile.GetDrivingCurve() is Line))
{
throw new Exception("The selected element driving curve is not a line.");
}
// get the driving path and vector of the beam or column
Line line = swProfile.GetDrivingCurve() as Line;
if (null != line)
{
m_drivingLine = line; // driving path
m_drivingVector = GeomUtil.SubXYZ(line.get_EndPoint(1), line.get_EndPoint(0));
}
//get the geometry object
foreach (GeometryObject geoObject in geoElement.Objects)
{
//get the geometry instance which contain the geometry information
GeoInstance instance = geoObject as GeoInstance;
if (null != instance)
{
foreach (GeometryObject o in instance.SymbolGeometry.Objects)
{
// get the solid of beam of column
Solid solid = o as Solid;
// do some checks.
if (null == solid)
{
continue;
}
if (0 == solid.Faces.Size || 0 == solid.Edges.Size)
{
continue;
}
m_solid = solid;
//get the transform value of instance
m_transform = instance.Transform;
// Get the swept profile curves information
if (!GetSweptProfile(solid))
{
throw new Exception("Can't get the swept profile curves.");
}
break;
}
}
}
// do some checks about profile curves information
if (null == m_edges)
{
throw new Exception("Can't get the geometry edge information.");
}
if (4 != m_points.Count)
{
throw new Exception("The sample only work for rectangular beams or columns.");
}
}
public static Point3d ToPoint3d(this DB.XYZ value)
{
var rhino = RawDecoder.AsPoint3d(value); UnitConverter.Scale(ref rhino, UnitConverter.ToRhinoUnits); return(rhino);
}
PlaceColumn( Autodesk.Revit.ApplicationServices.Application rvtApp, Document rvtDoc, Autodesk.Revit.DB.XYZ point2, double angle, FamilySymbol columnType, ElementId baseLevelId, ElementId topLevelId )
{
Autodesk.Revit.DB.XYZ point = point2;
// Note: Must use level-hosted NewFamilyInstance!
Level instLevel = (Level) rvtDoc.GetElement( baseLevelId );
Autodesk.Revit.DB.FamilyInstance column = rvtDoc.Create.NewFamilyInstance( point, columnType, instLevel, StructuralType.Column );
if( column == null )
{
MessageBox.Show( "failed to create an instance of a column." );
return;
}
Autodesk.Revit.DB.XYZ zVec = new Autodesk.Revit.DB.XYZ( 0, 0, 1 );
Autodesk.Revit.DB.Line axis = Line.CreateUnbound( point, zVec );
column.Location.Rotate( axis, angle );
// Set the level Ids
Parameter baseLevelParameter = column.get_Parameter( Autodesk.Revit.DB.BuiltInParameter.FAMILY_BASE_LEVEL_PARAM );
Parameter topLevelParameter = column.get_Parameter( Autodesk.Revit.DB.BuiltInParameter.FAMILY_TOP_LEVEL_PARAM ); ;
baseLevelParameter.Set( baseLevelId );
topLevelParameter.Set( topLevelId );
}
/// <summary>
/// Get triangles in a solid with transform.
/// </summary>
/// <param name="solid">The solid contains triangulars</param>
/// <param name="transform">The transformation.</param>
private void GetTriangular(Document document, Solid solid, Transform transform)
{
// a solid has many faces
FaceArray faces = solid.Faces;
bool hasTransform = (null != transform);
if (0 == faces.Size)
{
return;
}
foreach (Face face in faces)
{
if (face.Visibility != Visibility.Visible)
{
continue;
}
Mesh mesh = face.Triangulate();
if (null == mesh)
{
continue;
}
m_TriangularNumber += mesh.NumTriangles;
PlanarFace planarFace = face as PlanarFace;
// write face to stl file
// a face has a mesh, all meshes are made of triangles
for (int ii = 0; ii < mesh.NumTriangles; ii++)
{
MeshTriangle triangular = mesh.get_Triangle(ii);
double[] xyz = new double[9];
Autodesk.Revit.DB.XYZ normal = new Autodesk.Revit.DB.XYZ();
try
{
Autodesk.Revit.DB.XYZ[] triPnts = new Autodesk.Revit.DB.XYZ[3];
for (int n = 0; n < 3; ++n)
{
double x, y, z;
Autodesk.Revit.DB.XYZ point = triangular.get_Vertex(n);
if (hasTransform)
{
point = transform.OfPoint(point);
}
if (m_Settings.ExportSharedCoordinates)
{
ProjectPosition ps = document.ActiveProjectLocation.GetProjectPosition(point);
x = ps.EastWest;
y = ps.NorthSouth;
z = ps.Elevation;
}
else
{
x = point.X;
y = point.Y;
z = point.Z;
}
if (!m_Settings.Units.Empty())
{
xyz[3 * n] = UnitUtils.ConvertFromInternalUnits(x, m_Settings.Units);
xyz[3 * n + 1] = UnitUtils.ConvertFromInternalUnits(y, m_Settings.Units);
xyz[3 * n + 2] = UnitUtils.ConvertFromInternalUnits(z, m_Settings.Units);
}
else
{
xyz[3 * n] = x;
xyz[3 * n + 1] = y;
xyz[3 * n + 2] = z;
}
var mypoint = new XYZ(xyz[3 * n], xyz[3 * n + 1], xyz[3 * n + 2]);
triPnts[n] = mypoint;
}
Autodesk.Revit.DB.XYZ pnt1 = triPnts[1] - triPnts[0];
normal = pnt1.CrossProduct(triPnts[2] - triPnts[1]);
}
catch (Exception ex)
{
m_TriangularNumber--;
STLDialogManager.ShowDebug(ex.Message);
continue;
}
if (m_Writer is SaveDataAsBinary && m_Settings.ExportColor)
{
Material material = document.GetElement(face.MaterialElementId) as Material;
if (material != null)
{
((SaveDataAsBinary)m_Writer).Color = material.Color;
}
}
m_Writer.WriteSection(normal, xyz);
}
}
}
/// <summary>
/// create beam of certain type in certain position
/// </summary>
/// <param name="point2D1">one point of the location line in 2D</param>
/// <param name="point2D2">another point of the location line in 2D</param>
/// <param name="baseLevel">the base level of the beam</param>
/// <param name="topLevel">the top level of the beam</param>
/// <param name="beamType">type of beam</param>
/// <returns>nothing</returns>
private void PlaceBeam(Autodesk.Revit.DB.UV point2D1, Autodesk.Revit.DB.UV point2D2, Level baseLevel, Level topLevel, FamilySymbol beamType)
{
double height = topLevel.Elevation;
Autodesk.Revit.DB.XYZ startPoint = new Autodesk.Revit.DB.XYZ (point2D1.U, point2D1.V, height);
Autodesk.Revit.DB.XYZ endPoint = new Autodesk.Revit.DB.XYZ (point2D2.U, point2D2.V, height);
Autodesk.Revit.DB.ElementId topLevelId = topLevel.Id;
Line line = m_revit.Application.Create.NewLineBound(startPoint, endPoint);
STRUCTURALTYPE structuralType = Autodesk.Revit.DB.Structure.StructuralType.Beam;
m_revit.ActiveUIDocument.Document.Create.NewFamilyInstance(line, beamType, topLevel, structuralType);
}
/// <summary>
/// Generate a BoundingBoxXYZ instance which used in NewViewSection() method
/// </summary>
/// <returns>true if the instance can be created; otherwise, false.</returns>
Boolean GenerateBoundingBoxXYZ()
{
Transaction transaction = new Transaction(m_project.Document, "GenerateBoundingBox");
transaction.Start();
// First new a BoundingBoxXYZ, and set the MAX and Min property.
m_box = new BoundingBoxXYZ();
m_box.Enabled = true;
Autodesk.Revit.DB.XYZ maxPoint = new Autodesk.Revit.DB.XYZ (LENGTH, LENGTH, 0);
Autodesk.Revit.DB.XYZ minPoint = new Autodesk.Revit.DB.XYZ (-LENGTH, -LENGTH, -HEIGHT);
m_box.Max = maxPoint;
m_box.Min = minPoint;
// Set Transform property is the most important thing.
// It define the Orgin and the directions(include RightDirection,
// UpDirection and ViewDirection) of the created view.
Transform transform = GenerateTransform();
if (null == transform)
{
return false;
}
m_box.Transform = transform;
transaction.Commit();
// If all went well, return true.
return true;
}
/// <summary>
/// create column of certain type in certain position
/// </summary>
/// <param name="point2D">2D coordinate of the column</param>
/// <param name="columnType">type of column</param>
/// <param name="baseLevel">the base level of the column</param>
/// <param name="topLevel">the top level of the column</param>
private void PlaceColumn(Autodesk.Revit.DB.UV point2D, FamilySymbol columnType, Level baseLevel, Level topLevel)
{
//create column of certain type in certain level and start point
Autodesk.Revit.DB.XYZ point = new Autodesk.Revit.DB.XYZ (point2D.U, point2D.V, 0);
STRUCTURALTYPE structuralType;
structuralType = Autodesk.Revit.DB.Structure.StructuralType.Column;
FamilyInstance column = m_revit.ActiveUIDocument.Document.Create.NewFamilyInstance(point, columnType, topLevel, structuralType);
//set base level & top level of the column
if (null != column)
{
Parameter baseLevelParameter = column.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.FAMILY_BASE_LEVEL_PARAM);
Parameter topLevelParameter = column.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.FAMILY_TOP_LEVEL_PARAM);
Parameter topOffsetParameter = column.get_Parameter(BuiltInParameter.FAMILY_TOP_LEVEL_OFFSET_PARAM);
Parameter baseOffsetParameter = column.get_Parameter(BuiltInParameter.FAMILY_BASE_LEVEL_OFFSET_PARAM);
if (null != baseLevelParameter)
{
Autodesk.Revit.DB.ElementId baseLevelId;
baseLevelId = baseLevel.Id;
baseLevelParameter.Set(baseLevelId);
}
if (null != topLevelParameter)
{
Autodesk.Revit.DB.ElementId topLevelId;
topLevelId = topLevel.Id;
topLevelParameter.Set(topLevelId);
}
if (null != topOffsetParameter)
{
topOffsetParameter.Set(0.0);
}
if (null != baseOffsetParameter)
{
baseOffsetParameter.Set(0.0);
}
}
}
/// <summary>
/// Create the arc(ModelArc)
/// </summary>
/// <param name="sketchId">the id of the sketch plane</param>
/// <param name="startPoint">the start point of the arc</param>
/// <param name="endPoint">the end point of the arc</param>
/// <param name="thirdPoint">the third point which is on the arc</param>
public void CreateArc(ElementId sketchId, Autodesk.Revit.DB.XYZ startPoint, Autodesk.Revit.DB.XYZ endPoint, Autodesk.Revit.DB.XYZ thirdPoint)
{
try
{
// First get the sketch plane by the giving element id.
SketchPlane workPlane = GetSketchPlaneById(sketchId);
// Additional check: the start, end and third point should not be the same
if (startPoint.Equals(endPoint) || startPoint.Equals(thirdPoint) ||
endPoint.Equals(thirdPoint))
{
throw new ArgumentException("Three points should not be the same.");
}
// create the geometry arc
Arc geometryArc = Arc.Create(startPoint, endPoint, thirdPoint);
if (null == geometryArc) // assert the creation is successful
{
throw new Exception("Create the geometry arc failed.");
}
// create the ModelArc
ModelArc arc = m_createDoc.NewModelCurve(geometryArc, workPlane) as ModelArc;
if (null == arc) // assert the creation is successful
{
throw new Exception("Create the ModelArc failed.");
}
// Add the created ModelArc into the arc array
m_arcArray.Append(arc);
// Finally refresh information map.
RefreshInformationMap();
}
catch (Exception ex)
{
throw new Exception("Can not create the ModelArc, message: " + ex.Message);
}
}
/// <summary>
/// initialize some member data
/// </summary>
protected virtual void Initialize()
{
double INITANGLE = Math.PI / 4;
RotateX(ref m_origin, INITANGLE);
RotateY(ref m_origin, INITANGLE);
m_transferedMax = new Autodesk.Revit.DB.XYZ (double.MinValue, double.MinValue, double.MinValue);
m_transferedMin = new Autodesk.Revit.DB.XYZ (double.MaxValue, double.MaxValue, double.MaxValue);
}
/// <summary>
/// Create other lines, including Ellipse, HermiteSpline and NurbSpline
/// </summary>
/// <param name="sketchId">the id of the sketch plane</param>
/// <param name="elementId">the element id which copy the curve from</param>
/// <param name="offsetPoint">the offset direction from the copied line</param>
public void CreateOthers(ElementId sketchId, ElementId elementId, Autodesk.Revit.DB.XYZ offsetPoint)
{
// First get the sketch plane by the giving element id.
SketchPlane workPlane = GetSketchPlaneById(sketchId);
// Because the geometry of these lines can't be created by API,
// use an existing geometry to create ModelEllipse, ModelHermiteSpline, ModelNurbSpline
// and then move a bit to make the user see the creation distinctly
// This method use NewModelCurveArray() method to create model lines
CurveArray curves = m_createApp.NewCurveArray();// create a geometry curve array
// Get the Autodesk.Revit.DB.ElementId which used to get the corresponding element
ModelCurve selected = GetElementById(elementId) as ModelCurve;
if (null == selected)
{
throw new Exception("Don't have the element you select");
}
// add the geometry curve of the element
curves.Append(selected.GeometryCurve); // add the geometry ellipse
// Create the model line
ModelCurveArray modelCurves = m_createDoc.NewModelCurveArray(curves, workPlane);
if (null == modelCurves || 1 != modelCurves.Size) // assert the creation is successful
{
throw new Exception("Create the ModelCurveArray failed.");
}
// Offset the create model lines in order to differentiate the existing model lines
foreach (ModelCurve m in modelCurves)
{
ElementTransformUtils.MoveElement(m.Document, m.Id, offsetPoint); // move the lines
}
// Add the created model lines into corresponding array
foreach (ModelCurve m in modelCurves)
{
switch (m.GetType().Name)
{
case "ModelEllipse": // If the line is Ellipse
m_ellipseArray.Append(m); // Add to Ellipse array
break;
case "ModelHermiteSpline": // If the line is HermiteSpline
m_hermiteArray.Append(m); // Add to HermiteSpline array
break;
case "ModelNurbSpline": // If the line is NurbSpline
m_nurbArray.Append(m); // Add to NurbSpline
break;
default:
break;
}
}
// Finally refresh information map.
RefreshInformationMap();
}
