FIGURI GEOMETRICE

#include <iostream>
#include <vector>
#include <cmath>
#include <string>
using namespace std;

#define PI 3.14
#define sin(x) sin(x * PI / 180)
#define cos(x) cos(x * PI / 180)

class Figura
{
protected:
    string nume;
public:
    Figura() : nume("") {}
    Figura(string nume) : nume(nume) {}

    virtual float arie() = 0;
    virtual float perimetru() = 0;

    void afisare()
    {
        cout << "Figura : " << nume << endl;
        cout << "Arie : " << arie() << endl;
        cout << "Perimetru : " << perimetru() << endl << endl;
    }
};

class Elipsa : virtual public Figura
{
protected:
    float raza1, raza2;
public:
    Elipsa() : Figura("Elipsa"), raza1(0), raza2(0) {}
    Elipsa(float raza1, float raza2) : Figura("Elipsa"), raza1(raza1), raza2(raza2) {}

    virtual float arie() { return raza1 * raza2 * PI; }
    virtual float perimetru() { return (raza1 + raza2) * PI; }
};

class Cerc : public Elipsa
{
public:
    Cerc() : Figura("Cerc"), Elipsa() {}
    Cerc(float raza) : Figura("Cerc"), Elipsa(raza, raza) {}

    float arie() { return Elipsa::arie(); }
    float perimetru() { return Elipsa::perimetru(); }
};

class Poligon : virtual public Figura
{
protected:
    vector<pair<float, float>> coordonate;
public:
    Poligon() : Figura("Poligon"), coordonate() {}
    Poligon(vector<pair<float, float>> coordonate) : Figura("Poligon"), coordonate(coordonate) {}
    ~Poligon() { coordonate.clear(); }

    float arie()
    {
        float suma = 0;
        for (int index = 0; index < coordonate.size() - 1; ++index)
            suma += coordonate[index].first * coordonate[index + 1].second -
            coordonate[index + 1].first * coordonate[index].second;
        return fabs(suma) / 2;
    }

    float perimetru()
    {
        float perimetru = 0;
        for (int index = 0; index < coordonate.size() - 1; ++index)
            perimetru += (float)sqrt(pow(coordonate[index + 1].first - coordonate[index].first, 2) +
                pow(coordonate[index + 1].second - coordonate[index].second, 2));
        return perimetru;
    }
};

class Patrulater : virtual public Poligon
{
public:
    Patrulater() : Figura("Patrulater"), Poligon() {}
    Patrulater(vector<pair<float, float>> coordonate) : Figura("Patrulater"), Poligon(coordonate) {}
    ~Patrulater() { coordonate.clear(); }

    float arie() { return Poligon::arie(); }
    float perimetru() { return Poligon::perimetru(); }
};

class Paralelogram : virtual public Patrulater
{
protected:
    float x, y, lx, ly, alfa;
public:
    Paralelogram() : Figura("Paralelogram"), x(0), y(0), lx(0), ly(0), alfa(0) {}
    Paralelogram(float x, float y, float lx, float ly, float alfa) : Figura("Paralelogram"), x(x), y(y), lx(lx), ly(ly), alfa(alfa) {}

    virtual float arie() { return lx * ly * sin(alfa); }
    virtual float perimetru() { return 2 * (lx + ly); }
};

class Dreptunghi : virtual public Paralelogram
{
public:
    Dreptunghi() : Figura("Dreptunghi"), Paralelogram() {}
    Dreptunghi(float x, float y, float lx, float ly) : Figura("Dreptunghi"), Paralelogram(x, y, lx, ly, 90) {}

    virtual float arie() { return Paralelogram::arie(); }
    float perimetru() { return Paralelogram::perimetru(); }
};

class Romb : virtual public Paralelogram
{
public:
    Romb() : Figura("Romb"), Paralelogram() {}
    Romb(float x, float y, float lx, float alfa) : Figura("Romb"), Paralelogram(x, y, lx, lx, alfa) {}

    float arie() { return Paralelogram::arie(); }
    virtual float perimetru() { return Paralelogram::perimetru(); }
};

class Patrat : virtual public Dreptunghi, virtual public Romb
{
public:
    Patrat() : Figura("Patrat"), Paralelogram() {}
    Patrat(float x, float y, float l) : Figura("Patrat"), Paralelogram(x, y, l, l, 90) {}

    float arie() { return Dreptunghi::arie(); }
    float perimetru() { return Romb::perimetru(); }
};

class Trapez : virtual public Patrulater
{
protected:
    float x1, y1, x2, y2, b1, b2;
public:
    Trapez() : Figura("Trapez"), x1(0), y1(0), x2(0), y2(0), b1(0), b2(0) {}
    Trapez(float x1, float y1, float x2, float y2, float b1, float b2) : Figura("Trapez"), x1(x1), y1(y1), x2(x2), y2(y2), b1(b1), b2(b2) {}

    virtual float arie() { return (b1 + b2) * (y2 - y1) / 2; }
    virtual float perimetru()
    {
        float latura1, latura2;
        latura1 = (float)sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
        latura2 = (float)sqrt(pow(x2 + b2 - (x1 + b1), 2) + pow(y2 - y1, 2));
        return b1 + b2 + latura1 + latura2;
    }
};

class TrapezIsoscel : public Trapez
{
public:
    TrapezIsoscel() : Figura("Trapez isoscel"), Trapez() {}
    TrapezIsoscel(float x, float y, float h, float b1, float b2) : Figura("Trapez isoscel"), Trapez(x, y, x + (b1 - b2) / 2, y + h, b1, b2) {}

    float arie() { return Trapez::arie(); }
    float perimetru() { return Trapez::perimetru(); }
};

class TrapezDreptunghic : public Trapez
{
public:
    TrapezDreptunghic() : Figura("Trapez dreptunghic"), Trapez() {}
    TrapezDreptunghic(float x, float y, float h, float b1, float b2) : Figura("Trapez dreptunghic"), Trapez(x, y, x, y + h, b1, b2) {}

    float arie() { return Trapez::arie(); }
    float perimetru() { return Trapez::perimetru(); }
};

class Triunghi : public Poligon
{
protected:
    float latura1, latura2, alfa;
public:
    Triunghi() : Figura("Triunghi"), latura1(0), latura2(0), alfa(0) {}
    Triunghi(float latura1, float latura2, float alfa) : Figura("Triunghi"), latura1(latura1), latura2(latura2), alfa(alfa) {}

    virtual float arie()
    {
        return latura1 * latura2 * sin(alfa) / 2;
    }

    virtual float perimetru()
    {
        float latura3 = (float)sqrt(pow(latura1, 2) + pow(latura2, 2) - 2 * latura1 * latura2 * cos(alfa));
        return latura1 + latura2 + latura3;
    }
};

class TriunghiIsoscel : virtual public Triunghi
{
public:
    TriunghiIsoscel() : Figura("Triunghi isoscel"), Triunghi() {}
    TriunghiIsoscel(float latura, float alfa) : Figura("Triunghi isoscel"), Triunghi(latura, latura, alfa) {}

    virtual float arie() { return Triunghi::arie(); }
    virtual float perimetru() { return Triunghi::perimetru(); }
};

class TriunghiEchilateral : public TriunghiIsoscel
{
public:
    TriunghiEchilateral() : Figura("Triunghi echilateral"), Triunghi() {}
    TriunghiEchilateral(float latura) : Figura("Triunghi isoscel"), Triunghi(latura, latura, 60) {}

    float arie() { return Triunghi::arie(); }
    float perimetru() { return Triunghi::perimetru(); }
};

class TriunghiDreptunghic : virtual public Triunghi
{
public:
    TriunghiDreptunghic() : Figura("Triunghi dreptunghic"), Triunghi() {}
    TriunghiDreptunghic(float latura1, float latura2) : Figura("Triunghi dreptunghic"), Triunghi(latura1, latura2, 90) {}

    virtual float arie() { return Triunghi::arie(); }
    virtual float perimetru() { return Triunghi::perimetru(); }
};

class TriunghiDreptunghicIsoscel : public TriunghiDreptunghic, public TriunghiIsoscel
{
public:
    TriunghiDreptunghicIsoscel() : Figura("Triunghi dreptunghic isoscel"), Triunghi() {}
    TriunghiDreptunghicIsoscel(float latura) : Figura("Triunghi dreptunghic isoscel"), Triunghi(latura, latura, 90) {}

    float arie() { return TriunghiDreptunghic::arie(); }
    float perimetru() { return TriunghiIsoscel::perimetru(); }
};

int main()
{
    Elipsa elipsa(5, 6); // Raza1, Raza2
    elipsa.afisare();

    Cerc cerc(5); // Raza
    cerc.afisare();


    vector<pair<float, float>> coordonate;
    coordonate.push_back(make_pair(0, 0));
    coordonate.push_back(make_pair(3, -1));
    coordonate.push_back(make_pair(5, 1));
    coordonate.push_back(make_pair(4, 3));
    coordonate.push_back(make_pair(2, 2));
    coordonate.push_back(coordonate[0]);

    Poligon poligon(coordonate); // coordonatele punctelor
    poligon.afisare();

    Patrulater patrulater(coordonate); // coordonatele punctelor
    patrulater.afisare();


    Paralelogram paralelogram(0, 0, 5, 15, 30); // x, y, lx, ly, alfa
    paralelogram.afisare();

    Dreptunghi dreptunghi(0, 0, 5, 15); // x, y, lx, ly
    dreptunghi.afisare();

    Romb romb(0, 0, 5, 60); // x, y, latura, alfa
    romb.afisare();

    Patrat patrat(0, 0, 5); // x, y, latura
    patrat.afisare();


    Trapez trapez(0, 0, 2, 2, 10, 5); // x1, y1, x2, y2, B1, B2
    trapez.afisare();

    TrapezIsoscel trapezIsoscel(0, 0, 2, 10, 5); // x, y, h, B1, B2
    trapezIsoscel.afisare();

    TrapezDreptunghic trapezDreptunghic(0, 0, 2, 15, 5); // x, y, h, B1, B2
    trapezDreptunghic.afisare();


    Triunghi triunghi(4, 4, 90); // l1, l2, alfa
    triunghi.afisare();

    TriunghiIsoscel triunghiIsoscel(4, 60); // latura, alfa
    triunghiIsoscel.afisare();

    TriunghiEchilateral triunghiEchilateral(4); // latura
    triunghiEchilateral.afisare();

    TriunghiDreptunghic triunghiDreptunghic(4, 4); // cateta1, cateta2
    triunghiDreptunghic.afisare();

    TriunghiDreptunghicIsoscel triunghiDreptunghicIsoscel(4); // cateta
    triunghiDreptunghicIsoscel.afisare();

    return 0;
}