tema 2.2 [GRAFICA]

Scrieti un program care sa rezolve urmatoarea cerinta: Se da un sir de n varfuri, P1, ..., Pn. Programul detecteaza eventualele autointersectii ale liniei poligonale P1...Pn si deseneaza folosind sabloane si culori diferite muchiile cu intersectii si muchiile fara intersectii.

#include <windows.h>  // sunt mentionate fisiere (biblioteci) care urmeaza sa fie incluse
#include <gl/freeglut.h> // nu trebuie uitat freeglut.h (sau glut.h sau gl.h & glu.h)
#include <iostream>

double Y[1000], X[1000], nr_puncte = 0;
int k = 0;
int V[1000];
int x, y;

void init(void)  // initializare fereastra de vizualizare
{
    glClearColor(1.0, 1.0, 1.0, 0.0); // precizeaza culoarea de fond a ferestrei de vizualizare
    glMatrixMode(GL_PROJECTION);  // se precizeaza este vorba de o reprezentare 2D, realizata prin proiectie ortogonala
    gluOrtho2D(0.0, 800.0, 0.0, 800.0); // sunt indicate coordonatele extreme ale ferestrei de vizualizare
}

void functie_pentru_click(int button, int state, int x, int y) {

    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
    {
        X[k] = x;
        Y[k] = 800 - y;
        for (int i = 0; i < k - 2; i++)
        {
        //if()
            double fc = ((X[k-1] - X[i]) / (X[i+1] - X[i])) * (Y[i+1] - Y[i]) - (Y[k-1] - Y[i]);
            double fd = ((X[k] - X[i]) / (X[i+1] - X[i])) * (Y[i+1] - Y[i]) - (Y[k] - Y[i]);
            std::cout << fc << ' ' << fd << '\n';
            if (fc * fd < 0) {
                double a1 = Y[i+1] - Y[i];
                double b1 = X[i] - X[i+1];
                double c1 = a1 * X[i] + b1 * Y[i];

                double a2 = Y[k] - Y[k-1];
                double b2 = X[k-1] - X[k];
                double c2 = a2 * X[k-1] + b2 * Y[k-1];

                double denom = a1 * b2 - a2 * b1;

                if (denom == 0)
                {
                    std::cout << "Same Line i guees";
                }
                else
                {
                    double xi = (b2 * c1 - b1 * c2) / denom;
                    double yi = (a1 * c2 - a2 * c1) / denom;
                    if ((xi <= max(X[i], X[i + 1]) && xi >= min(X[i], X[i + 1]) &&
                        yi <= max(Y[i], Y[i + 1]) && yi >= min(Y[i], Y[i + 1]) &&
                        xi <= max(X[k - 1], X[k]) && xi >= min(X[k - 1], X[k]) &&
                        yi <= max(Y[k - 1], Y[k]) && yi >= min(Y[k - 1], Y[k])) == 1) {
                        V[i] = 1;
                        V[k - 1] = 1;
                    }
                }
            }
        }

        glutPostRedisplay();
        k++;
    }
}

void desen(void) // procedura desenare
{
    glutMouseFunc(functie_pentru_click);
    glPointSize(10.0);
    //Puncte
    std::cout << x <<"-"<<y<<'\n';


    glEnable(GL_POINT_SMOOTH);
    glBegin(GL_POINTS);
    glColor3f(1.0, 1.0, 0.0);
    glVertex2i(X[k], Y[k]);
    glEnd();
    glDisable(GL_POINT_SMOOTH);

    for (int i = 0; i < k - 1; i++)
    {
        if (V[i] == 1)
        {
            glBegin(GL_LINES);
            glColor3f(1.0, 0.0, 0.0);
            glVertex2i(X[i + 1], Y[i + 1]);
            glColor3f(1.0, 0.0, 0.0);
            glVertex2i(X[i], Y[i]);
            glEnd();
        }
        else
        {
            glBegin(GL_LINES);
            glColor3f(1.0, 1.0, 0.0);
            glVertex2i(X[i + 1], Y[i + 1]);
            glColor3f(1.0, 1.0, 0.0);
            glVertex2i(X[i], Y[i]);
            glEnd();
        }
    }
    glFlush(); // proceseaza procedurile OpenGL cat mai rapid
}
void main(int argc, char** argv)
{
    glutInit(&argc, argv); // initializare GLUT
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // se utilizeaza un singur buffer | modul de colorare RedGreenBlue (= default)
    glutInitWindowPosition(100, 100); // pozitia initiala a ferestrei de vizualizare (in coordonate ecran)
    glutInitWindowSize(800, 800); // dimensiunile ferestrei
    glutCreateWindow("Puncte & Segmente"); // creeaza fereastra, indicand numele ferestrei de vizualizare - apare in partea superioara

    init(); // executa procedura de initializare
    glClear(GL_COLOR_BUFFER_BIT); // reprezentare si colorare fereastra de vizualizare
    glutDisplayFunc(desen); // procedura desen este invocata ori de cate ori este nevoie
    glutMainLoop(); // ultima instructiune a programului, asteapta (eventuale) noi date de intrare
}