/// <summary>
/// This node will obtain the outline of the Viewport title if one is used. This is the label outline.
/// </summary>
/// <param name="viewport">Viewport to obtain data from.</param>
/// <returns name="labelOutline">The label outline of the viewport.</returns>
/// <search>
/// viewport, Viewport.LabelOutline, rhythm
/// </search>
public static List <Autodesk.DesignScript.Geometry.Curve> LabelOutline(global::Revit.Elements.Element viewport)
{
Autodesk.Revit.DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
//obtain the element id from the sheet
Autodesk.Revit.DB.Viewport internalViewport = (Autodesk.Revit.DB.Viewport)viewport.InternalElement;
//this obtains the label outline
var labelOutline = internalViewport.GetLabelOutline();
//create plane that corresponds to sheet plane
Plane labelPlane = Plane.ByOriginNormal(labelOutline.MaximumPoint.ToPoint(), Vector.ZAxis());
var labelCuboid = Cuboid.ByCorners(labelOutline.MaximumPoint.ToPoint(), labelOutline.MinimumPoint.ToPoint());
var labelSurface = labelCuboid.Intersect(labelPlane);
List <Autodesk.DesignScript.Geometry.Curve[]> labelCurves = new List <Autodesk.DesignScript.Geometry.Curve[]>();
foreach (Surface surf in labelSurface)
{
labelCurves.Add(surf.PerimeterCurves());
}
List <Autodesk.DesignScript.Geometry.Curve> labelSheetCurves = new List <Autodesk.DesignScript.Geometry.Curve>();
//pull the curves onto a plane at 0,0,0
foreach (Autodesk.DesignScript.Geometry.Curve[] curve in labelCurves)
{
foreach (Autodesk.DesignScript.Geometry.Curve c in curve)
{
labelSheetCurves.Add(c.PullOntoPlane(Plane.XY()));
}
}
return(labelSheetCurves);
}
public RsTarget CreateTarget(DGeom.Plane targetPlane)
{
try
{
//create robtarget
RsRobTarget robTarget = new RsRobTarget();
robTarget.Name = rsTask.GetValidRapidName("Target", "_", 1);
//translation
double[] trans = PlaneToTransform(targetPlane);
robTarget.Frame.Translation = new Vector3(trans[0], trans[1], trans[2]);
robTarget.Frame.RX = trans[3];
robTarget.Frame.RY = trans[4];
robTarget.Frame.RZ = trans[5];
//add robtargets to datadeclaration
// rsTask.DataDeclarations.Add(robTarget);
//create target
RsTarget target = new RsTarget(rsWobj, robTarget);
target.Name = robTarget.Name;
target.Attributes.Add(target.Name, true);
//add targets to active task
//rsTask.Targets.Add(target);
return(target);
}
catch (Exception exception)
{
}
return(null);
}
internal Dyn.Geometry EnsureUnit(Dyn.Geometry geo, bool disposeInput = false)
{
Dyn.Geometry scgeo = null;
Dyn.Plane xy = Dyn.Plane.XY();
if (targetUnit == baseUnit)
{
scgeo = geo.Scale(xy, 1, 1, 1);
}
else
{
if (baseUnit == "Meters" && targetUnit == "Feet")
{
double factor = 3.280841666667;
scgeo = geo.Scale(xy, factor, factor, factor);
}
else if (baseUnit == "Feet" && targetUnit == "Meters")
{
double factor = 0.304800164592;
scgeo = geo.Scale(xy, factor, factor, factor);
}
else
{
}
}
if (disposeInput)
{
geo.Dispose();
}
xy.Dispose();
return(scgeo);
}
internal static double[] DSPlaneToDoubleArray(DSPlane pl, bool transpose)
{
double[] a;
if (transpose)
{
a = new double[]
{
pl.XAxis.X, pl.XAxis.Y, pl.XAxis.Z, 0,
pl.YAxis.X, pl.YAxis.Y, pl.YAxis.Z, 0,
pl.Normal.X, pl.Normal.Y, pl.Normal.Z, 0,
pl.Origin.X, pl.Origin.Y, pl.Origin.Z, 1
};
}
else
{
a = new double[]
{
pl.XAxis.X, pl.YAxis.X, pl.Normal.X, pl.Origin.X,
pl.XAxis.Y, pl.YAxis.Y, pl.Normal.Y, pl.Origin.Y,
pl.XAxis.Z, pl.YAxis.Z, pl.Normal.Z, pl.Origin.Z,
0, 0, 0, 1
};
}
return(a);
}
public static Dictionary <string, object> CurveSinusoidalPoints(
Autodesk.DesignScript.Geometry.Curve _Curve,
double WaveLength = 5.0,
double Amplitude = 1.0,
double Resolution = 2.0)
{
double n = (_Curve.Length / WaveLength) * 4 * Resolution;
double _Span = _Curve.Length / n;
List <Autodesk.DesignScript.Geometry.Point> points = new List <Autodesk.DesignScript.Geometry.Point>();
List <double> ks = new List <double>();
for (int i = 0; i < n; i++)
{
double k = Amplitude * Math.Sin(i * _Span * Math.PI * 2 / WaveLength + Math.PI * 2);
Autodesk.DesignScript.Geometry.Plane pl = _Curve.PlaneAtParameter(_Curve.ParameterAtSegmentLength(i * _Span));
Autodesk.DesignScript.Geometry.Point p = _Curve.PointAtSegmentLength(i * _Span);
points.Add((Autodesk.DesignScript.Geometry.Point)p.Translate(pl.YAxis, k));
ks.Add(k);
}
return(new Dictionary <string, object>
{
{ "Points", points },
{ "k", ks }
});
}
public static Dictionary <string, object> CurveSinusoidalPointsWithVoxel(
Autodesk.DesignScript.Geometry.Curve _Curve,
VoxelImage Voxel,
double WaveLength = 5.0,
double Amplitude = 1.0,
double Resolution = 2.0)
{
VoxelChannel _VoxelChannel = Voxel.GetChannel(VoxelImageLayout.SHAPECHANNEL);
double n = (_Curve.Length / WaveLength) * 4 * Resolution;
double _Span = _Curve.Length / n;
List <Autodesk.DesignScript.Geometry.Point> points = new List <Autodesk.DesignScript.Geometry.Point>();
List <double> ks = new List <double>();
for (int i = 0; i < n; i++)
{
Autodesk.DesignScript.Geometry.Plane pl = _Curve.PlaneAtParameter(_Curve.ParameterAtSegmentLength(i * _Span));
Autodesk.DesignScript.Geometry.Point p = _Curve.PointAtSegmentLength(i * _Span);
double FieldValue = V2GVoxel.GetVoxelFieldValue(_VoxelChannel, p.X, p.Y, p.Z);
double k = FieldValue * Amplitude * Math.Sin(i * _Span * Math.PI * 2 / WaveLength + Math.PI * 2);
points.Add((Autodesk.DesignScript.Geometry.Point)p.Translate(pl.YAxis, k));
ks.Add(k);
}
return(new Dictionary <string, object>
{
{ "Points", points },
{ "k", ks }
});
}
public void ByTextSketchPlaneAndPosition_ValidArgs()
{
var origin = Point.ByCoordinates(1, 2, 3);
var normal = Vector.ByCoordinates(0, 0, 1);
var plane = Plane.ByOriginNormal(origin, normal);
var text = "Snickers - why wait?";
var name = "Model Text 1";
var modelTextType = ModelTextType.ByName(name);
var sketchPlane = SketchPlane.ByPlane(plane);
var depth = 1;
var x = 10;
var y = 3;
var mt = ModelText.ByTextSketchPlaneAndPosition(text, sketchPlane, x, y, depth, modelTextType);
Assert.NotNull(mt);
Assert.NotNull(mt.InternalElement);
Assert.IsTrue(DocumentManager.Instance.ElementExistsInDocument(
new ElementUUID(mt.InternalElement.UniqueId)));
mt.Depth.ShouldBeApproximately(depth);
// with unit conversion
InternalDepth(mt).ShouldBeApproximately(depth * UnitConverter.DynamoToHostFactor);
var expectedInternalLoc =
origin.InHostUnits()
.Add(Vector.XAxis().Scale(x * UnitConverter.DynamoToHostFactor))
.Add(Vector.YAxis().Scale(y * UnitConverter.DynamoToHostFactor));
InternalLocation(mt).ShouldBeApproximately(expectedInternalLoc);
}
public static Dictionary <string, object> Display(Autodesk.DesignScript.Geometry.Plane plane, double length = 1000)
{
//Avoid zero length
if (length == 0)
{
length = 1;
}
//Origin and Axes
var pt = plane.Origin;
var lineX = Line.ByStartPointDirectionLength(pt, plane.XAxis, length);
var colorX = DSCore.Color.ByARGB(255, 255, 0, 0);
var lineY = Line.ByStartPointDirectionLength(pt, plane.YAxis, length);
var colorY = DSCore.Color.ByARGB(255, 0, 255, 0);
var lineN = Line.ByStartPointDirectionLength(pt, plane.Normal, length);
var colorN = DSCore.Color.ByARGB(255, 0, 0, 255);
//Plane
var rect = Rectangle.ByWidthLength(plane, length, length);
var colorR = DSCore.Color.ByARGB(50, 50, 50, 50);
//Build List of Display
List <Modifiers.GeometryColor> display = new List <Modifiers.GeometryColor>();
display.Add(Modifiers.GeometryColor.ByGeometryColor(lineX, colorX));
display.Add(Modifiers.GeometryColor.ByGeometryColor(lineY, colorY));
display.Add(Modifiers.GeometryColor.ByGeometryColor(lineN, colorN));
display.Add(Modifiers.GeometryColor.ByGeometryColor(rect, colorR));
//Return values
var d = new Dictionary <string, object>();
d.Add("Display", display);
d.Add("Origin", pt);
d.Add("XAxis", plane.XAxis);
d.Add("YAxis", plane.YAxis);
d.Add("Normal", plane.Normal);
return(d);
}
public static Plane ToPlane(this D.Plane p)
{
var origin = p.Origin.ToPoint3d();
var xAxis = p.XAxis.ToVector3d();
var yAxis = p.YAxis.ToVector3d();
return(new(origin, xAxis, yAxis));
}
public bool isTargetReachable(DGeom.Plane targetPlane)
{
var target = CreateTarget(targetPlane);
var isOk = robot.Task.Mechanism.CanReachAsync(target.RobTarget, target.WorkObject, rsTask.ActiveTool);
isOk.Wait();
return(isOk.Result);
}
public static re.Element WallByProfile(List <dg.PolyCurve> closedProfiles, re.WallType wallType, re.Level level)
{
rdb.Document doc = DocumentManager.Instance.CurrentDBDocument;
// Try to get a wall from trace
var wallElem = ElementBinder.GetElementFromTrace <rdb.Wall>(doc);
dg.PolyCurve closedProfile = closedProfiles[0];
if (!closedProfile.IsClosed || !closedProfile.IsPlanar)
{
DeleteWall(wallElem, true);
return(null);
}
// Verify the wall profile is vertical
dg.Plane basePlane = closedProfile.BasePlane();
if (Math.Abs(basePlane.Normal.Z) > 0.0001)
{
DeleteWall(wallElem, true);
return(null);
}
// Convert Polycurve segments to a list of Revit curves;
List <rdb.Curve> rCrvs = new List <rdb.Curve>();
foreach (dg.PolyCurve pCrv in closedProfiles)
{
List <dg.Curve> dCrvs = pCrv.Curves().ToList();
foreach (dg.Curve dCrv in dCrvs)
{
rdb.Curve rCrv = dCrv.ToRevitType();
rCrvs.Add(rCrv);
}
}
TransactionManager.Instance.EnsureInTransaction(doc);
DeleteWall(wallElem, false);
// Build a wall
try
{
rdb.Wall w = rdb.Wall.Create(doc, rCrvs, new rdb.ElementId(wallType.Id), new rdb.ElementId(level.Id), false);
re.Wall rWall = re.ElementWrapper.ToDSType(w, true) as re.Wall;
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.CleanupAndSetElementForTrace(doc, w);
return(rWall);
}
catch (Exception ex)
{
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.CleanupAndSetElementForTrace(doc, null);
}
return(null);
}
internal static Matrix4x4 DSPlaneToMatrix4x4(DSPlane plane)
{
double[] pl = DSPlaneToDoubleArray(plane, false);
Matrix4x4 m = new Matrix4x4(
(float)pl[0], (float)pl[1], (float)pl[2], (float)pl[3],
(float)pl[4], (float)pl[5], (float)pl[6], (float)pl[7],
(float)pl[8], (float)pl[9], (float)pl[10], (float)pl[11],
(float)pl[12], (float)pl[13], (float)pl[14], (float)pl[15]);
return(m);
}
/// <summary>
/// Reorient all the tracked devices according to the new Plane you set as origin plane.
/// </summary>
/// <param name="NewOriginPlane">New base Plane.</param>
/// <param name="calibrate">Should this plane be used for calibration?</param>
public static void CalibrateOrigin([DefaultArgumentAttribute("Plane.XY();")] DSPlane NewOriginPlane, bool calibrate = true)
{
if (calibrate)
{
CalibrationTransform = Util.DSPlaneToMatrix4x4(NewOriginPlane);
CalibrationTransform = Matrix4x4.Multiply(CalibrationTransform, Matrix4x4.Identity);
}
else
{
CalibrationTransform = Matrix4x4.Identity;
}
}
public static Dictionary <string, object> LocationData(global::Revit.Elements.Element viewport)
{
//obtain the element id from the sheet
Autodesk.Revit.DB.Viewport internalViewport = (Autodesk.Revit.DB.Viewport)viewport.InternalElement;
//obtain the box center of the viewport
var boxCenterInternal = internalViewport.GetBoxCenter().ToPoint();
//Construct new point at sheet elevation of 0
Autodesk.DesignScript.Geometry.Point boxCenter =
Autodesk.DesignScript.Geometry.Point.ByCoordinates(boxCenterInternal.X, boxCenterInternal.Y, 0);
//this obtains the box outline
var boxOutline = internalViewport.GetBoxOutline();
//temporary geometry
var bBox = BoundingBox.ByCorners(boxOutline.MaximumPoint.ToPoint(), boxOutline.MinimumPoint.ToPoint());
var boxCuboid = Cuboid.ByCorners(boxOutline.MaximumPoint.ToPoint(), boxOutline.MinimumPoint.ToPoint());
//create plane that corresponds to sheet plane
Plane boxPlane = Plane.ByOriginNormal(boxOutline.MaximumPoint.ToPoint(), Vector.ZAxis());
var boxSurface = boxCuboid.Intersect(boxPlane);
List <Autodesk.DesignScript.Geometry.Curve[]> boxCurves = new List <Autodesk.DesignScript.Geometry.Curve[]>();
foreach (var geometry in boxSurface)
{
var surf = (Surface)geometry;
boxCurves.Add(surf.PerimeterCurves());
surf.Dispose();
}
List <Autodesk.DesignScript.Geometry.Curve> boxSheetCurves = new List <Autodesk.DesignScript.Geometry.Curve>();
//pull the curves onto a plane at 0,0,0
foreach (Autodesk.DesignScript.Geometry.Curve[] curve in boxCurves)
{
foreach (Autodesk.DesignScript.Geometry.Curve c in curve)
{
boxSheetCurves.Add(c.PullOntoPlane(Plane.XY()));
c.Dispose();
}
}
//dispose of temporary geometries
boxCuboid.Dispose();
boxPlane.Dispose();
//returns the outputs
var outInfo = new Dictionary <string, object>
{
{ "bBox", bBox },
{ "boxCenter", boxCenter },
{ "boxOutline", boxSheetCurves }
};
return(outInfo);
}
private static double IntersectWithPlaneAlongVector(this Curve curve, Plane plane, Vector tangent, double length)
{
// translate the plane along a vector using a distance
Plane offsetPlane = (Plane)plane.Translate(tangent, length);
// Intersect the plane with the curve
Geometry[] intersection = offsetPlane.Intersect(curve);
// If the intersection is one element and it is a point return the parameter of this point
// Otherwise return minus one
if (intersection.Count() == 1 && intersection[0].GetType() == typeof(Point))
return curve.ParameterAtPoint((Point)intersection[0]);
else
return -1;
}
private double[] PlaneToTransform(DGeom.Plane pl)
{
double[] result = new double[6];
//position
result[0] = pl.Origin.X;
result[1] = pl.Origin.Y;
result[2] = pl.Origin.Z;
//rotation
result[3] = (DGeom.Vector.XAxis().AngleWithVector(pl.XAxis) * Math.PI) / 180;
result[3] = (DGeom.Vector.YAxis().AngleWithVector(pl.YAxis) * Math.PI) / 180;
result[3] = (DGeom.Vector.ZAxis().AngleWithVector(pl.Normal) * Math.PI) / 180;
return(result);
}
public void ByTextSketchPlaneAndPosition_BadArgs()
{
var origin = Point.ByCoordinates(1, 2, 3);
var normal = Vector.ByCoordinates(0, 0, 1);
var plane = Plane.ByOriginNormal(origin, normal);
var text = "Snickers - why wait?";
var name = "Model Text 1";
var modelTextType = ModelTextType.ByName(name);
var sketchPlane = SketchPlane.ByPlane(plane);
Assert.Throws(typeof(System.ArgumentNullException), () => ModelText.ByTextSketchPlaneAndPosition(null, sketchPlane, 0, 0, 1, modelTextType));
Assert.Throws(typeof(System.ArgumentNullException), () => ModelText.ByTextSketchPlaneAndPosition(text, null, 0, 0, 1, modelTextType));
Assert.Throws(typeof(System.ArgumentNullException), () => ModelText.ByTextSketchPlaneAndPosition(text, sketchPlane, 0, 0, 1, null));
}
/// <summary>
/// This node will get the bounds of the view in paper space (in feet).
/// </summary>
/// <param name="view">The view to get outline from.</param>
/// <returns name="outline">The bounds of the view in paper space (in feet).</returns>
/// <search>
/// view, outline,rhythm
/// </search>
public static List <Autodesk.DesignScript.Geometry.Curve[]> GetOutline(global::Revit.Elements.Element view)
{
Autodesk.Revit.DB.View internalView = (Autodesk.Revit.DB.View)view.InternalElement;
var viewBbox = internalView.Outline;
var viewCuboid = Cuboid.ByCorners(Point.ByCoordinates(viewBbox.Max.U, viewBbox.Max.V, 0),
Point.ByCoordinates(viewBbox.Min.U, viewBbox.Min.V, 0));
var viewOutlineSurface = viewCuboid.Intersect(Plane.XY());
List <Autodesk.DesignScript.Geometry.Curve[]> viewOutlineCurves =
new List <Autodesk.DesignScript.Geometry.Curve[]>();
foreach (Surface surf in viewOutlineSurface)
{
viewOutlineCurves.Add(surf.PerimeterCurves());
}
return(viewOutlineCurves);
}
private static Autodesk.DesignScript.Geometry.Curve Convert(Autodesk.Revit.DB.Ellipse crv)
{
var isFullEllipse = !crv.IsBound ||
Math.Abs(Math.Abs(crv.GetEndParameter(1) - crv.GetEndParameter(0)) - 2 * Math.PI) < 1e-6;
if (isFullEllipse)
{
return
(Autodesk.DesignScript.Geometry.Ellipse.ByOriginVectors(
crv.Center.ToPoint(false),
(crv.XDirection * crv.RadiusX).ToVector(false),
(crv.YDirection * crv.RadiusY).ToVector(false)));
}
// We need to define the major and minor axis as the curve
// will be trimmed starting from the major axis (not the xaxis)
var major = Math.Max(crv.RadiusX, crv.RadiusY);
var minor = Math.Min(crv.RadiusX, crv.RadiusY);
Vector majorAxis;
Vector minorAxis;
double startParam;
var span = Math.Abs(crv.GetEndParameter(0) - crv.GetEndParameter(1)).ToDegrees();
if (crv.RadiusX > crv.RadiusY)
{
majorAxis = crv.XDirection.ToVector();
minorAxis = crv.YDirection.ToVector();
startParam = crv.GetEndParameter(0).ToDegrees();
}
else
{
majorAxis = crv.YDirection.ToVector().Reverse();
minorAxis = crv.XDirection.ToVector();
startParam = crv.GetEndParameter(0).ToDegrees() + 90;
}
using (var pl = Plane.ByOriginXAxisYAxis(crv.Center.ToPoint(false), majorAxis, minorAxis))
{
return(EllipseArc.ByPlaneRadiiStartAngleSweepAngle(pl, major, minor, startParam, span));
}
}
//**CONSTRUCTORS
/// <summary>
/// Internal constructor for the class that has all geometric inputs to create sliced model
/// </summary>
/// <param name="solid">Solid: geometry that is to be parsed</param>
/// <param name="plane">Plane: primary cutplane</param>
/// <param name="line1">Line1: (optional) defines secondary cutplane</param>
/// <param name="line2">Line2: (optional) defines tertiary cutplane</param>
/// <param name="thickness">Thickness: the thickness of the slices, or the thickness of the material to be used for the assembly</param>
/// <param name="spacing">Spacing: the distance between each slice</param>
internal Slicer(Solid solid, Plane plane, Line line1, Line line2, double thickness, double spacing)
{
Solid = solid;
Thickness = thickness;
Spacing = spacing;
CutPlanesPrimary.AddRange(GenerateCutPlanes(plane));
InitialGeometry = new List<Geometry>();
InitialGeometry.Add(plane);
if (line1 != null)
{
CutPlanesSecondary.AddRange(GenerateCutPlanes(Plane.ByThreePoints(line1.StartPoint, line1.EndPoint, line1.StartPoint.Add(plane.Normal))));
InitialGeometry.Add(line1);
}
if (line2 != null)
{
CutPlanesTertiary.AddRange(GenerateCutPlanes(Plane.ByThreePoints(line2.StartPoint, line2.EndPoint, line2.StartPoint.Add(plane.Normal))));
InitialGeometry.Add(line2);
}
}
private static Autodesk.DesignScript.Geometry.Curve Convert(Autodesk.Revit.DB.Ellipse crv)
{
var isComplete = !crv.IsBound ||
Math.Abs(Math.Abs(crv.GetEndParameter(1) - crv.GetEndParameter(0)) - 2 * Math.PI) < 1e-6;
if (!isComplete)
{
var pl = Plane.ByOriginXAxisYAxis(crv.Center.ToPoint(),
crv.XDirection.ToVector(), crv.YDirection.ToVector());
var s = crv.GetEndParameter(0).ToDegrees();
var e = crv.GetEndParameter(1).ToDegrees();
return(EllipseArc.ByPlaneRadiiStartAngleSweepAngle(pl, crv.RadiusX, crv.RadiusY, s, e - s));
}
return(Autodesk.DesignScript.Geometry.Ellipse.ByOriginVectors(crv.Center.ToPoint(),
(crv.XDirection * crv.RadiusX).ToVector(), (crv.YDirection * crv.RadiusY).ToVector()));
}
public async Task <double[]> CalulateIK(DGeom.Plane targetPlane)
{
double[] jointRot = new double[6];
RsTarget rst = CreateTarget(targetPlane);
try
{
//robot.CalculateInverseKinematicsAsync(rst, rsTask.ActiveTool, true);
var jData = await robot.Task.Mechanism.CalculateInverseKinematicsAsync(rst, rsTask.ActiveTool, false);
return(jData);
}
catch (ABB.Robotics.BaseException exception)
{
throw;
}
catch (Exception exception)
{
throw;
}
return(jointRot);
}
private static Autodesk.DesignScript.Geometry.Curve Convert(Autodesk.Revit.DB.Ellipse crv)
{
var isFullEllipse = !crv.IsBound ||
Math.Abs(Math.Abs(crv.GetEndParameter(1) - crv.GetEndParameter(0)) - 2 * Math.PI) < 1e-6;
if (isFullEllipse)
{
return
(Autodesk.DesignScript.Geometry.Ellipse.ByOriginVectors(
crv.Center.ToPoint(false),
(crv.XDirection * crv.RadiusX).ToVector(false),
(crv.YDirection * crv.RadiusY).ToVector(false)));
}
double startParam;
var span = Math.Abs(crv.GetEndParameter(0) - crv.GetEndParameter(1)).ToDegrees();
startParam = crv.GetEndParameter(0).ToDegrees();
using (var pl = Plane.ByOriginXAxisYAxis(crv.Center.ToPoint(false), crv.XDirection.ToVector(), crv.YDirection.ToVector()))
{
return(EllipseArc.ByPlaneRadiiAngles(pl, crv.RadiusX, crv.RadiusY, startParam, span));
}
}
/// <summary>
/// Split this surface using a plane as cutting tool.
/// </summary>
/// <param name="splittingPlane">Plane as cutting tool.</param>
/// <returns>Array of surfaces.</returns>
public Surface[] Split(Plane splittingPlane)
{
ISurfaceEntity[] splitSurfaces = SurfaceEntity.Split(splittingPlane.HostImpl as IPlaneEntity);
if (null == splitSurfaces || splitSurfaces.Length < 1)
{
throw new System.InvalidOperationException(string.Format(Properties.Resources.OperationFailed, "Surface.Split"));
}
return splitSurfaces.ConvertAll((ISurfaceEntity host) => host.ToSurf(true, this));
}
/// <summary>
///
/// </summary>
/// <param name="curves"></param>
/// <param name="planes"></param>
/// <param name="surfaces"></param>
/// <param name="solids"></param>
/// <param name="selectPoint"></param>
/// <param name="autoExtend"></param>
/// <returns></returns>
public Surface Trim(Curve[] curves, Plane[] planes, Surface[] surfaces, Solid[] solids, Point selectPoint, bool autoExtend)
{
if (null == selectPoint)
throw new System.ArgumentNullException("selectPoint");
ICurveEntity[] hostCurves = curves.ConvertAll(GeometryExtension.ToEntity<Curve, ICurveEntity>);
IPlaneEntity[] hostPlanes = planes.ConvertAll(GeometryExtension.ToEntity<Plane, IPlaneEntity>);
ISurfaceEntity[] hostSurfaces = surfaces.ConvertAll(GeometryExtension.ToEntity<Surface, ISurfaceEntity>);
ISolidEntity[] hostSolids = solids.ConvertAll(GeometryExtension.ToEntity<Solid, ISolidEntity>);
IPointEntity hostPoint = selectPoint.PointEntity;
if (hostCurves == null && hostPlanes == null && hostSurfaces == null && hostSolids == null)
throw new System.ArgumentException(string.Format(Properties.Resources.InvalidInput, "Geometry", "Surface.Trim"));
ISurfaceEntity trimSurface = SurfaceEntity.Trim(hostCurves, hostPlanes, hostSurfaces, hostSolids, hostPoint, autoExtend);
//For trim operation, if the return value is not null, hide the original tools and surfaces.
if (null != trimSurface)
{
Hide(curves);
Hide(planes);
Hide(surfaces);
Hide(solids);
SetVisibility(false);
}
return trimSurface.ToSurf(true, this);
}
public static List<double> PlaneToQuaternian(Plane plane)
{
//Point origin = plane.Origin;
Vector xVect = plane.XAxis;
Vector yVect = plane.YAxis;
Vector zVect = plane.Normal;
double s, trace;
double x1, x2, x3, y1, y2, y3, z1, z2, z3;
double q1, q2, q3, q4;
x1 = xVect.X;
x2 = xVect.Y;
x3 = xVect.Z;
y1 = yVect.X;
y2 = yVect.Y;
y3 = yVect.Z;
z1 = zVect.X;
z2 = zVect.Y;
z3 = zVect.Z;
trace = x1 + y2 + z3 + 1;
if (trace > 0.00001)
{
// s = (trace) ^ (1 / 2) * 2
s = Math.Sqrt(trace) * 2;
q1 = s / 4;
q2 = (-z2 + y3) / s;
q3 = (-x3 + z1) / s;
q4 = (-y1 + x2) / s;
}
else if (x1 > y2 && x1 > z3)
{
//s = (x1 - y2 - z3 + 1) ^ (1 / 2) * 2
s = Math.Sqrt(x1 - y2 - z3 + 1) * 2;
q1 = (z2 - y3) / s;
q2 = s / 4;
q3 = (y1 + x2) / s;
q4 = (x3 + z1) / s;
}
else if (y2 > z3)
{
//s = (-x1 + y2 - z3 + 1) ^ (1 / 2) * 2
s = Math.Sqrt(-x1 + y2 - z3 + 1) * 2;
q1 = (x3 - z1) / s;
q2 = (y1 + x2) / s;
q3 = s / 4;
q4 = (z2 + y3) / s;
}
else
{
//s = (-x1 - y2 + z3 + 1) ^ (1 / 2) * 2
s = Math.Sqrt(-x1 - y2 + z3 + 1) * 2;
q1 = (y1 - x2) / s;
q2 = (x3 + z1) / s;
q3 = (z2 + y3) / s;
q4 = s / 4;
}
List<double> quatDoubles = new List<double>();
quatDoubles.Add(q1);
quatDoubles.Add(q2);
quatDoubles.Add(q3);
quatDoubles.Add(q4);
return quatDoubles;
}
/// <summary>
/// Draws plane at half the scale.
/// </summary>
/// <param name="package"></param>
/// <param name="plane"></param>
/// <param name="name"></param>
private void DrawPlane(ref IRenderPackage package, Plane plane, Planes name)
{
package.Description = string.Format("{0}_{1}_{2}", RenderDescriptions.ManipulatorPlane, Name, name);
using (var vec1 = plane.XAxis.Scale(scale/3))
using (var vec2 = plane.YAxis.Scale(scale/3))
using (var vec3 = plane.YAxis.Scale(scale/3))
{
using (var p1 = Origin.Add(vec1))
using (var p2 = p1.Add(vec2))
using (var p3 = Origin.Add(vec3))
{
var axis = plane.Normal;
var color = GetAxisColor(GetAlignedAxis(axis));
package.AddLineStripVertexCount(3);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(p1.X, p1.Y, p1.Z);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(p2.X, p2.Y, p2.Z);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(p3.X, p3.Y, p3.Z);
}
}
}
internal override IGeometryEntity[] IntersectWithPlane(Plane plane)
{
return SurfaceEntity.IntersectWith(plane.PlaneEntity);
}
/// <summary>
/// Returns the projection of the curve on the plane with given direction
/// Argument Requirement:
/// direction.Length > 0
/// </summary>
/// <param name="contextPlane">Projection plane</param>
/// <param name="direction">Projection direction</param>
/// <returns>Projected curve on the context plane</returns>
public Curve Project(Plane contextPlane, Vector direction)
{
string kMethodName = "Curve.Project";
if (null == contextPlane)
throw new System.ArgumentNullException("contextPlane");
else if (null == direction)
throw new System.ArgumentNullException("direction");
if (direction.Length.EqualsTo(0.0))
throw new System.ArgumentException(string.Format(Properties.Resources.IsZero, "length of the direction vector"), "direction");
if (direction.IsPerpendicular(contextPlane.Normal))
return null;
ICurveEntity entity = CurveEntity.ProjectOn(contextPlane.PlaneEntity, direction.IVector);
if (null == entity)
throw new System.InvalidOperationException(string.Format(Properties.Resources.OperationFailed, kMethodName));
return entity.ToCurve(true, this);
}
/// <summary>
/// Constructors a point by projecting a point on a plane with given project direction.
/// </summary>
/// <param name="contextPlane">Plane of projection</param>
/// <param name="direction">Projection direction</param>
/// <returns>Point</returns>
public Point Project(Plane contextPlane, Vector direction)
{
if (contextPlane == null)
{
throw new ArgumentNullException("contextPlane");
}
else if (direction == null)
{
throw new ArgumentNullException("direction");
}
else if (direction.IsZeroVector())
{
throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, "direction"));
}
else if (direction.IsPerpendicular(contextPlane.Normal))
{
throw new ArgumentException(string.Format(Properties.Resources.IsParallel, "contextPlane", "direction", "Point.Project"));
}
var pt = contextPlane.Project(this, direction);
pt.Context = contextPlane;
pt.ReferencePoint = this;
pt.Direction = direction;
pt.Persist();
return pt;
}
//**PRIVATE FUNCTIONS
/// <summary>
/// This function creates a list of cut planes;
/// Initial cut plane is the plane specified in cosntructor
/// and the rest of the planes are generated from the initial plane
/// and the given spacing.
/// </summary>
/// <param name="plane">initial plane</param>
/// <returns>List containing all cut planes</returns>
private List<Plane> GenerateCutPlanes(Plane plane)
{
List<Plane> Planes = new List<Plane>(); // List for planes that will be returned
List<Plane> upPlanes = new List<Plane>(); // List of planes in normal direction
List<Plane> downPlanes = new List<Plane>(); // List of planes in reverse normal direction
Plane cutplane = plane.Offset(Spacing); // Plane object that is iterated to generate lists
while (Solid.DoesIntersect(cutplane))
{
upPlanes.Add(cutplane);
cutplane = cutplane.Offset(Spacing);
}
cutplane = plane.Offset(0.0 - Spacing);
while (Solid.DoesIntersect(cutplane))
{
downPlanes.Add(cutplane);
cutplane = cutplane.Offset(0.0 - Spacing);
}
downPlanes.Reverse();
Planes.AddRange(downPlanes);
Planes.Add(plane);
Planes.AddRange(upPlanes);
return Planes;
}
/// <summary>
/// Create robot Pose from plane.
/// </summary>
/// <param name="plane">Plane</param>
/// <returns></returns>
public static Pose RobotPoseAtPlane(Plane plane)
{
var r = new Pose();
r.Trans.X = (float)plane.Origin.X;
r.Trans.Y = (float)plane.Origin.Y;
r.Trans.Z = (float)plane.Origin.Z;
List<double> quatDoubles = RobotUtils.PlaneToQuaternian(plane);
r.Rot.Q1 = (float)quatDoubles[0];
r.Rot.Q2 = (float)quatDoubles[1];
r.Rot.Q3 = (float)quatDoubles[2];
r.Rot.Q4 = (float)quatDoubles[3];
return r;
}
/// <summary>
/// Get list of quaternions from a plane.
/// </summary>
/// <param name="plane">The plane</param>
/// <returns></returns>
public static List<double> QuatListAtPlane(Plane plane)
{
List<double> quats = new List<double>();
if (plane != null)
{
List<double> quatDoubles = RobotUtils.PlaneToQuaternian(plane);
quats.Add(quatDoubles[0]);
quats.Add(quatDoubles[1]);
quats.Add(quatDoubles[2]);
quats.Add(quatDoubles[3]);
}
return quats;
}
/// <summary><para>
/// Returns an array of planes located on the curve with equal distance.
/// The tangents at the points are the normals of the planes. </para>
/// <para> Argument Requirement:
/// numberOfPoints > 0
/// </para>
/// </summary>
/// <param name="numberOfPlanes"></param>
/// <returns></returns>
public Plane[] PlanesAtEqualArcLength(int numberOfPlanes)
{
if (numberOfPlanes < 1)
throw new System.ArgumentException(string.Format(Properties.Resources.LessThan, "number of planes", "one"), "numberOfPlanes");
IPointEntity[] pts = PointsAtEqualArcLengthCore(numberOfPlanes);
if (null == pts)
throw new System.ArgumentException(string.Format(Properties.Resources.InvalidArguments, "number of planes"), "numberOfPlanes");
Plane[] plns = new Plane[pts.Length];
int i = 0;
foreach (var p in pts)
{
double param = CurveEntity.ParameterAtPoint(p);
try
{
plns[i++] = PlaneAtParameter(param);
}
catch
{
//Proceed with next iteration.
}
p.Dispose();
}
return plns;
}
/// <summary>
/// Convert a DS Plane to a Revit Plane.
/// </summary>
/// <param name="plane"></param>
/// <returns></returns>
public static Autodesk.Revit.DB.Plane ToPlane(this Autodesk.DesignScript.Geometry.Plane plane)
{
return(new Autodesk.Revit.DB.Plane(plane.Normal.ToXyz(), plane.Origin.ToXyz()));
}
/// <summary>
///
/// </summary>
/// <param name="planes"></param>
/// <param name="selectPoint"></param>
/// <param name="autoExtend"></param>
/// <returns></returns>
public Surface Trim(Plane[] planes, Point selectPoint, bool autoExtend)
{
if(null == planes)
throw new System.ArgumentNullException("planes");
return Trim(null, planes, null, null, selectPoint, autoExtend);
}
/// <summary>
/// Performs hit test on Gizmo to find out hit object. The returned
/// hitObject could be either axis vector or a plane.
/// </summary>
/// <param name="source">Mouse click source for hit test</param>
/// <param name="direction">View projection direction</param>
/// <param name="hitObject">object hit</param>
/// <returns>True if Gizmo was hit successfully</returns>
public bool HitTest(Point source, Vector direction, out object hitObject)
{
hitAxis = null;
hitPlane = null; //reset hit objects
hitObject = HitTest(source, direction);
hitAxis = hitObject as Vector;
if (hitAxis == null)
{
hitPlane = hitObject as Plane;
}
return hitObject != null;
}
//**CREATE
/// <summary>
/// Construct an instance of slicer via a static method.
/// This makes vertical stacks of given solid
/// with each stack being of specified thickness
/// and with given plane as the initial cutplane
/// </summary>
/// <param name="solid">Solid: geometry that is to be parsed</param>
/// <param name="plane">Plane: primary cutplane</param>
/// <param name="line1">Line1: (optional) defines secondary cutplane</param>
/// <param name="line2">Line2: (optional) defines tertiary cutplane</param>
/// <param name="thickness">Thickness: the thickness of the slices, or the thickness of the material to be used for the assembly</param>
/// <param name="spacing">Spacing: the distance between each slice</param>
/// <returns>A newly-constructed Slicer object</returns>
public static Slicer ByPlaneAndLines(Solid solid, Plane plane, Line line1 = null, Line line2 = null, double thickness = 1, double spacing = 0)
{
if (!solid.DoesIntersect(plane)) throw new ArgumentException("plane does not intersection solid");
if (line1.Direction.IsParallel(plane.Normal)) throw new ArgumentException("line is perpendicular to plane");
if (line2.Direction.IsParallel(plane.Normal)) throw new ArgumentException("line is perpendicular to plane");
return new Slicer(solid, plane, line1, line2, thickness, spacing);
}
/// <summary>
/// Convert a DesignScript plane to a Nucleus one
/// </summary>
/// <param name="plane"></param>
/// <returns></returns>
public static Plane Convert(DS.Plane plane)
{
return(new Plane(Convert(plane.Origin), Convert(plane.XAxis), Convert(plane.YAxis)));
}
/// <summary>
/// Define tooldata from plane and load value.
/// </summary>
/// <param name="pl">Plane</param>
/// <param name="load">Load in kg</param>
/// <param name="name">Name of tooldata variable</param>
/// <returns></returns>
public static List<string> ToolAtPlane(Plane pl, object load, string name)
{
List<string> toolData = new List<string>();
List<double> quats = RobotUtils.PlaneToQuaternian(pl);
string tool = string.Format("\tPERS tooldata {0}:=[TRUE,[[{1},{2},{3}],[{4},{5},{6},{7}]],[{8},[0,0,0.001],[1,0,0,0],0,0,0]];\n", name, pl.Origin.X, pl.Origin.Y, pl.Origin.Z, quats[0], quats[1], quats[2], quats[3], load);
toolData.Add(tool);
return toolData;
}
/// <summary>
/// Constructors a point by projecting a point on a plane. It is
/// equivalent to finding the nearest point on the plane.
/// </summary>
/// <param name="contextPlane">Plane of projection</param>
/// <returns>Point</returns>
public Point Project(Plane contextPlane)
{
if (contextPlane == null)
{
throw new ArgumentNullException("contextPlane");
}
var pt = contextPlane.Project(this);
pt.Context = contextPlane;
pt.ReferencePoint = this;
pt.Persist();
return pt;
}
/// <summary>
/// Define wobjdata from plane.
/// </summary>
/// <param name="pl">Plane</param>
/// <param name="name">Name of wobjdata variable</param>
/// <returns></returns>
public static List<string> WobjAtPlane(Plane pl, string name)
{
List<string> wobjData = new List<string>();
List<double> quats = RobotUtils.PlaneToQuaternian(pl);
string wobj = string.Format("\tTASK PERS wobjdata {0}:=[FALSE,TRUE," + @"""""" + ",[[{1},{2},{3}],[{4},{5},{6},{7}]],[[0,0,0],[1,0,0,0]]];\n", name, pl.Origin.X, pl.Origin.Y, pl.Origin.Z, quats[0], quats[1], quats[2], quats[3]);
wobjData.Add(wobj);
return wobjData;
}
/// <summary>
/// Returns the projection of this curve on a given plane with plane
/// normal as direction
/// </summary>
/// <param name="contextPlane">Projection plane</param>
/// <returns>Projected curve on the context plane</returns>
public Curve Project(Plane contextPlane)
{
string kMethodName = "Curve.Project";
if (null == contextPlane)
throw new System.ArgumentNullException("contextPlane");
ICurveEntity entity = CurveEntity.ProjectOn(contextPlane.PlaneEntity, contextPlane.Normal.IVector);
if (entity == null)
throw new System.InvalidOperationException(string.Format(Properties.Resources.OperationFailed, kMethodName));
return entity.ToCurve(true, this);
}
internal static IEnumerable<Curve> FromStringOriginAndScale(string text, Plane originPlane, double scale = 1.0)
{
//http://msdn.microsoft.com/en-us/library/ms745816(v=vs.110).aspx
var crvs = new List<Curve>();
var font = new System.Windows.Media.FontFamily("Arial");
var fontStyle = FontStyles.Normal;
var fontWeight = FontWeights.Medium;
// Create the formatted text based on the properties set.
var formattedText = new FormattedText(
text,
CultureInfo.GetCultureInfo("en-us"),
FlowDirection.LeftToRight,
new Typeface(
font,
fontStyle,
fontWeight,
FontStretches.Normal),
1,
System.Windows.Media.Brushes.Black // This brush does not matter since we use the geometry of the text.
);
// Build the geometry object that represents the text.
var textGeometry = formattedText.BuildGeometry(new System.Windows.Point(0, 0));
foreach (var figure in textGeometry.GetFlattenedPathGeometry().Figures)
{
var init = figure.StartPoint;
var a = figure.StartPoint;
System.Windows.Point b;
foreach (var segment in figure.GetFlattenedPathFigure().Segments)
{
var lineSeg = segment as LineSegment;
if (lineSeg != null)
{
b = lineSeg.Point;
var crv = LineBetweenPoints(originPlane.Origin, 0.5*scale, a, b);
a = b;
CoordinateSystem localWorldcs = CoordinateSystem.ByOrigin(originPlane.Origin);
Curve rotC = (Curve)crv.Transform(localWorldcs, originPlane.ToCoordinateSystem());
crvs.Add(rotC);
}
var plineSeg = segment as PolyLineSegment;
if (plineSeg != null)
{
foreach (var segPt in plineSeg.Points)
{
var crv = LineBetweenPoints(originPlane.Origin, 0.5 * scale, a, segPt);
a = segPt;
CoordinateSystem localWorldcs = CoordinateSystem.ByOrigin(originPlane.Origin);
Curve rotC = (Curve)crv.Transform(localWorldcs, originPlane.ToCoordinateSystem());
crvs.Add(rotC);
}
}
}
}
return crvs;
}
internal override IGeometryEntity[] IntersectWithPlane(Plane plane)
{
ILineEntity line = PlaneEntity.IntersectWith(plane.PlaneEntity);
if (null != line)
return new IGeometryEntity[] { line };
return null;
}
internal static DSPlane CoordinateSystemToPlane(CoordinateSystem cs)
{
DSPlane pl = DSPlane.ByOriginXAxisYAxis(cs.Origin, cs.XAxis, cs.YAxis);
return(pl);
}
/// <summary>
/// Create robot target from plane.
/// </summary>
/// <param name="plane">Plane</param>
/// <returns></returns>
public static RobTarget RobTargetAtPlane(Plane plane)
{
var target = new RobTarget();
if (plane != null)
{
List<double> quatDoubles = RobotUtils.PlaneToQuaternian(plane);
target.FillFromString2(
string.Format(
"[[{0},{1},{2}],[{3},{4},{5},{6}],[0,0,0,0],[9.999999999E09,9.999999999E09,9.999999999E09,9.999999999E09,9.999999999E09,9.999999999E09]];",
plane.Origin.X, plane.Origin.Y, plane.Origin.Z, quatDoubles[0], quatDoubles[1], quatDoubles[2], quatDoubles[3]));
}
return target;
}
private Plane[][] ShiftCutPlanes(List<Plane> planes, double thickness)
{
Plane[] shiftUp = new Plane[planes.Count];
Plane[] shiftDown = new Plane[planes.Count];
for (int i = 0; i < planes.Count; i++)
{
shiftUp[i] = planes[i].Offset(thickness / 2.0);
shiftDown[i] = planes[i].Offset(- thickness / 2.0);
}
Plane[][] shifted = {shiftUp, shiftDown};
return shifted;
}
/// <summary>
/// Draws plane at half the scale.
/// </summary>
/// <param name="package"></param>
/// <param name="plane"></param>
/// <param name="name"></param>
private void DrawPlane(ref IRenderPackage package, Plane plane, Planes name)
{
package.Description = string.Format("{0}_{1}_{2}", RenderDescriptions.ManipulatorPlane, Name, name.ToString());
var p1 = Origin.Add(plane.XAxis.Scale(scale/2));
var p2 = p1.Add(plane.YAxis.Scale(scale/2));
var p3 = Origin.Add(plane.YAxis.Scale(scale/2));
package.AddLineStripVertexCount(3);
package.AddLineStripVertexColor(0, 0, 255, 255);
package.AddLineStripVertex(p1.X, p1.Y, p1.Z);
package.AddLineStripVertexColor(0, 0, 255, 255);
package.AddLineStripVertex(p2.X, p2.Y, p2.Z);
package.AddLineStripVertexColor(0, 0, 255, 255);
package.AddLineStripVertex(p3.X, p3.Y, p3.Z);
}
/// <summary>
/// Create a Revit Floor given it's curve outline and Level
/// </summary>
/// <param name="outline">The outline.</param>
/// <param name="floorType">Type of the floor.</param>
/// <param name="level">The level.</param>
/// <param name="structural">if set to <c>true</c> [structural].</param>
/// <returns>
/// The floor
/// </returns>
public static SlopedFloor ByOutlineTypeAndLevel(Autodesk.DesignScript.Geometry.PolyCurve outline, Revit.Elements.FloorType floorType, Revit.Elements.Level level, bool structural)
{
Utils.Log(string.Format("SlopedFloor.ByOutlineTypeAndLevel started...", ""));
try
{
var profile = new CurveArray();
Autodesk.DesignScript.Geometry.Plane plane = Autodesk.DesignScript.Geometry.Plane.ByBestFitThroughPoints(
outline.Curves().Cast <Autodesk.DesignScript.Geometry.Curve>().Select(x => x.StartPoint));
Vector normal = plane.Normal;
if (normal.Dot(Vector.ZAxis()) <= 0)
{
normal = normal.Reverse();
}
Autodesk.DesignScript.Geometry.Point origin = plane.Origin;
Autodesk.DesignScript.Geometry.Point end = origin.Add(normal);
Autodesk.DesignScript.Geometry.Point projection = Autodesk.DesignScript.Geometry.Point.ByCoordinates(end.X, end.Y, -1000);
end = Autodesk.DesignScript.Geometry.Point.ByCoordinates(end.X, end.Y, end.Z + 1000);
Autodesk.DesignScript.Geometry.Point intersection = null;
var result = plane.Intersect(Autodesk.DesignScript.Geometry
.Line.ByStartPointEndPoint(end, projection));
if (result.Length > 0)
{
intersection = result[0] as Autodesk.DesignScript.Geometry.Point;
}
else
{
var message = "Couldn't find intersection";
Utils.Log(string.Format("ERROR: SlopedFloor.ByOutlineTypeAndLevel {0}", message));
throw new Exception(message);
}
Autodesk.DesignScript.Geometry.Curve temp = Autodesk.DesignScript.Geometry.Line.ByBestFitThroughPoints(new Autodesk.DesignScript.Geometry.Point[] { origin, intersection });
PolyCurve flat = PolyCurve.ByJoinedCurves(outline.PullOntoPlane(Autodesk.DesignScript.Geometry.Plane.XY()
.Offset(temp.StartPoint.Z)).Explode().Cast <Autodesk.DesignScript.Geometry.Curve>().ToList());
Autodesk.DesignScript.Geometry.Curve flatLine = temp.PullOntoPlane(Autodesk.DesignScript.Geometry.Plane.XY().Offset(temp.StartPoint.Z));
if (Math.Abs(Math.Abs(plane.Normal.Dot(Vector.ZAxis())) - 1) < 0.00001)
{
var f = Revit.Elements.Floor.ByOutlineTypeAndLevel(flat, floorType, level);
f.InternalElement.Parameters.Cast <Autodesk.Revit.DB.Parameter>()
.First(x => x.Id.IntegerValue.Equals(Autodesk.Revit.DB.BuiltInParameter.FLOOR_PARAM_IS_STRUCTURAL))
.Set(structural ? 1 : 0);
plane.Dispose();
flatLine.Dispose();
flat.Dispose();
origin.Dispose();
end.Dispose();
projection.Dispose();
intersection.Dispose();
temp.Dispose();
return(new SlopedFloor(f.InternalElement as Autodesk.Revit.DB.Floor));
}
double slope = (temp.EndPoint.Z - temp.StartPoint.Z) / flatLine.Length;
foreach (Autodesk.DesignScript.Geometry.Curve c in flat.Curves())
{
profile.Append(c.ToRevitType());
}
Autodesk.Revit.DB.Line slopeArrow = flatLine.ToRevitType() as Autodesk.Revit.DB.Line;
var ft = floorType.InternalElement as Autodesk.Revit.DB.FloorType;
var lvl = level.InternalElement as Autodesk.Revit.DB.Level;
var floor = new SlopedFloor(profile, slopeArrow, slope, ft, lvl, structural);
floor.Level = level;
floor.Floortype = floorType;
floor.Structural = structural;
//DocumentManager.Regenerate();
plane.Dispose();
flatLine.Dispose();
flat.Dispose();
origin.Dispose();
end.Dispose();
projection.Dispose();
intersection.Dispose();
temp.Dispose();
Utils.Log(string.Format("SlopedFloor.ByOutlineTypeAndLevel completed.", ""));
return(floor);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: SlopedFloor.ByOutlineTypeAndLevel {0}", ex.Message));
throw ex;
}
}
/// <summary>
/// Gets the rectangular openings.
/// </summary>
/// <returns></returns>
/// <remarks>This method uses walls, doors, windows and generic models bounding boxes to determine the rectangles.
/// These objects can be in the host file or in linked Revit files.</remarks>
public static IList <Autodesk.DesignScript.Geometry.Rectangle> GetRectangularOpenings()
{
Utils.Log(string.Format("OpeningUtils.GetRectangularOpenings started...", ""));
Autodesk.Revit.DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
//look for Walls, Doors, Windows, Generic Models in the current document and in the linked documents
ElementCategoryFilter wallFilter = new ElementCategoryFilter(BuiltInCategory.OST_Walls);
ElementCategoryFilter doorFilter = new ElementCategoryFilter(BuiltInCategory.OST_Doors);
ElementCategoryFilter windowFilter = new ElementCategoryFilter(BuiltInCategory.OST_Windows);
ElementCategoryFilter genericFilter = new ElementCategoryFilter(BuiltInCategory.OST_GenericModel);
IList <ElementFilter> filterList = new List <ElementFilter>()
{
wallFilter, doorFilter, windowFilter, genericFilter
};
LogicalOrFilter orFilter = new LogicalOrFilter(filterList);
IList <Autodesk.DesignScript.Geometry.Solid> solids = new List <Autodesk.DesignScript.Geometry.Solid>();
IList <Autodesk.DesignScript.Geometry.Rectangle> output = new List <Autodesk.DesignScript.Geometry.Rectangle>();
foreach (Autodesk.Revit.DB.Element e in new FilteredElementCollector(doc)
.WherePasses(orFilter)
.WhereElementIsNotElementType()
.Where(x =>
x.Parameters.Cast <Autodesk.Revit.DB.Parameter>()
.First(p => p.Id.IntegerValue == (int)BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).HasValue))
{
string comments = e.Parameters.Cast <Autodesk.Revit.DB.Parameter>().First(p => p.Id.IntegerValue == (int)BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).AsString();
if (comments.ToLower() != "opening")
{
continue;
}
Transform tr = Transform.Identity;
if (e is Instance)
{
Instance instance = e as Instance;
tr = instance.GetTotalTransform();
}
IList <Autodesk.Revit.DB.Solid> temp = new List <Autodesk.Revit.DB.Solid>();
foreach (GeometryObject go in e.get_Geometry(new Options()))
{
if (go is GeometryInstance)
{
GeometryInstance geoInstance = go as GeometryInstance;
foreach (var gi in geoInstance.SymbolGeometry)
{
if (gi is Autodesk.Revit.DB.Solid)
{
Autodesk.Revit.DB.Solid s = gi as Autodesk.Revit.DB.Solid;
s = SolidUtils.CreateTransformed(s, tr);
temp.Add(s);
}
}
}
else
{
if (go is Autodesk.Revit.DB.Solid)
{
Autodesk.Revit.DB.Solid s = go as Autodesk.Revit.DB.Solid;
s = SolidUtils.CreateTransformed(s, tr);
temp.Add(s);
}
}
}
if (temp.Count > 0)
{
Autodesk.Revit.DB.Solid s0 = temp[0];
for (int i = 1; i < temp.Count; ++i)
{
s0 = BooleanOperationsUtils.ExecuteBooleanOperation(s0, temp[i], BooleanOperationsType.Union);
}
solids.Add(s0.ToProtoType());
}
}
foreach (RevitLinkInstance rli in new FilteredElementCollector(doc).OfClass(typeof(RevitLinkInstance)).WhereElementIsNotElementType())
{
Autodesk.Revit.DB.Document link = rli.GetLinkDocument();
foreach (Autodesk.Revit.DB.Element e in new FilteredElementCollector(link)
.WherePasses(orFilter)
.WhereElementIsNotElementType()
.Where(x =>
x.Parameters.Cast <Autodesk.Revit.DB.Parameter>()
.First(p => p.Id.IntegerValue == (int)BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).HasValue))
{
Transform tr = rli.GetTotalTransform();
string comments = e.Parameters.Cast <Autodesk.Revit.DB.Parameter>().First(p => p.Id.IntegerValue == (int)BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).AsString();
if (comments.ToLower() != "opening")
{
continue;
}
if (e is Instance)
{
Instance instance = e as Instance;
tr = tr.Multiply(instance.GetTotalTransform());
}
IList <Autodesk.Revit.DB.Solid> temp = new List <Autodesk.Revit.DB.Solid>();
foreach (var go in e.get_Geometry(new Options()))
{
if (go is GeometryInstance)
{
GeometryInstance geoInstance = go as GeometryInstance;
foreach (var gi in geoInstance.SymbolGeometry)
{
if (gi is Autodesk.Revit.DB.Solid)
{
Autodesk.Revit.DB.Solid s = gi as Autodesk.Revit.DB.Solid;
s = SolidUtils.CreateTransformed(s, tr);
temp.Add(s);
}
}
}
else
{
if (go is Autodesk.Revit.DB.Solid)
{
Autodesk.Revit.DB.Solid s = go as Autodesk.Revit.DB.Solid;
s = SolidUtils.CreateTransformed(s, tr);
temp.Add(s);
}
}
}
if (temp.Count > 0)
{
Autodesk.Revit.DB.Solid s0 = temp[0];
for (int i = 1; i < temp.Count; ++i)
{
s0 = BooleanOperationsUtils.ExecuteBooleanOperation(s0, temp[i], BooleanOperationsType.Union);
}
solids.Add(s0.ToProtoType());
}
}
}
foreach (var s in solids)
{
IList <Autodesk.DesignScript.Geometry.Point> points = new List <Autodesk.DesignScript.Geometry.Point>();
foreach (var v in s.Vertices)
{
points.Add(v.PointGeometry);
}
points = Autodesk.DesignScript.Geometry.Point.PruneDuplicates(points);
Autodesk.DesignScript.Geometry.Plane plane = Autodesk.DesignScript.Geometry.Plane.ByBestFitThroughPoints(points);
plane = Autodesk.DesignScript.Geometry.Plane.ByOriginNormal(points.Last(), plane.Normal);
IList <Autodesk.DesignScript.Geometry.Point> temp = new List <Autodesk.DesignScript.Geometry.Point>();
foreach (var p in points)
{
foreach (var q in p.Project(plane, plane.Normal))
{
temp.Add(q as Autodesk.DesignScript.Geometry.Point);
}
foreach (var q in p.Project(plane, plane.Normal.Reverse()))
{
temp.Add(q as Autodesk.DesignScript.Geometry.Point);
}
}
temp = Autodesk.DesignScript.Geometry.Point.PruneDuplicates(temp);
CoordinateSystem cs = CoordinateSystem.ByPlane(plane);
IList <Autodesk.DesignScript.Geometry.Point> relative = new List <Autodesk.DesignScript.Geometry.Point>();
foreach (var p in temp)
{
relative.Add(p.Transform(cs.Inverse()) as Autodesk.DesignScript.Geometry.Point);
}
var min = Autodesk.DesignScript.Geometry.Point.ByCoordinates(relative.Min(p => p.X),
relative.Min(p => p.Y),
relative.Min(p => p.Z));
var max = Autodesk.DesignScript.Geometry.Point.ByCoordinates(relative.Max(p => p.X),
relative.Max(p => p.Y),
relative.Max(p => p.Z));
double width = max.X - min.X;
double height = max.Y - min.Y;
min = min.Transform(cs) as Autodesk.DesignScript.Geometry.Point;
max = max.Transform(cs) as Autodesk.DesignScript.Geometry.Point;
plane = Autodesk.DesignScript.Geometry.Plane.ByOriginNormal(Autodesk.DesignScript.Geometry.Line.ByStartPointEndPoint(min, max).PointAtParameter(0.5), plane.Normal);
Autodesk.DesignScript.Geometry.Rectangle rectangle = Autodesk.DesignScript.Geometry.Rectangle.ByWidthLength(plane,
width,
height);
output.Add(rectangle);
plane.Dispose();
cs.Dispose();
min.Dispose();
max.Dispose();
}
Utils.Log(string.Format("OpeningUtils.GetRectangularOpenings completed.", ""));
return(output);
}
public static Dictionary<string, double> QuatAtPlane(Plane plane)
{
List<double> quats = new List<double>();
if (plane != null)
{
List<double> quatDoubles = RobotUtils.PlaneToQuaternian(plane);
quats.Add(quatDoubles[0]);
quats.Add(quatDoubles[1]);
quats.Add(quatDoubles[2]);
quats.Add(quatDoubles[3]);
}
return new Dictionary<string, double>
{
{"q1", quats[0]},
{"q2", quats[1]},
{"q3", quats[2]},
{"q4", quats[3]}
};
}
public static Autodesk.Revit.DB.Plane ToPlane(this Autodesk.DesignScript.Geometry.Plane plane, bool convertUnits = true)
{
return(Autodesk.Revit.DB.Plane.CreateByNormalAndOrigin(plane.Normal.ToXyz(), plane.Origin.ToXyz(convertUnits)));
}
/// <summary>
/// Returns a plane at a point on the curve by given paramater and use
/// the tangent at the point as Normal of the plane. This method can
/// specify the size of the plane.
/// Argument Requirement:
/// planeSize >= 1
/// </summary>
/// <param name="param"></param>
/// <param name="planeSize"></param>
/// <returns></returns>
public Plane PlaneAtParameter(double param, double planeSize)
{
var origin = CurveEntity.PointAtParameter(param).ToPoint(false, null);
var tangent = TangentAtParameter(param);
Plane result = new Plane(origin, tangent, planeSize, true, this);
result.T = param;
result.Distance = CurveEntity.DistanceAtParameter(param);
return result;
}
