public IBSplineSurfaceEntity BSplineSurfaceByPoints(IPointEntity[][] points, int uDegree, int vDegree)
 {
     DSGeometryApplication.Check();
     IBSplineSurfaceEntity surface = new BSplineSurfaceEntity();
     surface.UpdateByPoints(points, uDegree, vDegree);
     return surface;
 }

 public IBSplineSurfaceEntity BSplineSurfaceByControlVertices(IPointEntity[][] controlVertices, int uDegree, int vDegree)
 {
     DSGeometryApplication.Check();
     IBSplineSurfaceEntity surface = new BSplineSurfaceEntity();
     surface.UpdateByPoles(controlVertices, uDegree, vDegree);
     return surface;
 }

 public CoordinateEntity(IPointEntity origin, IVectorEntity xAxis, IVectorEntity yAxis, IVectorEntity zAxis)
 {
     this.Origin = origin;
     this.XAxis = xAxis;
     this.YAxis = yAxis;
     this.ZAxis = zAxis;
 }

 public IArcEntity ArcByCenterPointStartPointSweepAngle(IPointEntity centerPoint, IPointEntity startPoint, double sweepAngle, IVector normal)
 {
     DSGeometryApplication.Check();
     double radius = startPoint.DistanceTo(centerPoint);
     double startAngle = 30;
     return new ArcEntity(centerPoint, normal, radius, startAngle, sweepAngle);
 }

 public IConeEntity ConeByPointsRadii(IPointEntity startPoint, IPointEntity endPoint, double startRadius, double endRadius)
 {
     DSGeometryApplication.Check();
     ConeEntity cone = new ConeEntity();
     cone.UpdateCone(startPoint, endPoint, startRadius, endRadius);
     return cone;
 }

 public void UpdateCone(IPointEntity startPoint, IPointEntity endPoint, double startRadius, double endRadius)
 {
     this.StartPoint = startPoint;
     this.EndPoint = endPoint;
     this.StartRadius = startRadius;
     this.EndRadius = endRadius; 
 }

 internal ArcEntity(IPointEntity center, IVectorEntity normal, double radius, double startAngle, double sweepAngle)
 {
     this.CenterPoint = center;
     this.Normal = normal;
     this.Radius = radius;
     this.StartAngle = startAngle;
     this.SweepAngle = sweepAngle;
 }

 public NurbsSurfaceEntity(IPointEntity[][] pts, int degreeU, int degreeV, int p)
 {
     if (p == 0)
         this.Points = pts;
     else
         this.Poles = pts;
     this.DegreeU = degreeU;
     this.DegreeV = degreeV;
 }

 public IArcEntity ArcByCenterPointStartPointSweepPoint(IPointEntity centerPoint, IPointEntity startPoint, IPointEntity sweepPoint)
 {
     DSGeometryApplication.Check();
     Vector start_center = Vector.ByCoordinates(startPoint.X - centerPoint.X, startPoint.Y - centerPoint.Y, startPoint.Z - centerPoint.Z);
     Vector sweep_center = Vector.ByCoordinates(sweepPoint.X - centerPoint.X, sweepPoint.Y - centerPoint.Y, sweepPoint.Z - centerPoint.Z);
     Vector normal = start_center.Cross(sweep_center);
     double radius = start_center.GetLength();
     Vector Axis = Vector.ByCoordinates(1, 0, 0);
     double startAngle = Math.Acos(start_center.Dot(Axis) / (start_center.GetLength() * Axis.GetLength()));
     double sweepAngle = Math.Acos(start_center.Dot(sweep_center) / (start_center.GetLength() * sweep_center.GetLength()));
     return new ArcEntity(centerPoint, normal.ToIVector(), radius, startAngle, sweepAngle);
 }

 public SphereEntity(IPointEntity centerPoint, double radius)
 {
     this.CenterPoint = centerPoint;
     this.Radius = radius;
 }

 public void UpdateSphere(IPointEntity centerPoint, double radius)
 {
     this.CenterPoint = centerPoint;
     this.Radius = radius;
 }

 public ICoordinateSystemEntity Rotation(double rotationAngle, IVectorEntity axis, IPointEntity origin)
 {
     return new CoordinateEntity();
 }

 public void Set(IPointEntity origin, IVectorEntity xAxis, IVectorEntity yAxis, IVectorEntity zAxis)
 {
     this.Origin = origin;
     this.XAxis = xAxis;
     this.YAxis = yAxis;
     this.ZAxis = zAxis;
 }

        internal IPointEntity[] PointsAtEqualArcLengthCore(int numberOfPoints)
        {
            if (numberOfPoints < 1)
                throw new System.ArgumentException(string.Format(Properties.Resources.LessThan, "number of points", "one"), "numberOfPoints");

            double length = Length;
            if (numberOfPoints == 1 || length.EqualsTo(0.0))
                return new[] { StartPoint.PointEntity.Clone() as IPointEntity };
            bool isClosed = IsClosed;
            if (numberOfPoints == 2 && !isClosed)
                return new[] { StartPoint.PointEntity.Clone() as IPointEntity, EndPoint.PointEntity.Clone() as IPointEntity };

            double steps = (isClosed ? length / numberOfPoints : length / (numberOfPoints - 1));
            IPointEntity[] pts = new IPointEntity[numberOfPoints];

            for (int i = 0; i < numberOfPoints; ++i)
            {
                double dist = i * steps;
                pts[i] = CurveEntity.PointAtDistance(dist);
            }
            return pts;
        }

 public void Scale2D(IPointEntity from, IPointEntity to)
 {
     throw new NotImplementedException();
 }

 public IGeometryEntity[] Project(IPointEntity PointEntity, IVectorEntity dir)
 {
     throw new NotImplementedException();
 }

 public IUVEntity UVParameterAtPoint(IPointEntity point)
 {
     throw new NotImplementedException();
 }

 public void UpdateVertices(IPointEntity[] positions)
 {
     this.Positions = positions;
 }

 public virtual IConeEntity ConeByPointsRadius(IPointEntity startPoint, IPointEntity endPoint, double startRadius, double endRadius)
 {
     throw new NotImplementedException("Factory method ConeByPointsRadius not implemented");
 }

 internal PolygonEntity()
 {
     Positions = new IPointEntity[2] { new PointEntity(), new PointEntity(1,1,1) };
 }