private static IArcEntity ByCenterPointRadiusAngleCore(DSPoint centerPoint, double radius, double startAngle, double sweepAngle, ref DSVector 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, DSGeometryExtension.DegreesToRadians(startAngle), DSGeometryExtension.DegreesToRadians(endAngle), normal.IVector);
if (null == entity)
{
throw new Exception(string.Format(Properties.Resources.OperationFailed, "DSArc.ByCenterPointRadiusAngle"));
}
return(entity);
}
private static ILineEntity ByStartPointDirectionLengthCore(DSPoint startPt, DSVector 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
DSVector 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, "DSLine.ByStartPointDirectionLength"));
}
return(entity);
}
private static ICircleEntity ByCenterPointRadiusCore(DSPoint centerPoint, double radius, ref DSVector 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, "DSCircle.ByCenterPointRadius"));
}
return(entity);
}
/// <summary>
/// Translates any geometry type by the given distance in the given
/// direction.
/// </summary>
/// <param name="direction">Displacement direction.</param>
/// <param name="distance">Displacement distance along given direction.</param>
/// <returns>Transformed Geometry.</returns>
public DSGeometry Translate(DSVector direction, double distance)
{
DSVector offset = direction.Normalize().MultiplyBy(distance);
DSGeometry geom = Translate(offset);
SetDisplayPropertiesTo(geom.Display);
return(geom);
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsPerpendicular(DSVector other)
{
if (other == null)
{
throw new System.ArgumentNullException("other");
}
var normalizedThis = Normalize();
var normalizedOther = other.Normalize();
var dotProd = normalizedThis.Dot(normalizedOther);
return(DSGeometryExtension.Equals(Math.Abs(dotProd), 0.0));
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
/// <param name="persist"></param>
/// <returns></returns>
internal DSPoint Translate(DSVector offset, bool persist)
{
if (offset == null)
{
throw new ArgumentNullException("direction");
}
IPointEntity pthost = PointEntity.Add(offset);
DSPoint pt = pthost.ToPoint(persist, this);
// setup backlinks
pt.Direction = offset.Normalize();
pt.Distance = offset.Length;
return(pt);
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="offset"></param>
/// <returns></returns>
internal DSPoint PointAtParametersCore(ref double u, ref double v, double offset)
{
bool uchange = DSGeometryExtension.ClipParamRange(ref u);
bool vchange = DSGeometryExtension.ClipParamRange(ref v);
// TO DO - throw a warning each time a condition above is satisfied.
//throw new System.ArgumentException(string.Format(Properties.Resources.InvalidInput, "u or v parameter", "Surface.PointAtParameters"));
IPointEntity pt = SurfaceEntity.PointAtParameter(u, v);
if (!offset.EqualsTo(0.0))
{
DSVector normal = new DSVector(SurfaceEntity.NormalAtPoint(pt));
DSVector translation = normal.Normalize().Scale(offset);
IPointEntity offsetPt = pt.Add(translation);
pt.Dispose();
pt = offsetPt;
}
return(pt.ToPoint(true, this));
}
private static ILineEntity GetPerpBisector(DSPoint startPt, DSPoint endPt,
IPlaneEntity planeOfCircle)
{
DSVector dir = startPt.DirectionTo(endPt);
dir = dir.Normalize();
IPointEntity midPt = HostFactory.Factory.CreatePoint((startPt.X + endPt.X) / 2, (startPt.Y + endPt.Y) / 2, (startPt.Z + endPt.Z) / 2);
// get the perpendicular plane to plane of circle at mid point of segment[startPt, endPt]
//
IPlaneEntity perpPlane = HostFactory.Factory.PlaneByOriginNormal(midPt, dir.IVector);
// this intersection results in line perp to segment[startPt, endPt] & plane normal
// and happens to be the perpBisector of mentioned segment in planeOfCircle
//
ILineEntity perpBisector = planeOfCircle.IntersectWith(perpPlane);
return(perpBisector);
}
/// <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, DSVector direction)
{
if (null == profile || direction.IsZeroVector())
{
return(null);
}
using (IPointEntity startPt = profile.PointAtParameter(0.5))
{
DSVector 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());
}
}
}
}
}
private static IPlaneEntity ByOriginNormalCore(DSPoint origin, ref DSVector 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, "DSPlane.ByOriginNormal"));
}
return(entity);
}
private static IArcEntity ByCenterPointStartPointSweepAngleCore(DSPoint centerPoint, DSPoint startPoint, double sweepAngle, ref DSVector 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, DSGeometryExtension.DegreesToRadians(sweepAngle), normal.IVector);
if (null == entity)
{
throw new Exception(string.Format(Properties.Resources.OperationFailed, "DSArc.ByCenterPointStartPointSweepAngle"));
}
return(entity);
}
internal static DSCoordinateSystem ByOriginVectors(DSPoint origin, DSVector xAxis, DSVector yAxis, DSVector zAxis,
bool isSheared, bool isNormalized, bool visible)
{
if (origin == null)
throw new System.ArgumentNullException("origin");
else if (xAxis == null)
throw new System.ArgumentNullException("xAxis");
else if (yAxis == null)
throw new System.ArgumentNullException("yAxis");
else if (zAxis == null)
throw new System.ArgumentNullException("zAxis");
else if (xAxis.IsZeroVector())
throw new System.ArgumentException(string.Format(Properties.Resources.IsZeroVector, "x axis"), "xAxis");
else if (yAxis.IsZeroVector())
throw new System.ArgumentException(string.Format(Properties.Resources.IsZeroVector, "y axis"), "yAxis");
else if (zAxis.IsZeroVector())
throw new System.ArgumentException(string.Format(Properties.Resources.IsZeroVector, "z axis"), "zAxis");
else if (xAxis.IsParallel(yAxis))
throw new System.ArgumentException(string.Format(Properties.Resources.IsParallel, "x axis", "y axis", "DSCoordinateSystem.ByOriginVectors"), "xAxis, yAxis");
else if (!isSheared && (!xAxis.IsPerpendicular(yAxis) || !yAxis.IsPerpendicular(zAxis) || !zAxis.IsPerpendicular(xAxis)))
{
// this is not the case for sheared but axes are not orthogonal
//
zAxis = xAxis.Cross(yAxis);
yAxis = zAxis.Cross(xAxis);
}
if (isNormalized)
{
xAxis = xAxis.Normalize();
yAxis = yAxis.Normalize();
zAxis = zAxis.Normalize();
}
var cs = HostFactory.Factory.CoordinateSystemByData(null); //create identity matrix
if (null == cs)
throw new System.Exception(string.Format(Properties.Resources.OperationFailed, "DSCoordinateSystem.ByOriginVectors"));
cs.Set(origin.PointEntity, xAxis.IVector, yAxis.IVector, zAxis.IVector);
var coordSys = new DSCoordinateSystem(cs, visible);
return coordSys;
}
/// <summary>
/// Translates the coordinate system in the direction of the vector and by the distance specified
/// </summary>
/// <param name="translationVector">The direction of translation</param>
/// <param name="distance">The distance of translation</param>
/// <returns></returns>
public DSCoordinateSystem Translate(DSVector translationVector, double distance)
{
if (translationVector == null)
{
throw new System.ArgumentNullException("translationVector");
}
translationVector = translationVector.Normalize().MultiplyBy(distance);
var translatedCSEntity = CSEntity.Translate(translationVector.IVector);
var cs = new DSCoordinateSystem(translatedCSEntity, true);
return cs;
}
private static IPlaneEntity ByOriginNormalCore(DSPoint origin, ref DSVector 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, "DSPlane.ByOriginNormal"));
return entity;
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsPerpendicular(DSVector other)
{
if (other == null)
{
throw new System.ArgumentNullException("other");
}
var normalizedThis = Normalize();
var normalizedOther = other.Normalize();
var dotProd = normalizedThis.Dot(normalizedOther);
return DSGeometryExtension.Equals(Math.Abs(dotProd), 0.0);
}
private static ICircleEntity ByCenterPointRadiusCore(DSPoint centerPoint, double radius, ref DSVector 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, "DSCircle.ByCenterPointRadius"));
return entity;
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
/// <param name="persist"></param>
/// <returns></returns>
internal DSPoint Translate(DSVector offset, bool persist)
{
if (offset == null)
{
throw new ArgumentNullException("direction");
}
IPointEntity pthost = PointEntity.Add(offset);
DSPoint pt = pthost.ToPoint(persist, this);
// setup backlinks
pt.Direction = offset.Normalize();
pt.Distance = offset.Length;
return pt;
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="offset"></param>
/// <returns></returns>
internal DSPoint PointAtParametersCore(ref double u, ref double v, double offset)
{
bool uchange = DSGeometryExtension.ClipParamRange(ref u);
bool vchange = DSGeometryExtension.ClipParamRange(ref v);
// TO DO - throw a warning each time a condition above is satisfied.
//throw new System.ArgumentException(string.Format(Properties.Resources.InvalidInput, "u or v parameter", "Surface.PointAtParameters"));
IPointEntity pt = SurfaceEntity.PointAtParameter(u, v);
if (!offset.EqualsTo(0.0))
{
DSVector normal = new DSVector(SurfaceEntity.NormalAtPoint(pt));
DSVector translation = normal.Normalize().Scale(offset);
IPointEntity offsetPt = pt.Add(translation);
pt.Dispose();
pt = offsetPt;
}
return pt.ToPoint(true, this);
}
private static IArcEntity ByCenterPointRadiusAngleCore(DSPoint centerPoint, double radius, double startAngle, double sweepAngle, ref DSVector 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, DSGeometryExtension.DegreesToRadians(startAngle), DSGeometryExtension.DegreesToRadians(endAngle), normal.IVector);
if (null == entity)
throw new Exception(string.Format(Properties.Resources.OperationFailed, "DSArc.ByCenterPointRadiusAngle"));
return entity;
}
private static IArcEntity ByCenterPointStartPointSweepAngleCore(DSPoint centerPoint, DSPoint startPoint, double sweepAngle, ref DSVector 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, DSGeometryExtension.DegreesToRadians(sweepAngle), normal.IVector);
if (null == entity)
throw new Exception(string.Format(Properties.Resources.OperationFailed, "DSArc.ByCenterPointStartPointSweepAngle"));
return entity;
}
private static ILineEntity ByStartPointDirectionLengthCore(DSPoint startPt, DSVector 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
DSVector 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, "DSLine.ByStartPointDirectionLength"));
return entity;
}
