Interpolacja

#include <iostream>
#include <graphics.h>

using namespace std;

int main()
{
   int gd = DETECT, gm;
   int x = 320, y = 240, r;

   initgraph(&gd, &gm, NULL);

   for(r = 25; r <= 125 ; r += 20)
      circle(x, y, r);

   getch();
   closegraph();
   return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Test biblioteki BGI
//----------------------------

#include <iostream>
#include <graphics.h>

using namespace std;

int main()
{
   initwindow(240,120,"Test BGI");
   getch();
   closegraph();
   return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Piksele
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    int xmax,ymax;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(400,300,"Piksele");

    // Odczytujemy rozmiar obszaru roboczego okna
    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Pętla nieskończona
    while(1)
    {
        // Rysujemy piksel o przypadkowym kolorze
        putpixel(rand() % xmax,
                 rand() % ymax,
                 COLOR(rand() & 0xff,
                       rand() & 0xff,
                       rand() & 0xff));
    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Piksele
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    int xmax,ymax;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(200,200,"Piksele");

    // Odczytujemy rozmiar obszaru roboczego okna
    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    int crs,cre,cgs,cge,cbs,cbe; // Kolory narożników

    int x,y;      // Pozycja piksela
    int cr,cg,cb; // Kolor na pozycji piksela

    int r,rmax;

    rmax = (xmax - 1) * (xmax - 1) + (ymax - 1) * (ymax - 1);

    // Pętla nieskończona
    while(1)
    {
        // Generujemy kolory dla dwóch narożników.
        // Lewy górny

        crs = rand() & 0xff;
        cgs = rand() & 0xff;
        cbs = rand() & 0xff;

        // Prawy dolny

        cre = 255 - crs;
        cge = 255 - cgs;
        cbe = 255 - cbe;

        // Rysujemy piksele

        for(y = 0; y < ymax; y++)
            for(x = 0; x < xmax; x++)
            {
                // Wyliczamy kolor w punkcie (x,y)

                r  = x * x + y * y;
                cr = crs + r * (cre - crs) / rmax;
                cg = cgs + r * (cge - cgs) / rmax;
                cb = cbs + r * (cbe - cbs) / rmax;

                // Stawiamy piksel

                putpixel(x,y,COLOR(cr,cg,cb));
            }
    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Odcinki
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    int xmax,ymax;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(400,400,"Odcinki");

    // Odczytujemy rozmiar obszaru roboczego okna
    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Pętla nieskończona
    while(1)
    {
        // Ustawiamy przypadkowy kolor rysowania
        setcolor(COLOR(rand() & 0xff, rand() & 0xff, rand() & 0xff));

        // Rysujemy odcinek w oknie
        line(rand() % xmax, rand() % ymax,
             rand() % xmax, rand() % ymax);

    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Odcinki
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    int xmax,ymax,x,cr,cg,cb,er,eg,eb;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(400,400,"Odcinki");

    // Odczytujemy rozmiar obszaru roboczego okna
    xmax = getmaxx();
    ymax = getmaxy();

    // Generujemy kolor startowy
    cr = rand() & 0xff;
    cg = rand() & 0xff;
    cb = rand() & 0xff;

    // Generujemy kolor docelowy
    er = rand() & 0xff;
    eg = rand() & 0xff;
    eb = rand() & 0xff;

    // Pętla nieskończona
    while(1)
    {
       // Ustawiamy kolor
       setcolor(COLOR(cr,cg,cb));

       // Modyfikujemy składowe kolorów
       if(cr > er) cr--;
       if(cr < er) cr++;
       if(cg > eg) cg--;
       if(cg < eg) cg++;
       if(cb > eb) cb--;
       if(cb < eb) cb++;

       if(cr == er) er = rand() & 0xff;
       if(cg == eg) eg = rand() & 0xff;
       if(cb == eb) eb = rand() & 0xff;

       // Rysujemy figurę

       x = 0;
       while(x <= xmax)
       {
           line(0,0,x,ymax);
           line(0,ymax,x,0);
           line(xmax,0,x,ymax);
           line(xmax,ymax,x,0);
           x += 10;
       }
    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Łamana
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    int xmax,ymax,cr,cg,cb,er,eg,eb;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(600,400,"Łamana");

    // Odczytujemy rozmiar obszaru roboczego okna
    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Generujemy kolor startowy
    cr = rand() & 0xff;
    cg = rand() & 0xff;
    cb = rand() & 0xff;

    // Generujemy kolor docelowy
    er = rand() & 0xff;
    eg = rand() & 0xff;
    eb = rand() & 0xff;

    // Tworzymy N punktów na powierzchni graficznej
    const int N = 50;  // Liczba punktów na obwodzie elipsy
    int x[N],y[N];

    for(int i = 0; i < N; i++)
    {
        x[i] = rand() % xmax;
        y[i] = rand() % ymax;
    }

    // Pętla nieskończona
    while(1)
    {
        // Ustawiamy kolor
        setcolor(COLOR(cr,cg,cb));

        // Modyfikujemy składowe kolorów
        if(cr > er) cr--;
        if(cr < er) cr++;
        if(cg > eg) cg--;
        if(cg < eg) cg++;
        if(cb > eb) cb--;
        if(cb < eb) cb++;

        if(cr == er) er = rand() & 0xff;
        if(cg == eg) eg = rand() & 0xff;
        if(cb == eb) eb = rand() & 0xff;

        // Rysujemy figurę

        moveto(x[0],y[0]);
        for(int i = 1; i < N; i++) lineto(x[i],y[i]);
    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Łamana
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

const int N = 50; // Liczba trójkątów

int main()
{
    int xmax,ymax,x[3],y[3],i,j;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(600,400,"Trójkąty");

    // Odczytujemy rozmiar obszaru roboczego okna
    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Pętla nieskończona
    while(1)
    {
        // Generujemy wierzchołki trójkąta
        for(i = 0; i < 2; i++)
        {
            x[i] = rand() % 200 - 100;
            y[i] = rand() % 200 - 100;
        }
        x[2] = -x[0] - x[1];
        y[2] = -y[0] - y[1];

        // Czyścimy treść okna
        cleardevice();

        // Na przypadkowych pozycjach rysujemy N trójkątów
        for(i = 0; i < N; i++)
        {
            // Kolor trójkąta
            setcolor(COLOR(rand() & 0xff,rand() & 0xff,rand() & 0xff));

            // Pozycja startowa
            moveto(rand() % xmax, rand() % ymax);

            // Rysujemy 3 odcinki
            for(j = 0; j < 3; j++) linerel(x[j],y[j]);

        }

        // Czekamy pół sekundy
        delay(500);
    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Klawiatura i myszka
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Otwieramy okno graficzne
    initwindow(600,600,"Klawiatura/myszka");

    // Zmienne
    int key;            // klawisz
    int x,y;            // Współrzędne kursora myszki
    bool drawing = FALSE; // Rysowanie

    setcolor(WHITE);

    // Pętla nieskończona
    while(1)
    {
        if(kbhit()) // Sprawdzamy, czy naciśnięto klawisz
        {
            key = getch(); // Tak, pobieramy kod klawisza
            switch(toupper(key))
            {
                case 'W': setcolor(WHITE);      break;
                case 'R': setcolor(LIGHTRED);   break;
                case 'G': setcolor(LIGHTGREEN); break;
                case 'B': setcolor(LIGHTBLUE);  break;
                default: break;
            }
        }

        // Sprawdzamy, czy wciśnieto prawy przycisk myszki
        getmouseclick(WM_RBUTTONDOWN,x,y);
        if(x != -1)
        {
            drawing = FALSE;
            cleardevice();
        }

        // Sprawdzamy, czy wciśnięto lewy przycisk myszki
        getmouseclick(WM_LBUTTONDOWN,x,y);
        if(x != -1)
        {
            drawing = TRUE;
            moveto(x,y);
        }

        // Sprawdzamy, czy zwolniono lewy przycisk myszki
        getmouseclick(WM_LBUTTONUP,x,y);
        if(x != -1)
        {
            drawing = FALSE;
            lineto(x,y);
        }

        // Sprawdzamy, czy należy rysować
        if(drawing)
        {
            // Sprawdzamy, czy myszka wykonała ruch
            getmouseclick(WM_MOUSEMOVE,x,y);
            if(x != -1) lineto(x,y);
        }
    }
    closegraph();
    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Grafika i tekst
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

extern ostringstream bgiout;

int main(void)
{
    // Zmienne
    int xmax,ymax,x1,y1,x2,y2;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Tworzymy okno graficzne
    initwindow(600, 400,"Tekst");

    xmax = getmaxx();
    ymax = getmaxy();

    // Pętla nieskończona
    while(1)
    {
        // Czyścimy okno
        cleardevice();

        // Generujemy początek odcinka
        x1 = xmax / 4 + rand() % 100;
        y1 = ymax / 4 + rand() % 100;

        // Generujemy koniec odcinka
        x2 = (3 * xmax / 4) - rand() % 100;
        y2 = (3 * ymax / 4) - rand() % 100;

        // Rysujemy odcinek w kolorze żółtym
        setcolor(YELLOW);
        line(x1,y1,x2,y2);

        // Kolor tekstu jasnozielony
        setcolor(LIGHTGREEN);

        // Współrzędne początku
        bgiout << "początek:" << endl
               << "(" << x1 << "," << y1 << ")";
        outstreamxy(x1 - 36,y1 - 36);

        // Kolor tekstu jasnoczerwony
        setcolor(LIGHTRED);

        // Współrzędne końca
        bgiout << "koniec:" << endl
               << "(" << x2 << "," << y2 << ")";
        outstreamxy(x2 - 24,y2 + 4);

        // Kolor tekstu biały
        setcolor(WHITE);

        // Czekamy na klawisz
        bgiout << "Naciśnij dowolny klawisz...";
        outstreamxy(0,0);
        getch();
    }

    closegraph( );
    return 0;

}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Tekst
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

extern ostringstream bgiout;

int main(void)
{
    // Zmienne
    int xmax,ymax;

    char t[2];

    t[1] = 0; // Znak EOT, czyli koniec tekstu

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Tworzymy okno graficzne
    initwindow(600, 400,"Tekst");

    xmax = getmaxx();
    ymax = getmaxy();

    // Pętla nieskończona
    while(1)
    {
        // Generujemy znak od A do Z

        t[0] = 'A' + rand() % ('Z' - 'A' + 1);

        // Kolor znaku
        setcolor(1 + rand() % 15);

        // Piszemy znak
        outtextxy(rand() % xmax, rand() % ymax, t);
    }

    closegraph( );

    return 0;

}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Tekst
//----------------------------

#include <iostream>
#include <graphics.h>

using namespace std;

int main(void)
{
    // Zmienne
    char * f[] = {(char *)"Standard",
                 (char *)"Triplex",
                 (char *)"Small",
                 (char *)"Sans Serif",
                 (char *)"Gothic",
                 (char *)"Script",
                 (char *)"Simplex",
                 (char *)"Triplex Script",
                 (char *)"Complex",
                 (char *)"European",
                 (char *)"Bold"};

    int i,x,y,s = 0;

    // Tworzymy okno graficzne
    initwindow(600, 500,"Tekst");

    // Pętla nieskończona
    while(1)
    {
        switch(s++)
        {
            case 0: setbkcolor(BLUE);
                    cleardevice();
                    setcolor(YELLOW);
                    x = getmaxx() / 2;
                    y = 64;
                    for(i = DEFAULT_FONT; i <= BOLD_FONT; i++)
                    {
                        if(i == SMALL_FONT) settextstyle(i,HORIZ_DIR,4);
                        else                settextstyle(i,HORIZ_DIR,1);
                        settextjustify(CENTER_TEXT,TOP_TEXT);
                        outtextxy(x,y,f[i]);
                        y += 16 + textheight(f[i]);
                    }
                    break;
            case 1: setbkcolor(RED);
                    cleardevice();
                    setcolor(WHITE);
                    x = 120;
                    y = getmaxy() / 2;
                    for(i = DEFAULT_FONT; i <= BOLD_FONT; i++)
                    {
                        if(i == SMALL_FONT) settextstyle(i,VERT_DIR,4);
                        else                settextstyle(i,VERT_DIR,1);
                        settextjustify(LEFT_TEXT,CENTER_TEXT);
                        outtextxy(x,y,f[i]);
                        x += 16 + textheight(f[i]);
                    }
                    break;
            case 2: setbkcolor(BLACK);
                    cleardevice();
                    setcolor(LIGHTRED);
                    y = 16;
                    for(i = DEFAULT_FONT; i <= BOLD_FONT; i++)
                    {
                        x = 16;
                        settextstyle(i,HORIZ_DIR,0);
                        settextjustify(LEFT_TEXT,TOP_TEXT);
                        setusercharsize(1,1,1,1);
                        moveto(x,y);
                        outtext(f[i]);
                        setusercharsize(2,3,1,1);
                        outtext((char *)" : A");
                        setusercharsize(1,1,1,1);
                        outtext((char *)"A");
                        setusercharsize(2,1,1,1);
                        outtext((char *)"A");
                        setusercharsize(3,1,1,1);
                        outtext((char *)"A");
                        setusercharsize(4,1,1,1);
                        outtext((char *)"A");
                        y += 16 + textheight("Ay");
                    }
                    break;
        }

        if(s == 3) s = 0;

        // Czekamy na klawisz
        getch();
    }

    closegraph( );

    return 0;

}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Obiekty
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

const int N = 20; // Liczba wierzchołków łamanej

int main(void)
{
    // Zmienne
    int xy[2 * N],dxy[2 * N],xmax,ymax,i,j;
    int cr,cg,cb,dr,dg,db;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Tworzymy okno graficzne
    initwindow(500, 400,"Łamane");

    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Inicjujemy tablice wierzchołków
    for(i = 0; i < N; i++)
    {
        j = i + i;
        xy[j] = rand() % xmax;
        do dxy[j] = 3 - rand() % 7; while(!dxy[j]);
        j++;
        xy[j] = rand() % ymax;
        do dxy[j] = 3 - rand() % 7; while(!dxy[j]);
    }
    // inicjujemy kolory składowe
    cr = rand() & 0xff;
    cg = rand() & 0xff;
    cb = rand() & 0xff;
    do dr = 3 - rand() % 7; while(!dr);
    do dg = 3 - rand() % 7; while(!dg);
    do db = 3 - rand() % 7; while(!db);

    // Pętla nieskończona
    while(1)
    {
        // Ustawiamy kolor
        setcolor(COLOR(cr,cg,cb));

        // Rysujemy łamaną
        drawpoly(N,xy);

        // modyfikujemy kolory
        cr += dr;
        if((cr < 0) || (cr > 255))
        {
            dr = -dr;
            cr += dr;
        }
        cg += dg;
        if((cg < 0) || (cg > 255))
        {
            dg = -dg;
            cg += dg;
        }
        cb += dr;
        if((cb < 0) || (cb > 255))
        {
            db = -db;
            cb += db;
        }

        // Modyfikujemy współrzędne wierzchołków
        for(i = 0; i < N; i++)
        {
            j = i + i;
            xy[j] += dxy[j];
            if((xy[j] < 0) || (xy[j] >= xmax)) dxy[j] = -dxy[j];
            j++;
            xy[j] += dxy[j];
            if((xy[j] < 0) || (xy[j] >= ymax)) dxy[j] = -dxy[j];
        }

        // Opóźnienie 1/20 sekundy
        delay(20);
    }

    closegraph( );

    return 0;
}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Obiekty
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

const int N = 3; // Liczba wierzchołków łamanej

int main(void)
{
    // Zmienne
    int xy[2 * (N + 1)],dxy[2 * N],xmax,ymax,i,j;
    int cr,cg,cb,dr,dg,db;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Tworzymy okno graficzne
    initwindow(500, 400,"Trójkąty");

    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Inicjujemy tablice wierzchołków
    for(i = 0; i < N; i++)
    {
        j = i + i;
        xy[j] = rand() % xmax;
        do dxy[j] = 3 - rand() % 7; while(!dxy[j]);
        j++;
        xy[j] = rand() % ymax;
        do dxy[j] = 3 - rand() % 7; while(!dxy[j]);
    }
    xy[6] = xy[0];
    xy[7] = xy[1];

    // inicjujemy kolory składowe
    cr = rand() & 0xff;
    cg = rand() & 0xff;
    cb = rand() & 0xff;
    do dr = 3 - rand() % 7; while(!dr);
    do dg = 3 - rand() % 7; while(!dg);
    do db = 3 - rand() % 7; while(!db);

    // Pętla nieskończona
    while(1)
    {
        // Ustawiamy kolor
        setcolor(COLOR(cr,cg,cb));

        // Rysujemy łamaną
        drawpoly(N + 1,xy);

        // modyfikujemy kolory
        cr += dr;
        if((cr < 0) || (cr > 255))
        {
            dr = -dr;
            cr += dr;
        }
        cg += dg;
        if((cg < 0) || (cg > 255))
        {
            dg = -dg;
            cg += dg;
        }
        cb += dr;
        if((cb < 0) || (cb > 255))
        {
            db = -db;
            cb += db;
        }

        // Modyfikujemy współrzędne wierzchołków
        for(i = 0; i < N; i++)
        {
            j = i + i;
            xy[j] += dxy[j];
            if((xy[j] < 0) || (xy[j] >= xmax)) dxy[j] = -dxy[j];
            j++;
            xy[j] += dxy[j];
            if((xy[j] < 0) || (xy[j] >= ymax)) dxy[j] = -dxy[j];
        }

        xy[6] = xy[0];
        xy[7] = xy[1];

        // Opóźnienie 1/20 sekundy
        delay(20);
    }

    closegraph( );

    return 0;

}

// BGI
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
// Obiekty
//----------------------------

#include <iostream>
#include <graphics.h>
#include <cstdlib>
#include <ctime>

using namespace std;

const int N = 10; // Liczba wierzchołków wielokąta

int main(void)
{
    // Zmienne
    char * s[] = {(char *)"EMPTY_FILL",
                 (char *)"SOLID_FILL",
                 (char *)"LINE_FILL",
                 (char *)"LTSLASH_FILL",
                 (char *)"SLASH_FILL",
                 (char *)"BKSLASH_FILL ",
                 (char *)"LTBKSLASH_FILL",
                 (char *)"HATCH_FILL",
                 (char *)"XHATCH_FILL",
                 (char *)"INTERLEAVE_FILL",
                 (char *)"WIDE_DOT_FILL",
                 (char *)"CLOSE_DOT_FILL",
                 (char *)"USER_FILL"};

    char f[] = { 0x00,  // 00000000
                 0x7E,  // 01111110
                 0x42,  // 01000010
                 0x5A,  // 01011010
                 0x5A,  // 01011010
                 0x42,  // 01000010
                 0x7E,  // 01111110
                 0x00}; // 00000000

    int p[2 * N];
    int i,j,xmax,ymax;

    // Inicjujemy generator pseudolosowy
    srand(time(NULL));

    // Tworzymy okno graficzne
    initwindow(600, 400,"Wieloboki");

    xmax = getmaxx() + 1;
    ymax = getmaxy() + 1;

    // Generujemy wierzchołki
    for(i = 0; i < N; i++)
    {
        j = i + i;
        p[j++] = rand() % xmax;
        p[j]   = 32 + rand() % (ymax - 32);
    }

    // Wyświetlamy wielobok z kolejnymi wypełnieniami

    for(i = EMPTY_FILL; i <= USER_FILL; i++)
    {
        // Czyścimy okno
        cleardevice();

        // Kolor tła
        setbkcolor(BLUE);

        // Kolor Linii
        setcolor(WHITE);

        // Rodzaj i kolor wypełnienia
        if(i != USER_FILL) setfillstyle(i,YELLOW);
        else               setfillpattern(f,LIGHTRED);

        // Rysujemy wielobok
        fillpoly(N,p);

        // Wyświetlamy nazwę wypełnienia
        setcolor(LIGHTCYAN);
        setbkcolor(BLACK);
        settextstyle(TRIPLEX_FONT,HORIZ_DIR,2);
        settextjustify(CENTER_TEXT,TOP_TEXT);
        moveto(xmax / 2, 5);
        outtext(s[i]);

        // Czekamy na klawisz
        getch();
    }

    closegraph( );

    return 0;
}