private static IArcEntity ByCenterPointRadiusAngleCore(Point centerPoint, double radius, double startAngle, double sweepAngle, ref Vector normal) { if (centerPoint == null) { throw new ArgumentNullException("centerPoint"); } else if (normal == null) { throw new ArgumentNullException("normal"); } else if (radius <= 0.0) { throw new ArgumentException(string.Format(Properties.Resources.LessThanZero, "radius")); } else if (normal.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, normal), "normal"); } normal = normal.IsNormalized ? normal : normal.Normalize(); var endAngle = (startAngle + sweepAngle); IArcEntity entity = HostFactory.Factory.ArcByCenterPointRadiusAngle(centerPoint.PointEntity, radius, GeometryExtension.DegreesToRadians(startAngle), GeometryExtension.DegreesToRadians(endAngle), normal.IVector); if (null == entity) { throw new Exception(string.Format(Properties.Resources.OperationFailed, "Arc.ByCenterPointRadiusAngle")); } return(entity); }
private static ICircleEntity ByCenterPointRadiusCore(Point centerPoint, double radius, ref Vector normal) { if (null == centerPoint) { throw new ArgumentNullException("centerPoint"); } if (null == normal) { throw new ArgumentNullException("normal"); } if (normal.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, "normal"), "normal"); } if (radius <= 0.0) { throw new ArgumentException(Properties.Resources.IsZeroRadius); } normal = normal.IsNormalized ? normal : normal.Normalize(); ICircleEntity entity = HostFactory.Factory.CircleByCenterPointRadius(centerPoint.PointEntity, radius, normal.IVector); if (null == entity) { throw new Exception(string.Format(Properties.Resources.OperationFailed, "Circle.ByCenterPointRadius")); } return(entity); }
private static ILineEntity ByStartPointDirectionLengthCore(Point startPt, Vector direction, double length) { if (startPt == null) { throw new ArgumentNullException("startPt"); } else if (direction == null) { throw new ArgumentNullException("direction"); } else if (direction.IsZeroVector() || length == 0.0) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, "direction")); } else if (length == 0.0) { throw new ArgumentException(Properties.Resources.IsZeroLength); } //Temporary end point is created by translating, should be disposed Vector offset = direction.Normalize().MultiplyBy(length); var endPt = startPt.Translate(offset, false); ILineEntity entity = HostFactory.Factory.LineByStartPointEndPoint(startPt.PointEntity, endPt.PointEntity); if (null == entity) { throw new System.Exception(string.Format(Properties.Resources.OperationFailed, "Line.ByStartPointDirectionLength")); } return(entity); }
/// <summary> /// Constructs a point by projecting a point on surface with given /// project direction. /// </summary> /// <param name="contextSurface">The surface on which the projection is to be made.</param> /// <param name="direction">The direction vector of the projection</param> /// <returns>Projected point on surface</returns> public Point Project(Surface contextSurface, Vector direction) { if (null == contextSurface) { throw new ArgumentNullException("contextSurface"); } if (null == direction || direction.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.InvalidInput, direction, "Project on surface"), "direction"); } Point pt = ProjectOnGeometry(contextSurface, direction); pt.Context = contextSurface; pt.Direction = direction; pt.ReferencePoint = this; double[] parameters = contextSurface.ParameterAtPoint(pt); if (null != parameters) { pt.U = parameters[0]; pt.V = parameters[1]; } return(pt); }
/// <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); }
/// <summary> /// Constructs a Bspline curve interpolating the given set of input /// points and tangent to the first and second tangent vectors at the /// start and end points respectively with degree 3. /// </summary> /// <param name="points">Array of points</param> /// <param name="startTangent">Start tangent vector</param> /// <param name="endTangent">End tangent vector</param> /// <returns>BSplineCurve</returns> public static BSplineCurve ByPoints(Point[] points, Vector startTangent, Vector endTangent) { if (startTangent == null || endTangent == null || startTangent.IsZeroVector() || endTangent.IsZeroVector()) { throw new System.ArgumentException(string.Format(Properties.Resources.InvalidArguments, "points"), "points"); } return(ByPoints(points, startTangent, endTangent, false)); }
/// <summary> /// /// </summary> /// <param name="point"></param> /// <param name="direction"></param> /// <returns></returns> public Point Project(Point point, Vector direction) { if (point == null || direction == null || direction.IsZeroVector()) { return(null); } IPointEntity projectedPt = PlaneEntity.Project(point.PointEntity, direction.IVector); if (null == projectedPt) { return(null); } return(projectedPt.ToPoint(true, this)); }
/// <summary> /// /// </summary> /// <param name="pts"></param> /// <param name="startTangent"></param> /// <param name="endTangent"></param> /// <returns></returns> public static BSplineCurve ByPoints(Point[] pts, Vector startTangent, Vector endTangent) { if (pts == null || startTangent == null || endTangent == null || startTangent.IsZeroVector() || endTangent.IsZeroVector()) { return(null); } IBSplineCurveHost ent = HostFactory.Factory.BSplineByPoints(pts.ToHostArray(), startTangent, endTangent); var spline = new BSplineCurve(ent, true); spline.Points = pts; spline.Degree = 3; spline.StartTangent = startTangent; spline.EndTangent = endTangent; return(spline); }
/// <summary> /// Constructs a point by projecting a point on solid with given /// project direction. /// </summary> /// <param name="contextSolid">The solid on which the projection is to be made.</param> /// <param name="direction">The direction vector of the projection</param> /// <returns>Projected point on solid</returns> public Point Project(Solid contextSolid, Vector direction) { if (null == contextSolid) { throw new ArgumentNullException("contextSurface"); } if (null == direction || direction.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.InvalidInput, direction, "Project on surface"), "direction"); } Point pt = ProjectOnGeometry(contextSolid, direction); pt.Context = contextSolid; pt.Direction = direction; pt.ReferencePoint = this; return(pt); }
/// <summary> /// Internal utility method /// </summary> /// <param name="profile"></param> /// <param name="distance"></param> /// <param name="direction"></param> /// <returns></returns> internal static IBSplineSurfaceEntity[] ExtrudeAsBSplineSurfaces(this ICurveEntity profile, double distance, Vector direction) { if (null == profile || direction.IsZeroVector()) { return(null); } using (IPointEntity startPt = profile.PointAtParameter(0.5)) { Vector offset = direction.Normalize().Scale(distance); using (IPointEntity endPt = startPt.CopyAndTranslate(offset.IVector) as IPointEntity) { using (ILineEntity path = HostFactory.Factory.LineByStartPointEndPoint(startPt, endPt)) { using (ISurfaceEntity surf = HostFactory.Factory.SurfaceBySweep(profile, path)) { return(surf.ConvertToBSplineSurface()); } } } } }
/// <summary> /// Constructs a point by projecting a point on a curve with given project direction. /// </summary> /// <param name="curve">the curve on which the projection is to be made.</param> /// <param name="direction">the direction vector of the projection</param> /// <returns></returns> public Point Project(Curve curve, Vector direction) { if (curve == null) { throw new ArgumentNullException("curve"); } else if (direction == null) { throw new ArgumentNullException("direction"); } else if (direction.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, "direction")); } var pt = curve.Project(this, direction); pt.Context = curve; pt.ReferencePoint = this; pt.Direction = direction; pt.Persist(); return(pt); }
private static ICircleEntity By2PointsCore(Point firstPoint, Point secondPoint, ref Vector normal) { if (null == firstPoint) { throw new ArgumentNullException("firstPoint"); } if (null == secondPoint) { throw new ArgumentNullException("secondPoint"); } if (null == normal) { throw new ArgumentNullException("normal"); } if (firstPoint.Equals(secondPoint)) { throw new ArgumentException(string.Format(Properties.Resources.EqualGeometry, "first point", "second point"), "firstPoint, secondPoint"); } if (normal.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, "normal"), "normal"); } var fptPos = firstPoint.PointEntity; var sptPos = secondPoint.PointEntity; var cptPos = HostFactory.Factory.CreatePoint((fptPos.X + sptPos.X) / 2.0, (fptPos.Y + sptPos.Y) / 2.0, (fptPos.Z + sptPos.Z) / 2.0); var centerPt = cptPos.ToPoint(false, null); var circleEntity = Circle.ByCenterPointRadiusCore(centerPt, cptPos.DistanceTo(fptPos), ref normal); if (circleEntity == null) { throw new Exception(string.Format(Properties.Resources.OperationFailed, "Circle.By2Points")); } return(circleEntity); }
private static IPlaneEntity ByOriginNormalCore(Point origin, ref Vector normal, double size) { if (origin == null) { throw new ArgumentNullException("origin"); } else if (normal == null) { throw new ArgumentNullException("normal"); } else if (normal.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, normal), "normal"); } normal = normal.IsNormalized ? normal : normal.Normalize(); IPlaneEntity entity = HostFactory.Factory.PlaneByOriginNormal(origin.PointEntity, normal.IVector); if (null == entity) { throw new System.Exception(string.Format(Properties.Resources.OperationFailed, "Plane.ByOriginNormal")); } return(entity); }
private static IArcEntity ByCenterPointStartPointSweepAngleCore(Point centerPoint, Point startPoint, double sweepAngle, ref Vector normal) { if (centerPoint == null) { throw new ArgumentNullException("centerPoint"); } else if (startPoint == null) { throw new ArgumentNullException("startPoint"); } else if (normal == null) { throw new ArgumentNullException("normal"); } else if (normal.IsZeroVector()) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroVector, "normal vector"), "normal"); } else if (centerPoint.Equals(startPoint)) { throw new ArgumentException(string.Format(Properties.Resources.EqualGeometry, "center point", "start point"), "centerPoint, startPoint"); } else if (sweepAngle == 0.0) { throw new ArgumentException(string.Format(Properties.Resources.IsZeroAngle, "sweep"), "sweepAngle"); } normal = normal.IsNormalized ? normal : normal.Normalize(); var entity = HostFactory.Factory.ArcByCenterPointStartPointSweepAngle(centerPoint.PointEntity, startPoint.PointEntity, GeometryExtension.DegreesToRadians(sweepAngle), normal.IVector); if (null == entity) { throw new Exception(string.Format(Properties.Resources.OperationFailed, "Arc.ByCenterPointStartPointSweepAngle")); } return(entity); }