эллипс

#define _USE_MATH_DEFINES
#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>
#include <cmath>

using namespace sf;
using namespace std;

int main()
{
    constexpr int pointCount = 200;
    const Vector2f ellipseRadius = { 200.f, 80.f };

    ContextSettings settings;
    settings.antialiasingLevel = 8;
    RenderWindow window(VideoMode({ 800,600 }), "Ellipse", Style::Default, settings);

    ConvexShape ellipse;
    ellipse.setPosition({ 400,320 });
    ellipse.setFillColor(Color::Blue);

    //ellipse.setOutlineThickness(1);
    //ellipse.setOutlineColor(Color::White);

    ellipse.setPointCount(pointCount);
    for (int pointNo = 0; pointNo < pointCount; pointNo++) {
        float angle = float(2 * M_PI * pointNo) / float(pointCount);
        Vector2f point = {
            ellipseRadius.x * sin(angle),
            ellipseRadius.y * cos(angle)
        };
        ellipse.setPoint(pointNo, point);
    }

    vector< vector< vector<Vertex> > > lines;

    int lineCount = 5;
    int segmentCount = 200;

    int _x = 400;
    int _y = 320;


  vector< ConvexShape > small_ellipse;


  for( int i = 0; i < lineCount; i++ ){
    ConvexShape RightHalf;
    RightHalf.setPosition( _x - 0.5, _y );
    ConvexShape LeftHalf;
    LeftHalf.setPosition( _x + 0.5 , _y );


    vector< Color > col = { Color::Red, Color::Green, Color::Magenta };
    RightHalf.setFillColor( col[ (i ) % col.size() ]  );
    LeftHalf.setFillColor( col[ (i + 1 ) % col.size() ]  );

    RightHalf.setPointCount( segmentCount );
    for( int j = 0; j < segmentCount; j++ ){
      float angle = float( M_PI * j ) / float( segmentCount );
      Vector2f point = {
        ellipseRadius.x * sin(angle) * ( float( i + 1 ) / lineCount ) ,
              ellipseRadius.y * cos(angle)
      };
      RightHalf.setPoint( j, point );
    }

    LeftHalf.setPointCount( segmentCount );
    for( int j = 0; j < segmentCount; j++ ){
      float angle = M_PI + float( M_PI * j ) / float( segmentCount );
      Vector2f point = {
        ellipseRadius.x * sin(angle) * ( float( i + 1 ) / lineCount ) ,
              ellipseRadius.y * cos(angle)
      };
      LeftHalf.setPoint( j, point );
    }

    small_ellipse.push_back( RightHalf );
    small_ellipse.push_back( LeftHalf );

  }



    for (int i = 0; i < lineCount; i++) {
        vector< vector<Vertex> > line;
        for (int j = 0; j < segmentCount - 1; j++) {
            float a1 = float(2 * M_PI * j) / float(segmentCount);
            float a2 = float(2 * M_PI * (j + 1)) / float(segmentCount);
            float x = ellipseRadius.x * (float(i+1)  / lineCount);
            float y = ellipseRadius.y;
            vector<Vertex> lineSegment{
              Vertex(Vector2f( x * sin(a1),  y * cos(a1))),
              Vertex(Vector2f( x * sin(a2),  y * cos(a2))),
            };
            line.push_back(lineSegment);
        }
        lines.push_back(line);
    }

    window.setFramerateLimit(60);
    int t = 0;

    while (window.isOpen())
    {
        double speed = 1.0 / 10;
        double angle = ( ( t * speed ));
        double scale_x = 1 +  0.5 * cos( angle );
        double scale_y = 1 +  0.5 * sin( angle );
        t += 1;

        cout << scale_x << ' ' << scale_y << ' ' << t << endl;
        Event event;
        while (window.pollEvent(event))
        {
            if (event.type == Event::Closed)
            {
                window.close();
            }
        }

        window.clear();

        ellipse.setScale(scale_x,scale_y);
        window.draw( ellipse );

        for( int i = 0; i < small_ellipse.size() ; i++ ){
          small_ellipse[ small_ellipse.size() - 1 - i].setScale(scale_x,scale_y);

          window.draw( small_ellipse[ small_ellipse.size() - 1 - i] );
        }


        for (int i = 0; i < lineCount; i++) {
            for (int j = 0; j < segmentCount - 1; j++) {
                Vertex first = lines[i][j][0];
                Vertex second = lines[i][j][1];
                first.position.x = first.position.x * scale_x + _x;
                first.position.y = first.position.y * scale_y + _y;

                second.position.x = second.position.x * scale_x + _x;
                second.position.y = second.position.y * scale_y + _y;

                Vertex line[2] = {
                  first,
                  second
                };
                window.draw(line, 10, Lines);
            }
        }


        window.display();
    }
}