tema2.1 [GRAFICA]

Scrieti o procedura / un program care sa rezolve urmatoarea cerinta: Se dau patru puncte A, B, C, D (se presupune ca sunt necoliniare - eventual procedura verifica acest lucru) in plan. Sa se determine daca segmentele [AB] si [CD] se intersecteaza si, in caz afirmativ, sa se calculeze acest punct. Reprezentare grafica. Indicatie: se va folosi reprezentarea punctelor unui segment folosind combinatii baricentrice. In suportul de curs (pag. 7) sunt detalii, inclusiv un exemplu numeric.

#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[10], X[10], nr_puncte = 0;
int k = 0;

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 && k<=3)
    {
        X[k] = x;
        Y[k] = 800-y;
        k++;
    }
}

void desen(void) // procedura desenare
{
    glutMouseFunc(functie_pentru_click);
    glPointSize(10);
    glBegin(GL_POINTS);
        for (int i = 0; i < k; i++)
        {
            glColor3f(1.0, 1.0, 0.0);
            glVertex2i(X[i], Y[i]);
            // segmentele
            if (k == 2 ) {
                glLineWidth(2.0);
                glBegin(GL_LINES);
                glColor3f(1.0, 1.0, 0.0);
                glVertex2i(X[0], Y[0]);
                glColor3f(1.0, 1.0, 0.0);
                glVertex2i(X[1], Y[1]);
                glEnd();
            }

            if (k == 4)
            {
                glLineWidth(2.0);
                glBegin(GL_LINES);
                glColor3f(1.0, 1.0, 0.0);
                glVertex2i(X[2], Y[2]);
                glColor3f(1.0, 1.0, 0.0);
                glVertex2i(X[3], Y[3]);
                glEnd();
            }
        }
    glEnd();

    if (k == 4) {
        double fc = ((X[2] - X[0]) / (X[1] - X[0])) * (Y[1] - Y[0]) - (Y[2] - Y[0]);
        double fd = ((X[3] - X[0]) / (X[1] - X[0])) * (Y[1] - Y[0]) - (Y[3] - Y[0]);
        std::cout << fc << ' ' << fd <<'\n';
        if (fc * fd < 0) {
            std::cout << "Se intersecteaza"<<'\n';
            double a1 = Y[1] - Y[0];
            double b1 = X[0] - X[1];
            double c1 = a1 * X[0] + b1 * Y[0];

            double a2 = Y[3] - Y[2];
            double b2 = X[2] - X[3];
            double c2 = a2 * X[2] + b2 * Y[2];

            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[0], X[1]) && xi >= min(X[0], X[1]) &&
                    yi <= max(Y[0], Y[1]) && yi >= min(Y[0], Y[1]) &&
                    xi <= max(X[2], X[3]) && xi >= min(X[2], X[3]) &&
                    yi <= max(Y[2], Y[3]) && yi >= min(Y[2], Y[3])) == 1)

                {
                    glBegin(GL_POINTS);
                    glColor3f(0.0, 1.0, 0.0);
                    glVertex2i(xi, yi);
                    glEnd();
                    for (int i = 0; i < 4; i++)
                        std::cout << "x: " << X[i] << " y: " << Y[i] << '\n';
                    std::cout << xi << "    " << yi;
                }

            }
            k++;
        }
        else
        {
            std::cout << "Nu se intersecteaza";
            k++;
        }
    }

    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
}