comp

#include "StdAfx.h"
#include "GF.h"
#include <iostream>
#include <vector>

using namespace std;

#ifndef M_PI
const double M_PI = 3.1415926535897932384626433832795;
#endif

enum { LEFT, RIGHT, BEYOND, BEHIND, ORIGIN, DEST, BETWEEN, COLLINEAR, PARALLEL, CROSS, SKEW, SKEW_CROSS,
    SKEW_NO_CROSS, CROSS_LEFT, CROSS_RIGHT, INESSNTIAL, TOUCHING, COMPLEX, SIMPLE, CONVEX, NON_CONVEX,
    INSIDE, OUTSIDE, CLOCKWISE, COUNTERCLOCKWISE };


// Ваша реализация необходимых вам функций
void DrawLine( int x0, int y0, int x1, int y1, RGBPIXEL color )
{
    int dx = abs(x1 - x0);      //
    int dy = abs(y1 - y0);
    int signX = x1 > x0 ? 1 : -1;       //if x1>x0 -> 1
    int signY = y1 > y0 ? 1 : -1;
    if (dx == 0 && dy == 0)
    {
        gfSetPixel(x0, y0, color);      //ставит один пиксель
    }
    else
    {
        if (dx - dy >= 0)       //прямоульгольник вытянут по x
        {
            int x = x0;
            int y = y0;
            int E = 2 * dy - dx;        //ошибка
            while (x != x1 || y != y1)      //пока не дойдем в кон точку
            {
                gfSetPixel(x, y, color);
                if (signY >= 0)     //усл для того чтобы одинаково от x0 и обратно
                {
                    if (E >= 0)     //всегда измен x, иногда измен y
                    {
                        E -= 2 * dx;
                        y += signY;
                    }
                }
                else
                {
                    if (E > 0)
                    {
                        E -= 2 * dx;
                        y += signY;
                    }
                }
                x += signX;     //увеличиваем или умен на шаг в 1 пиксель
                E += 2 * dy;

            }
            gfSetPixel(x, y, color);
        }
        else        //прям вытянут по y
        {
            int x = x0;
            int y = y0;
            int E = 2 * dx - dy;
            while (x != x1 || y != y1)
            {
                gfSetPixel(x, y, color);
                if (signX >= 0)
                {
                    if (E >= 0)
                    {
                        E -= 2 * dy;
                        x += signX;
                    }
                }
                else
                {
                    if (E > 0)
                    {
                        E -= 2 * dy;
                        x += signX;
                    }
                }
                y += signY;
                E += 2 * dx;
            }
            gfSetPixel(x, y, color);
        }
    }

}



void DrawPolygon(vector<vector<int>>& P, RGBPIXEL color)        // рисуем полигон. в динамический массиве 2 x n сначала x,потом y
{
    if (P.size() == 2)      //проверка что два столбика
    {
        if (P[0].size() == P[1].size())     //количество x должно совпадать с y
        {
            for (int i = 0; i < P[0].size() - 1; i++)
            {
                DrawLine(P[0][i], P[1][i], P[0][i + 1], P[1][i + 1], color);
            }
            DrawLine(P[0][P[0].size() - 1], P[1][P[0].size() - 1], P[0][0], P[1][0], color);        //прорисовываем отдельно последнюю строчку
        }
        else
        {
            cout << "Неправильно задан вектор" << endl;
        }
    }
    else
    {
        cout << "Неправильно задан вектор" << endl;
    }
}


int Classify(int x1, int y1, int x2, int y2, int x, int y)      //где лежит точка относительно прямой
{
    int ax = x2 - x1;       //вектор a=(ax,ay) совпадает с прямой
    int bx = x - x1;
    int ay = y2 - y1;
    int by = y - y1;
    int s = ax * by - bx * ay;
    if (s > 0)
        return LEFT;
    if (s < 0)
        return RIGHT;
    if ((ax * bx < 0) || (ay * by < 0))     //на прямой продолжающей отрезок сзади
        return BEHIND;
    if ((ax * ax + ay * ay) < (bx * bx + by * by)) // спереди
        return BEYOND;
    if ((x == x1) && (y == y1)) //в начало попали
        return ORIGIN;
    if ((x == x2) && (y == y2))
        return DEST;
    return BETWEEN; // попали четко на отрезок
}


int PolyTypeConv(vector<vector<int>>& P)
{
    if (P[0].size() <= 2)       //чтобы было 3 x,y
    {
        gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
        return -1;
    }
    int type0 = Classify(P[0][0], P[1][0], P[0][1], P[1][1], P[0][2], P[1][2]); //запоминаем тип одной точку
    for (int j = 0; j < P[0].size() - 1; j++)  //пробегаем по всем ребрам
        for (int i = j + 2; i < P[0].size() + j - 1; i++)       //пробегаем по точкам, кроме ребра
        {
            int type = Classify(P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], P[0][i % P[0].size()], P[1][i % P[0].size()]);
            if (type == DEST || type == ORIGIN || type == BEYOND || type == BEHIND)
            {
                gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
                return -1;
            }
            if (type != type0) {
            gfDrawText(200, 200, "Невыпуклый", RGBPIXEL(0, 128, 255));
            return NON_CONVEX;      //невыпуклый полигон
            }
        }
    gfDrawText(200, 200, "Выпуклый", RGBPIXEL(0, 128, 255));
    return CONVEX;
}

int Intersect(int xa, int ya, int xb, int yb, int xc, int yc, int xd, int yd, double& t)    //пересекаются 2 прямые ab и cd или нет
{
    int nx = yd - yc;       //направляющий вектор
    int ny = xc - xd;
    int denom = nx * (xb - xa) + ny * (yb - ya);        //знаменатель
    if (denom == 0)
    {
        int type = Classify(xc, yc, xd, yd, xa, ya);
        if ((type == LEFT) || (type == RIGHT))
            return PARALLEL;
        else
            return COLLINEAR;       //на одной прямой
    }
    int num = nx * (xa - xc) + ny * (ya - yc);
    t = -double(num) / double(denom);       //именно для отрезков пересечение
    return CROSS;
}


int PolyTypeSimp(vector<vector<int>>& P)
{
    if (PolyTypeConv(P) == -1)
    {
        gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
        return -1;
    }
    if (PolyTypeConv(P) == CONVEX) {
        gfDrawText(200, 100, "Простой", RGBPIXEL(0, 128, 255));
        return SIMPLE;
    }

    for (int j = 0; j < P[0].size() - 1; j++)
        for (int i = j + 2; i < j + P[0].size() - 1; i++)
        {
            double t1 = -1;
            double t2 = -2;
            int type1 = Intersect(P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], P[0][(i % P[0].size())], P[1][(i % P[0].size())], P[0][((i + 1) % P[0].size())], P[1][((i + 1) % P[0].size())], t1);
            int type2 = Intersect(P[0][(i % P[0].size())], P[1][(i % P[0].size())], P[0][((i + 1) % P[0].size())], P[1][((i + 1) % P[0].size())], P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], t2);
            if (type1 == CROSS && type2 == CROSS)
                if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) { //если обе t находятся от 0 до 1
                    gfDrawText(200, 100, "Сложный", RGBPIXEL(0, 128, 255));
                    return COMPLEX;     //сложный
                }
        }
    gfDrawText(200, 100, "Простой", RGBPIXEL(0, 128, 255));
    return SIMPLE;
}


int EdgeType(int x0, int y0, int x1, int y1, int x, int y)      //каким образом прямая из точки x,y пересекает прямую
{
    switch (Classify(x0, y0, x1, y1, x, y))
    {
    case LEFT:
        if (y > y0 && y <= y1)
            return CROSS_LEFT;
        else
            return INESSNTIAL;  // не пересекает
    case RIGHT:
        if (y > y1 && y <= y0)
            return CROSS_RIGHT;
        else
            return INESSNTIAL;
    case BETWEEN:
    case ORIGIN:
    case DEST:
        return TOUCHING;
    default:
        return INESSNTIAL;
    }
}


int PInPolyEO(int x, int y, vector<vector<int>>& P)     //(лек) even-odd(считает число пересевчений, направл не интересует) закрашивает тольок ушки звезды
{
    int prm = 0;
    for (int i = 0; i < P[0].size(); i++)
    {
        switch (EdgeType(P[0][i], P[1][i], P[0][(i + 1) % P[0].size()], P[1][(i + 1) % P[0].size()], x, y))
        {
        case TOUCHING:
            return INSIDE;
        case CROSS_LEFT:
        case CROSS_RIGHT:
            prm = 1 - prm;
            break;
        }
    }
    if (prm == 0)
        return OUTSIDE;
    else
        return INSIDE;
}


int PInPolyNZW(int x, int y, vector<vector<int>>& P) //(лек) закрасит всю звезду (учитывает и направления тоже)
{
    int prm = 0;
    for (int i = 0; i < P[0].size(); i++)
    {
        switch (EdgeType(P[0][i], P[1][i], P[0][(i + 1) % P[0].size()], P[1][(i + 1) % P[0].size()], x, y))
        {
        case TOUCHING:
            return INSIDE;
        case CROSS_LEFT:
            prm = prm + 1;
            break;
        case CROSS_RIGHT:
            prm = prm - 1;
            break;
        }
    }
    if (prm != 0)
        return INSIDE;
    else
        return OUTSIDE;
}


int Max_El_1D(vector<int>& P) //максимальный элемент одномерного массива
{
    int max = P[0];
    for (int i = 0; i < P.size(); i++)
    {
        if (P[i] > max)
            max = P[i];
    }
    return max;
}

int Min_El_1D(vector<int>& P)
{
    int min = P[0];
    for (int i = 0; i < P.size(); i++)
    {
        if (P[i] < min)
            min = P[i];
    }
    return min;
}


void FillingEO(vector<vector<int>>& P, RGBPIXEL color)
{
    int x_max = Max_El_1D(P[0]);
    int x_min = Min_El_1D(P[0]);
    int y_max = Max_El_1D(P[1]);
    int y_min = Min_El_1D(P[1]);
    for (int y = y_min; y <= y_max; y++) //увеличиваем по пикселю и закрашиваем если внутри
        for (int x = x_min; x <= x_max; x++)
        {
            if (PInPolyEO(x, y, P) == INSIDE)
                gfSetPixel(x, y, color);
        }
}


void FillingNZW(vector<vector<int>>& P, RGBPIXEL color)
{
    int x_max = Max_El_1D(P[0]);
    int x_min = Min_El_1D(P[0]);
    int y_max = Max_El_1D(P[1]);
    int y_min = Min_El_1D(P[1]);
    for (int y = y_min; y <= y_max; y++)
        for (int x = x_min; x <= x_max; x++)
        {
            if (PInPolyNZW(x, y, P) == INSIDE)
                gfSetPixel(x, y, color);
        }
}




//2 ЛР

vector<int> R3(double t, vector<vector<int>>& P) //(лек) параметрическое задание кривой безье 3 порядка
{
    vector<int> R = { 0 , 0 }; //точка
    R[0] = int((1 - t) * (1 - t) * (1 - t) * P[0][0] + 3 * t * (1 - t) * (1 - t) * P[0][1] + 3 * t * t * (1 - t) * P[0][2] + t * t * t * P[0][3]);
    R[1] = int((1 - t) * (1 - t) * (1 - t) * P[1][0] + 3 * t * (1 - t) * (1 - t) * P[1][1] + 3 * t * t * (1 - t) * P[1][2] + t * t * t * P[1][3]);
    return R;
}

int dist(int x, int y)  //(лек)
{
    return abs(x) + abs(y);
}

void DrawBesie3(vector<vector<int>>& P, RGBPIXEL color) //(лек)
{
    int D = Max(dist(P[0][0] - 2 * P[0][1] + P[0][2], P[1][0] - 2 * P[1][1] + P[1][2]), dist(P[0][1] - 2 * P[0][2] + P[0][3], P[1][1] - 2 * P[1][2] + P[1][3]));
    double N = 1 + sqrt(3 * D);
    double dt = 1 / N;
    double t = dt;
    vector<int> P1, P2;
    P1 = R3(0, P); //нач точка
    while (t <= 1)
    {
        P2 = R3(t, P);
        t += dt;
        DrawLine(P1[0], P1[1], P2[0], P2[1], color);
        P1 = P2;
    }
    P2 = R3(1, P);
    DrawLine(P1[0], P1[1], P2[0], P2[1], color);
}


int PolyTypeConvOrient(vector<vector<int>>& P, int& t) //проверка на ориентацию
{
    t = -1;
    if (P[0].size() <= 2)
    {
        gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
        return -1;
    }
    int type0 = Classify(P[0][0], P[1][0], P[0][1], P[1][1], P[0][2], P[1][2]);
    for (int j = 0; j < P[0].size() - 1; j++)
        for (int i = j + 2; i < P[0].size() + j - 1; i++)
        {
            int type = Classify(P[0][j], P[1][j], P[0][j + 1], P[1][j + 1], P[0][i % P[0].size()], P[1][i % P[0].size()]);
            if (type == DEST || type == ORIGIN || type == BEYOND || type == BEHIND)
            {
                gfDrawText(300, 300, "Not polygon", RGBPIXEL::Cyan());
                return -1;
            }
            if (type != type0)
                return NON_CONVEX;
        }
    if (type0 == LEFT)
        t = CLOCKWISE;  //по часовой(система левосторонняя)
    if (type0 == RIGHT)
        t = COUNTERCLOCKWISE;
    return CONVEX;
}

void ClipLine(vector<vector<int>>& line, vector<vector<int>>& Poly, RGBPIXEL color) //(лек)
{
    int n = Poly[0].size();  //количество вершин(точек)
    int trigger = -1; //отвечает за по\против часовой (ориентация)
    int type = PolyTypeConvOrient(Poly, trigger);
    if (type == NON_CONVEX)
        gfDrawText(500, 100, "Невыпуклый", RGBPIXEL::Red());
    else
    {
        if (trigger == CLOCKWISE) //переворачиваем, делаем копию buff и меняем
        {
            vector<vector<int>> buff = Poly;
            for (int j = 0; j < 2; j++)
                for (int i = 1; i < n; i++)
                {
                    buff[j][i] = Poly[j][n - i];
                }
            Poly = buff;
        }
        double t0 = 0, t1 = 1, t;
        int sx = line[0][1] - line[0][0];
        int sy = line[1][1] - line[1][0];
        int nx, ny;
        double num, denom;
        for (int i = 0; i < n; i++)
        {
            nx = Poly[1][(i + 1) % n] - Poly[1][i];
            ny = Poly[0][i] - Poly[0][(i + 1) % n];
            denom = nx * sx + ny * sy;
            num = nx * (line[0][0] - Poly[0][i]) + ny * (line[1][0] - Poly[1][i]);
            if (abs(denom) > 0.01)
            {
                t = -num / denom;
                if (denom > 0)
                {
                    if (t > t0)
                        t0 = t;

                }
                else
                {
                    if (t < t1)
                        t1 = t;
                }
            }
        }
        if (t0 <= t1) //&& t1>0)
            DrawLine(int(line[0][0] + t0 * sx), int(line[1][0] + t0 * sy), int(line[0][0] + t1 * sx), int(line[1][0] + t1 * sy), color);
    }

}


// Вызывается один раз в самом начале при инициализации приложения
bool gfInitScene()
{
    gfSetWindowSize( 640, 480 );

    gfSetPixel( 20, 20, RGBPIXEL(255, 255, 0) );

    vector<vector<int>> Poly = { {60, 60, 300, 300} ,{60,300,300,60} };
    vector<vector<int>> Poly2 = { {60, 300, 60, 300} ,{60,300,300,60} };
    DrawPolygon(Poly, RGBPIXEL::Cyan());
    //DrawPolygon(Poly2, RGBPIXEL::Cyan());
    //PolyTypeConv(Poly);
    //PolyTypeSimp(Poly);
    DrawLine(10, 10, 500, 300, RGBPIXEL::Green());
    vector<vector<int>> line = { {10, 500} ,{10, 300}};
    //DrawBesie3(Poly, RGBPIXEL::Red());
    ClipLine(line, Poly, RGBPIXEL::Red());

    //FillingEO(Poly, RGBPIXEL::Red());
    //FillingNZW(Poly2, RGBPIXEL::Red());
    //gfDrawRectangle( 100, 120, 170, 150, RGBPIXEL(255, 255, 0) );
    //gfDrawText( 200, 200, "Hello World", RGBPIXEL(0, 128, 255));
    //gfDisplayMessage("Message!");

    return true;
}

// Вызывается в цикле до момента выхода из приложения.
// Следует использовать для создания анимационных эффектов
void gfDrawScene()
{
    //gfClearScreen(RGBPIXEL::Black());

    //static int x = 0;
    //gfDrawRectangle(x, 100, x + 50, 130, RGBPIXEL::Blue());
    //x = (x + 1) % gfGetWindowWidth() ;

    //int x = gfGetMouseX(),
    //    y = gfGetMouseY();
    //gfDrawRectangle(x - 10, y - 10, x + 10, y + 10, RGBPIXEL::Green());
}

// Вызывается один раз перед выходом из приложения.
// Следует использовать для освобождения выделенных
// ресурсов (памяти, файлов и т.п.)
void gfCleanupScene()
{
}

// Вызывается когда пользователь нажимает левую кнопку мыши
void gfOnLMouseClick( int x, int y )
{
    x; y;
    gfDrawRectangle(x - 10, y - 10, x + 10, y + 10, RGBPIXEL::Green());
}

// Вызывается когда пользователь нажимает правую кнопку мыши
void gfOnRMouseClick( int x, int y )
{
    x; y;
}

// Вызывается когда пользователь нажимает клавишу на клавиатуре
void gfOnKeyDown( UINT key )
{
    key;

    if( key == 'A' )
        gfDisplayMessage( "'A' key has been pressed" );
}

// Вызывается когда пользователь отжимает клавишу на клавиатуре
void gfOnKeyUp( UINT key )
{
    key;

    //if( key == 'B' )
    //    gfDisplayMessage( "'B' key has been un-pressed" );
}