Рисование кривой совместно с использованием алгоритма отсечения Коэна-Сазерленда

static float Wxlef = 0.0,   /* Координаты левого нижнего и */
Wybot = 0.0,   /* правого верхнего углов окна */
Wxrig = 7.0,   /* отсечения                   */
Wytop = 5.0;
 
/* Глобальные скаляры для алгоритма Кируса-Бека
 * отсечения по многоугольному окну
 */
 
 /* Координаты прямоугольного окна */
static float Wxrect[4] = { 0.0, 0.0, 7.0, 7.0 };
static float Wyrect[4] = { 0.0, 5.0, 5.0, 0.0 };
 
/* Перпендикуляры к сторонам прямоугольного окна */
static float WxNrec[4] = { 1.0,  0.0, -1.0, 0.0 };
static float WyNrec[4] = { 0.0, -1.0,  0.0, 1.0 };
 
/* Данные для многоугольного окна */
static int   Windn = 4;          /* Кол-во вершин у окна   */
static float* Windx = Wxrect,  /* Координаты вершин окна */
* Windy = Wyrect;
static float* Wnormx = WxNrec,  /* Координаты нормалей    */
* Wnormy = WyNrec;
 
 
/*--------------------------------------------------- V_CSclip
 * Реализует алгоритм отсечения Коэна-Сазерленда с
 * кодированием концов отсекаемого отрезка
 *
 * int  V_CSclip (float *x0, float *y0, float *x1, float *y1)
 *
 * Отсекает отрезок, заданный значениями координат его
 * точек (x0,y0), (x1,y1), по окну отсечения, заданному
 * глобальными скалярами Wxlef, Wybot, Wxrig, Wytop
 *
 * Конечным точкам отрезка приписываются коды,
 * характеризующие его положение относительно окна отсечения
 * по правилу:
 *
 *  1001 | 1000 | 1010
 *  -----|------|-----
 *       | Окно |
 *  0001 | 0000 | 0010
 *  -----|------|-----
 *  0101 | 0100 | 0110
 *
 *  Отрезок целиком видим если оба его конца имеют коды 0000
 *  Если логическое И кодов концов не равно 0, то отрезок
 *  целиком вне окна и он просто отбрасывается.
 *  Если же результат этой операции = 0, то отрезок
 *  подозрительный. Он может быть и вне и пересекать окно.
 *  Для подозрительных отрезков определяются координаты их
 *  пересечений с теми сторонами, с которыми они могли бы
 *  пересечься в соответствии с кодами концов.
 *  При этом используется горизонтальность и вертикальность
 *  сторон окна, что позволяет определить одну из координат
 *  без вычислений.
 *  Часть отрезка, оставшаяся за окном отбрасывается.
 *  Оставшаяся часть отрезка проверяется на возможность его
 *  принятия или отбрасывания целиком. Если это невозможно,
 *  то процесс повторяется для другой стороны окна.
 *  На каждом цикле вычислений конечная точка отрезка,
 *  выходившая за окно, заменяется на точку, лежащую или на
 *  стороне окна или его продолжении.
 *
 *  Вспомогательная процедура Code вычисляет код положения
 *  для конца отрезка.
 *
 */
 
static float  CSxn, CSyn;   /* Координаты начала отрезка */
static int  CScode(void)  /* Определяет код точки xn, yn */
{
    register int  i;
    i = 0;
    if (CSxn < Wxlef) ++i; else
        if (CSxn > Wxrig) i += 2;
    if (CSyn < Wybot) i += 4; else
        if (CSyn > Wytop) i += 8;
    return (i);
}  /* CScode */
 
int   V_CSclip(x0, y0, x1, y1) 
float * x0, * y0, * x1, * y1;
{
    float  CSxk, CSyk;   /* Координаты конца отрезка  */
    int    cn, ck,       /* Коды концов отрезка */
        visible,      /* 0/1 - не видим/видим*/
        ii, s;        /* Рабочие переменные  */
    float  dx, dy,      /* Приращения координат*/
        dxdy, dydx,    /* Наклоны отрезка к сторонам */
        r;            /* Рабочая переменная  */
 
    CSxk = *x1; CSyk = *y1;
    CSxn = *x1; CSyn = *y1; ck = CScode();
    CSxn = *x0; CSyn = *y0; cn = CScode();
 
    /* Определение приращений координат и наклонов отрезка
     * к осям. Заодно сразу на построение передается отрезок,
     * состоящий из единственной точки, попавшей в окно
     */
    dx = CSxk - CSxn;
    dy = CSyk - CSyn;
    if (dx != 0) dydx = dy / dx; else {
        if (dy == 0) {
            if (cn == 0 && ck == 0) goto out; else goto all;
        }
    }
    if (dy != 0) dxdy = dx / dy;
 
    /* Основной цикл отсечения */
    visible = 0;  ii = 4;
    do {
        if (cn & ck) break;       /* Целиком вне окна    */
        if (cn == 0 && ck == 0) { /* Целиком внутри окна */
            ++visible;  
            break;
        }
        if (!cn) {                /* Если Pn внутри окна, то */
            s = cn; cn = ck; ck = s;  /* перестить точки Pn,Pk и */
            r = CSxn; CSxn = CSxk; CSxk = r;  /* их коды, чтобы Pn  */
            r = CSyn; CSyn = CSyk; CSyk = r;  /* оказалась вне окна */
        }
        /* Теперь отрезок разделяется. Pn помещается в точку
         * пересечения отрезка со стороной окна.
         */
        if (cn & 1) {         /* Пересечение с левой стороной */
            CSyn = CSyn + dydx * (Wxlef - CSxn);
            CSxn = Wxlef;
        }
        else if (cn & 2) {  /* Пересечение с правой стороной*/
            CSyn = CSyn + dydx * (Wxrig - CSxn);
            CSxn = Wxrig;
        }
        else if (cn & 4) {  /* Пересечение в нижней стороной*/
            CSxn = CSxn + dxdy * (Wybot - CSyn);
            CSyn = Wybot;
        }
        else if (cn & 8) {  /*Пересечение с верхней стороной*/
            CSxn = CSxn + dxdy * (Wytop - CSyn);
            CSyn = Wytop;
        }
        cn = CScode();        /* Перевычисление кода точки Pn */
    } while (--ii >= 0);
    if (visible) {
    out:  *x0 = CSxn;  *y0 = CSyn;
        *x1 = CSxk;  *y1 = CSyk;
    }
all:
    return (visible);
}  /* V_CSclip */

int V_CSclip(x0, y0, x1, y1) 
float x0, y0, x1, y1;

// int V_CSclip(x0, y0, x1, y1) - это должно быть либо объявление функции, либо определение.
 // это объявление
int V_CSclip(x0, y0, x1, y1);
// это определение
int V_CSclip(x0, y0, x1, y1)
{
    // это тело функции, где находится выполняемый ей код
}

Окно - массив 1 x 4, содержащий координаты(xл, xп, yн, yв) сторон окна.
 
P1, P2 - концевые точки отрезка с координатами(P1x, P1y) и(P2x, P2y) соответственно.
 
T1код, T2код - массивы 1 x 4, содержащие коды точек P1 и P2 .
 
Flag - индикатор координатной ориентации отрезка, равный : -1 - при вертикальности, 0 - при горизонтальности.
 
инициализация Flag
 
Flag = 1
 
проверка вертикальности и горизонтальности отрезка
 
if P2x - P1x = 0 then
 
Flag = -1
 
else
 
вычисление наклона N1
 
N1 = (P2y - P1y) / (P2x - P1x)
 
if N1 = 0 then Flag = 0
 
end if
 
для каждой стороны окна
 
for i = 1 to 4
 
call Коэн(P1, P2, Окно; Видимость)
 
if Видимость = да then 2
 
if Видимость = нет then 3
 
проверка пересечения отрезка и стороны окна
 
if T1код(5 - i) = T2код(5 - i) then 1
 
проверка нахождения P1 вне окна; если P1 внутри окна, то поменять P1 и P2 местами
 
if T1код(5 - i) = 0 then
 
Pаб = Pi
 
P1 = P2
 
P2 = Pаб
 
end if
 
поиск пересечений отрезка со сторонами окна
 
выбор соответствующей подпрограммы вычисления пересечения
 
контроль вертикальности отрезка
 
if Flag <> -1 and i <= 2 then
 
P1y = N1 * (Окноi - P1x) + P1y
 
P1x = Окноi
 
else
 
if Flag < > 0 then
 
if Flag <> -1 then
 
P1x = (1 / N1) * (Окноi - P1y) + P1x
 
end if
 
P1y = Окноi
 
end if
 
end if
 
next i{ 1 шаг }
 
начертить видимый отрезок
 
Draw P1 P2{ 2 шаг }
 
finish{ 3 шаг }
 
 
 
 
 
 
подпрограмма определения видимости отрезка
 
subroutine Коэн(P1, P2, Окно; Видимость)
 
P1, P2 - концевые точки отрезка с координатами(P1x, P1y) и(P2x, P2y) соответственно.
 
Окно - массив 1 x 4, содержащий координаты(xл, xп, yн, yв) сторон окна.
 
Видимость - признак видимости отрезка равный :
 
"нет", "частично", "да" - если отрезок соответственно :
 
полностью невидим, видим частично или полностью видим
 
вычисление кодов концевых точек отрезка
 
call Конец(P1, Окно; T1код, Сумма1)
 
call Конец(P2, Окно; T2код, Сумма2)
 
предположим, что отрезок частично видим
 
Видимость = частично
 
проверка полной видимости отрезка
 
if Сумма1 = 0 and Сумма2 = 0 then
 
Видимость = да
 
else
 
проверка тривиальной невидимости отрезка
 
call Логическое(T1код, T2код, Произвед)
 
if Произвед < > 0 then Видимость = нет
 
end if
 
отрезок может оказаться частично видимым
 
return
 
 
 
 
 
подпрограмма вычисления кодов концевой точки отрезка
 
subroutine Конец(P, Окно; Tкод, Сумма)
 
Px, Py - координаты точки P
 
Окно - массив 1 x 4, содержащий координаты(xл, xп, yн, yв) сторон окна.
 
Tкод - массив 1 x 4, содержащий коды концевой точки .
 
Сумма - сумма всех элементов массива Tкод
 
вычисление кодов концевой точки
 
if Px < xл then Ткод(4) = 1 else Ткод(4) = 0
 
    if Px > xп then Ткод(3) = 1 else Ткод(3) = 0
 
        if Py < yн then Ткод(2) = 1 else Ткод(2) = 0
 
            if Py > yв then Ткод(1) = 1 else Ткод(1) = 0
 
                вычисление суммы
 
                Сумма = 0
 
                for i = 1 to 4
 
                    Сумма = Сумма + Ткод(i)
 
                    next i
 
                    return
 
 
 
 
 
 
 
                    подпрограмма вычисления логического произведения
 
                    subroutine Логическое(Т1код, Т2код; Произвед)
 
                    T1код, T2код - массивы 1 x 4, содержащие коды первой и второй концевых точек соответственно.
 
                    Произвед - сумма побитовых логических произведений.
 
                    Произвед = 0
 
                    for i = 1 to 4
 
                        Произвед = Произвед + Целая часть((Т1код(i) + Т2код(i)) / 2)
 
                        next i
 
                        return

#include<windows.h>
#include<Windowsx.h>
#include<gdiplus.h>
#include<gdiplustypes.h>
#include <string> 
#include <tchar.h>
#include<Strsafe.h>
#include<AtlConv.h>
#include "Math.h"
#include "Vectors.h"
#include"WorldWindowAndViewport.h"
#include<vector>
#define PI 3.14159265
#pragma comment(lib,"Gdiplus.lib")
using namespace Gdiplus;
using namespace std;
 
VOID OnPaint(HDC hdc);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR, INT iCmdShow)
{
    HWND                hWnd;
    MSG                 msg;
    WNDCLASS            wndClass;
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR           gdiplusToken;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
    wndClass.style = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc = WndProc;
    wndClass.cbClsExtra = 0;
    wndClass.cbWndExtra = 0;
    wndClass.hInstance = hInstance;
    wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wndClass.lpszMenuName = NULL;
    wndClass.lpszClassName = TEXT("Лианга-Барски ");
    RegisterClass(&wndClass);
    hWnd = CreateWindow(
        TEXT("Лианга-Барски "), TEXT("Лианга-Барски "), WS_SYSMENU,
        CW_USEDEFAULT, CW_USEDEFAULT, 700, 700,
        NULL, NULL, hInstance, NULL);
    ShowWindow(hWnd, iCmdShow);
    UpdateWindow(hWnd);
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    GdiplusShutdown(gdiplusToken);
    return msg.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message,
    WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    switch (message)
    {
    case WM_INITDIALOG:
        return 0;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        OnPaint(hdc);
        EndPaint(hWnd, &ps);
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
}
 
 
template <class Func>
inline std::vector<Gdiplus::PointF> Curve(float tMin, float tMax, size_t n, Func f) {
    std::vector<Gdiplus::PointF> result;
    if (n > 1)
    {
        result.reserve(n); // зарезервируем место для n точек
                           // определяем шаг изменения t
        float dt = (tMax - tMin) / (float)(n - 1);
        for (size_t i = 0; i < n; ++i)
        {
            // добавим точку в массив
            result.push_back(f(tMin + i * dt));
        } // for
    } // if
    return result;
} // Curve
 
 
bool LineClip(const WorldWindow& w, PointF& pt1, PointF& pt2)
{
    static float  CSxn, CSyn;   /* Координаты начала отрезка */
 
    int  CScode();  /* Определяет код точки xn, yn */
    {
        register int  i;
        i = 0;
        if (CSxn < w.Left) ++i; else
            if (CSxn > w.Right) i += 2;
        if (CSyn < w.Bottom) i += 4; else
            if (CSyn > w.Top) i += 8;
        return (i);
    }  /* CScode */
 
    int V_CSclip();
    float x0, y0, x1, y1;
    {
        float  CSxk, CSyk;   /* Координаты конца отрезка  */
        int    cn, ck,       /* Коды концов отрезка */
            visible,      /* 0/1 - не видим/видим*/
            ii, s;        /* Рабочие переменные  */
        float  dx, dy,       /* Приращения координат*/
            dxdy, dydx,    /* Наклоны отрезка к сторонам */
            r;            /* Рабочая переменная  */
 
        CSxk = x1; CSyk = y1;
        CSxn = x1; CSyn = y1; ck = CScode();
        CSxn = x0; CSyn = y0; cn = CScode();
 
        /* Определение приращений координат и наклонов отрезка
         * к осям. Заодно сразу на построение передается отрезок,
         * состоящий из единственной точки, попавшей в окно
         */
        dx = CSxk - CSxn;
        dy = CSyk - CSyn;
        if (dx != 0) dydx = dy / dx; else {
            if (dy == 0) {
                if (cn == 0 && ck == 0) goto out; else goto all;
            }
        }
        if (dy != 0) dxdy = dx / dy;
 
        /* Основной цикл отсечения */
        visible = 0;  ii = 4;
        do {
            if (cn & ck) break;       /* Целиком вне окна    */
            if (cn == 0 && ck == 0) { /* Целиком внутри окна */
                ++visible;  break;
            }
            if (!cn) {                /* Если Pn внутри окна, то */
                s = cn; cn = ck; ck = s;  /* перестить точки Pn,Pk и */
                r = CSxn; CSxn = CSxk; CSxk = r;  /* их коды, чтобы Pn  */
                r = CSyn; CSyn = CSyk; CSyk = r;  /* оказалась вне окна */
            }
            /* Теперь отрезок разделяется. Pn помещается в точку
             * пересечения отрезка со стороной окна.
             */
            if (cn & 1) {         /* Пересечение с левой стороной */
                CSyn = CSyn + dydx * (w.Left - CSxn);
                CSxn = w.Left;
            }
            else if (cn & 2) {  /* Пересечение с правой стороной*/
                CSyn = CSyn + dydx * (w.Right - CSxn);
                CSxn = w.Right;
            }
            else if (cn & 4) {  /* Пересечение в нижней стороной*/
                CSxn = CSxn + dxdy * (w.Bottom - CSyn);
                CSyn = w.Bottom;
            }
            else if (cn & 8) {  /*Пересечение с верхней стороной*/
                CSxn = CSxn + dxdy * (w.Top - CSyn);
                CSyn = w.Top;
            }
            cn = CScode();        /* Перевычисление кода точки Pn */
        } while (--ii >= 0);
        if (visible) {
        out: x0 = CSxn; y0 = CSyn; x1 = CSxk; y1 = CSyk;
        }
    all:
        return (visible);
    }
}
 
void DrawPolyline(Gdiplus::Graphics& g, const Gdiplus::Pen* pen, const std::vector<Gdiplus::PointF>& polyline,
    const WorldWindow& w, const Viewport& vp)
{
    for (size_t i = 1; i < polyline.size(); ++i)
    {
        PointF points[2] = { polyline[i - 1], polyline[i] };
        // производим отсечение
        bool fIsDraw = LineClip(w, points[0], points[1]);
        if (fIsDraw) // если ребро выжило
        //if (true) // если ребро выжило
        {
            // выполняем преобразование координат точек
            WorldToViewport(w, vp, points, 2);
            // рисуем ребро
            g.DrawLines(pen, points, 2);
        } // if
    } // for
} // DrawPolyline
Gdiplus::PointF f(float t)
{
    PointF res;
    res.X = 31 * Cos(t) + 5 * Cos(31 * t / 5);
    res.Y = 31 * Sin(t) - 5 * Sin(31 * t / 5);
    return res;
}
 
 
VOID OnPaint(HDC hdc)
{
    Graphics drawingBoard(hdc);
    drawingBoard.Clear(Color::DodgerBlue);
    Pen curvePen(Color(0, 0, 0), 2.0f);
    Pen borderPen(Color(255, 210, 140), 5.0f);
    WorldWindow w(-36, 36, 36, -36);            // кординаты мирового окна
    Viewport vp(100, 100, 600, 600);        // координаты порта просмотра
 
    drawingBoard.DrawRectangle(&borderPen, 100, 100, 500, 500);
    std::vector<Gdiplus::PointF> parabola = Curve(0, 10 * PI, 500, f);
    DrawPolyline(drawingBoard, &curvePen, parabola, w, vp);
}