// Constructor
 public Circle(Vector3D center, double radius)
     : base(center)
 {
     this.Radius = radius;
     A = new Vector3D(center.X + this.Radius, center.Y, center.Z);
     B = new Vector3D(center.X, center.Y + this.Radius, center.Z);
 }

 public void Translate(Vector3D translationVector)
 {
     for (int i = 0; i < this.vertices.Count; i++)
     {
         this.vertices[i] += translationVector;
     }
 }

        public static Vector3D CrossProduct(Vector3D a, Vector3D b)
        {
            double crossX = a.Y * b.Z - a.Z * b.Y;
            double crossY = a.Z * b.X - a.X * b.Z;
            double crossZ = a.X * b.Y - a.Y * b.X;

            return new Vector3D(crossX, crossY, crossZ);
        }

 public Vector3D GetNormal()
 {
     Vector3D center = this.GetCenter();
     Vector3D A = new Vector3D(center.X + this.Radius, center.Y, center.Z);
     Vector3D B = new Vector3D(center.X, center.Y + this.Radius, center.Z);
     Vector3D normal = Vector3D.CrossProduct(center - A, center - B);
     normal.Normalize();
     return normal;
 }

 public void Scale(Vector3D scaleCenter, double scaleFactor)
 {
     for (int i = 0; i < this.vertices.Count; i++)
     {
         Vector3D centeredCurrent = this.vertices[i] - scaleCenter;
         Vector3D scaledCenteredCurrent = centeredCurrent * scaleFactor;
         this.vertices[i] = scaledCenteredCurrent + scaleCenter;
     }
 }

        public static double DotProduct(Vector3D a, Vector3D b)
        {
            double result = 0;
            for (int d = 0; d < 3; d++)
            {
                result += a[d] * b[d];
            }

            return result;
        }

        // Methods
        public virtual Vector3D GetCenter()
        {
            Vector3D verticesSum = new Vector3D(0, 0, 0);

            for (int i = 0; i < this.vertices.Count; i++)
            {
                verticesSum += this.vertices[i];
            }

            return verticesSum / this.vertices.Count;
        }

        public void RotateInXY(Vector3D rotCenter, double angleDegrees)
        {
            for (int i = 0; i < this.vertices.Count; i++)
            {
                Vector3D centeredCurrent = this.vertices[i] - rotCenter;
                double angleRads = angleDegrees * Math.PI / 180.0;

                Vector3D rotatedCenteredCurrent = new Vector3D(
                    centeredCurrent.X * Math.Cos(angleRads) - centeredCurrent.Y * Math.Sin(angleRads),
                    centeredCurrent.X * Math.Sin(angleRads) + centeredCurrent.Y * Math.Cos(angleRads),
                    centeredCurrent.Z);

                this.vertices[i] = rotatedCenteredCurrent + rotCenter;
            }
        }

 public Cylinder(Vector3D botCirc, Vector3D topCirc, double radius)
     : base(botCirc, topCirc)
 {
     this.Radius = radius;
 }

 public Cylinder(Vector3D centerBottom, Vector3D centerTop, double radius)
     : base(centerBottom, centerTop)
 {
     this.Radius = radius;
 }

 public Circle(Vector3D center, double radius)
     : base(center)
 {
     this.Radisu = radius;
 }

 public Vertex(Vector3D location)
     : base(location)
 {
 }

 public Triangle(Vector3D a, Vector3D b, Vector3D c)
     : base(a, b, c)
 {
 }

        public Cylinder(Vector3D bottomCenter, Vector3D topCenter, double radius)
            : base(topCenter, bottomCenter)
        {
            this.BottomCenter = bottomCenter;
            this.TopCenter = topCenter;
            this.Radius = radius;

            this.Height = (topCenter - bottomCenter).Magnitude;
        }

 public Circle(Vector3D centre, double radius)
     : base(centre)
 {
     this.Radius = radius;
 }

 public Vector3D GetNormal()
 {
     Vector3D normal = new Vector3D(0, 0, 1);
     return normal;
 }

 public Circle(Vector3D vector, double radius)
     : base(vector)
 {
     this.Radius = radius;
 }

 public Cylinder(Vector3D bottomCenter, Vector3D topCenter, double radius)
     : base(bottomCenter, topCenter)
 {
     this.Radius = radius;
 }

 public Cylinder(Vector3D a, Vector3D b, double r)
     : base(a, b)
 {
     this.Radius = r;
 }

 public Circle(Vector3D a, double r)
     : base(a)
 {
     this.Radius = r;
 }