API tools faq
paste
GieeF

Untitled

GieeF
Jan 4th, 2020
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 24.05 KB | None | 0 0
raw download clone embed print report
  1. #ifdef __cplusplus
  2.     #include <cstdlib>
  3. #else
  4.     #include <stdlib.h>
  5.  
  6. #endif
  7. #include <SDL/SDL.h>
  8. #include <math.h>
  9. #include <time.h>
  10. #include <iostream>
  11. #define M_PI       3.14159265358979323846
  12. using namespace std;
  13.  
  14. SDL_Surface *screen;
  15. int width = 512;
  16. int height = 340;
  17. char const* tytul = "GKiM2019 - Lab 11 - Balaban Kamil";
  18.  
  19. struct YCbCr {
  20.     float y;
  21.     float cb;
  22.     float cr;
  23. };
  24.  
  25. struct HSV {
  26.     float h;
  27.     float s;
  28.     float v;
  29. };
  30.  
  31. const int ROZMIAR_BLOKU = 8;
  32.  
  33. struct macierz {
  34.     float dct[ROZMIAR_BLOKU][ROZMIAR_BLOKU];
  35.     Uint8 dane[ROZMIAR_BLOKU][ROZMIAR_BLOKU];
  36. };
  37.  
  38. void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B);
  39. SDL_Color getPixel (int x, int y);
  40.  
  41. void czyscEkran(Uint8 R, Uint8 G, Uint8 B);
  42.  
  43. void Linia(int x1, int y1, int x2, int y2, Uint8 R, Uint8 G, Uint8 B);
  44. void Okrag(int x, int y, int r, Uint8 R, Uint8 G, Uint8 B);
  45. void Elipsa(int x, int y, int a, int b, Uint8 R, Uint8 G, Uint8 B);
  46. YCbCr RGBtoYCbCr(SDL_Color rgb);
  47. SDL_Color YCbCrtoRGB(YCbCr ycbcr);
  48. SDL_Color HSVtoRGB(HSV hsv);
  49. HSV RGBtoHSV(SDL_Color rgb);
  50. macierz dct(Uint8 wartosci[ROZMIAR_BLOKU][ROZMIAR_BLOKU]);
  51. macierz idct(float DCT[ROZMIAR_BLOKU][ROZMIAR_BLOKU]);
  52.  
  53. void Funkcja1();
  54. void Funkcja2();
  55. void Funkcja3();
  56. void Funkcja4();
  57. void Funkcja5();
  58. void Funkcja6();
  59. void Funkcja7();
  60. void Funkcja8();
  61. void Funkcja9();
  62.  
  63.  
  64. void Funkcja1() {
  65.  
  66.     float kolor = 0;
  67.  
  68.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  69.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  70.             setPixel(x+128, y+64, kolor, kolor, kolor);
  71.             kolor+= 256.0/(ROZMIAR_BLOKU*ROZMIAR_BLOKU);
  72.         }
  73.     }
  74.  
  75.     for(int y = 1; y< ROZMIAR_BLOKU; y+=2) {
  76.         for(int x = 1; x < ROZMIAR_BLOKU; x+=2) {
  77.             setPixel(x+128, y+64+ROZMIAR_BLOKU, 255, 255, 255);
  78.             setPixel(x+128-1, y+64+ROZMIAR_BLOKU-1, 128, 128, 128);
  79.             setPixel(x+128, y+64+ROZMIAR_BLOKU-1, 0, 0, 0);
  80.             setPixel(x+128-1, y+64+ROZMIAR_BLOKU, 0, 0, 0);
  81.         }
  82.     }
  83.  
  84.     SDL_Flip(screen);
  85. }
  86.  
  87. void wyswietlDane(macierz blok) {
  88.  
  89.     cout << "Dane pikselowe w macierzy: " << endl;
  90.  
  91.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  92.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  93.             cout << (int)blok.dane[x][y]<<" ";
  94.         }
  95.         cout << endl;
  96.     }
  97. }
  98.  
  99. void wyswietlDCT(macierz blok) {
  100.  
  101.     cout << "Wspolczynniki transformaty w macierzy: " << endl;
  102.  
  103.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  104.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  105.             cout << (float)blok.dct[x][y]<<" ";
  106.         }
  107.         cout << endl;
  108.     }
  109. }
  110.  
  111. void Funkcja2() {
  112.  
  113.     macierz blok;
  114.     macierz blokDCT;
  115.     macierz blokDane;
  116.  
  117.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  118.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  119.             blok.dane[x][y] = getPixel(x+128, y+64).r;
  120.             blok.dct[x][y] = 0;
  121.         }
  122.     }
  123.     wyswietlDane(blok);
  124.     blokDCT = dct(blok.dane);
  125.  
  126.     wyswietlDCT(blokDCT);
  127.  
  128.     blokDane = idct(blokDCT.dct);
  129.     wyswietlDane(blokDane);
  130.  
  131.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  132.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  133.             setPixel(x+128+(width/2), y+64, blokDane.dane[x][y], blokDane.dane[x][y], blokDane.dane[x][y]);
  134.         }
  135.     }
  136.  
  137.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  138.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  139.             blok.dane[x][y] = getPixel(x+128, y+64+ROZMIAR_BLOKU).r;
  140.             blok.dct[x][y] = 0;
  141.         }
  142.     }
  143.     wyswietlDane(blok);
  144.     blokDCT = dct(blok.dane);
  145.  
  146.     wyswietlDCT(blokDCT);
  147.  
  148.     blokDane = idct(blokDCT.dct);
  149.     wyswietlDane(blokDane);
  150.  
  151.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  152.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  153.             setPixel(x+128+(width/2), y+64+ROZMIAR_BLOKU, blokDane.dane[x][y], blokDane.dane[x][y], blokDane.dane[x][y]);
  154.         }
  155.     }
  156.  
  157.     SDL_Flip(screen);
  158. }
  159.  
  160. macierz zakraglenieDCT(macierz blok) {
  161.     macierz wynik = blok;
  162.  
  163.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  164.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  165.             wynik.dct[x][y] = round(blok.dct[x][y]);
  166.         }
  167.     }
  168.     return wynik;
  169. }
  170.  
  171. macierz utnijMacierz(macierz wejscie, int ile) {
  172.     macierz wynik = wejscie;
  173.  
  174.     if(ile > 0) {
  175.         wynik.dct[ROZMIAR_BLOKU-1][ROZMIAR_BLOKU-1] = 0;
  176.     }
  177.     int a, b;
  178.     if(ile > 1) {
  179.         for(int j = ile; j > 0; j--) {
  180.             for(int i = j-1; i>=0; i--) {
  181.                 a = i+1;
  182.                 b = j-i;
  183.                 wynik.dct[ROZMIAR_BLOKU-a][ROZMIAR_BLOKU-b] = 0;
  184.             }
  185.         }
  186.     }
  187.  
  188.     return wynik;
  189. }
  190.  
  191. void Funkcja3() {
  192.  
  193.     macierz blok;
  194.     macierz blokDCT;
  195.     macierz blokDane;
  196.  
  197.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  198.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  199.             blok.dane[x][y] = getPixel(x+128, y+64).r;
  200.             blok.dct[x][y] = 0;
  201.         }
  202.     }
  203.     wyswietlDane(blok);
  204.     blokDCT = dct(blok.dane);
  205.     blokDCT = zakraglenieDCT(blokDCT);
  206.     wyswietlDCT(blokDCT);
  207.  
  208.     blokDCT = utnijMacierz(blokDCT, 5);
  209.     wyswietlDCT(blokDCT);
  210.  
  211.     blokDane = idct(blokDCT.dct);
  212.     wyswietlDane(blokDane);
  213.  
  214.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  215.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  216.             setPixel(x+128+(width/2), y+64, blokDane.dane[x][y], blokDane.dane[x][y], blokDane.dane[x][y]);
  217.         }
  218.     }
  219.  
  220.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  221.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  222.             blok.dane[x][y] = getPixel(x+128, y+64+ROZMIAR_BLOKU).r;
  223.             blok.dct[x][y] = 0;
  224.         }
  225.     }
  226.     wyswietlDane(blok);
  227.     blokDCT = dct(blok.dane);
  228.  
  229.     blokDCT = zakraglenieDCT(blokDCT);
  230.     wyswietlDCT(blokDCT);
  231.  
  232.     blokDCT = utnijMacierz(blokDCT, 5);
  233.     wyswietlDCT(blokDCT);
  234.  
  235.     blokDane = idct(blokDCT.dct);
  236.     wyswietlDane(blokDane);
  237.  
  238.     for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  239.         for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  240.             setPixel(x+128+(width/2), y+64+ROZMIAR_BLOKU, blokDane.dane[x][y], blokDane.dane[x][y], blokDane.dane[x][y]);
  241.         }
  242.     }
  243.  
  244.     SDL_Flip(screen);
  245. }
  246.  
  247. void Funkcja4() {
  248.  
  249.     macierz blok;
  250.     macierz blokDCT;
  251.     macierz blokDane;
  252.  
  253.     for(int i = 0; i < width/ROZMIAR_BLOKU; i++) {
  254.         for(int j = 0; j < height/ROZMIAR_BLOKU; j++) {
  255.             for(int y = 0; y < ROZMIAR_BLOKU; y++) {
  256.                 for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  257.                     blok.dane[x][y] = getPixel(x+i*ROZMIAR_BLOKU, y+j*ROZMIAR_BLOKU).r;
  258.                     blok.dct[x][y] = 0;
  259.                 }
  260.             }
  261.             blokDCT = dct(blok.dane);
  262.             blokDCT = zakraglenieDCT(blokDCT);
  263.             blokDCT = utnijMacierz(blokDCT, 8);
  264.             blokDane = idct(blokDCT.dct);
  265.  
  266.             for(int y = 0; y< ROZMIAR_BLOKU; y++) {
  267.                 for(int x = 0; x < ROZMIAR_BLOKU; x++) {
  268.                     setPixel(x+i*ROZMIAR_BLOKU+(width/2), y+j*ROZMIAR_BLOKU, blokDane.dane[x][y], blokDane.dane[x][y], blokDane.dane[x][y]);
  269.                 }
  270.             }
  271.         }
  272.     }
  273.  
  274.  
  275.  
  276.     SDL_Flip(screen);
  277. }
  278.  
  279.  
  280. void Funkcja5() {
  281.  
  282.     //...
  283.  
  284.     SDL_Flip(screen);
  285. }
  286.  
  287.  
  288. void Funkcja6() {
  289.  
  290.     //...
  291.  
  292.     SDL_Flip(screen);
  293. }
  294.  
  295.  
  296. void Funkcja7() {
  297.  
  298.     //...
  299.  
  300.     SDL_Flip(screen);
  301. }
  302.  
  303.  
  304. void Funkcja8() {
  305.  
  306.     //...
  307.  
  308.     SDL_Flip(screen);
  309. }
  310.  
  311.  
  312. void Funkcja9() {
  313.  
  314.     //...
  315.  
  316.     SDL_Flip(screen);
  317. }
  318.  
  319.  
  320. macierz dct(Uint8 wartosci[ROZMIAR_BLOKU][ROZMIAR_BLOKU])
  321. {
  322.     float wynik[ROZMIAR_BLOKU][ROZMIAR_BLOKU];
  323.  
  324.     // obliczamy DCT
  325.     for (unsigned v = 0; v < ROZMIAR_BLOKU; ++v) {
  326.         for (unsigned u = 0; u < ROZMIAR_BLOKU; ++u) {
  327.             const double cu = (u == 0) ? 1.0 / sqrt(2) : 1.0;
  328.             const double cv = (v == 0) ? 1.0 / sqrt(2) : 1.0;
  329.             double dctCoeff = 0;
  330.  
  331.             for (unsigned y = 0; y < ROZMIAR_BLOKU; ++y) {
  332.                 for (unsigned x = 0; x < ROZMIAR_BLOKU; ++x) {
  333.                     double uCosFactor = cos((double)(2 * x + 1) * M_PI * (double)u / (2 * (double) ROZMIAR_BLOKU));
  334.                     double vCosFactor = cos((double)(2 * y + 1) * M_PI * (double)v / (2 * (double) ROZMIAR_BLOKU));
  335.                     double pixel = (double)wartosci[x][y];
  336.                     dctCoeff +=  pixel * uCosFactor * vCosFactor;
  337.                 }
  338.             }
  339.             dctCoeff *= (2.0 / (double) ROZMIAR_BLOKU) * cu * cv;
  340.             wynik[u][v] = dctCoeff;
  341.         }
  342.     }
  343.  
  344.     macierz rezultat;
  345.     for (int j=0; j<ROZMIAR_BLOKU; j++) {
  346.         for (int i=0; i<ROZMIAR_BLOKU; i++) {
  347.             rezultat.dct[i][j] = wynik[i][j];
  348.             rezultat.dane[i][j] = wartosci[i][j];
  349.         }
  350.     }
  351.  
  352.     return rezultat;
  353. }
  354.  
  355. macierz idct(float DCT[ROZMIAR_BLOKU][ROZMIAR_BLOKU]) {
  356.     int wynik[ROZMIAR_BLOKU][ROZMIAR_BLOKU];
  357.     // obliczamy DCT
  358.     for (unsigned x = 0; x < ROZMIAR_BLOKU; ++x) {
  359.         for (unsigned y = 0; y < ROZMIAR_BLOKU; ++y) {
  360.  
  361.             double pixel = 0;
  362.  
  363.             for (unsigned u = 0; u < ROZMIAR_BLOKU; ++u) {
  364.                 for (unsigned v = 0; v < ROZMIAR_BLOKU; ++v) {
  365.                     const double cu = (u == 0) ? 1.0 / sqrt(2) : 1.0;
  366.                     const double cv = (v == 0) ? 1.0 / sqrt(2) : 1.0;
  367.                     double uCosFactor = cos((double)(2 * x + 1) * M_PI * (double)u / (2 * (double) ROZMIAR_BLOKU));
  368.                     double vCosFactor = cos((double)(2 * y + 1) * M_PI * (double)v / (2 * (double) ROZMIAR_BLOKU));
  369.                     double coeff = DCT[u][v];
  370.                     pixel +=  coeff * uCosFactor * vCosFactor * cu * cv;
  371.                 }
  372.             }
  373.             pixel *= (2.0 / (double) ROZMIAR_BLOKU) ;
  374.             wynik[x][y] = pixel;
  375.         }
  376.     }
  377.  
  378.     macierz rezultat;
  379.     for (int j=0; j<ROZMIAR_BLOKU; j++) {
  380.         for (int i=0; i<ROZMIAR_BLOKU; i++) {
  381.             if (wynik[i][j]>255) wynik[i][j]=255;
  382.             if (wynik[i][j]<0) wynik[i][j]=0;
  383.             rezultat.dane[i][j] = wynik[i][j];
  384.             rezultat.dct[i][j] = DCT[i][j];
  385.         }
  386.     }
  387.     return rezultat;
  388. }
  389.  
  390. void Linia(int x1, int y1, int x2, int y2, Uint8 R, Uint8 G, Uint8 B) {
  391.     setPixel(x1,y1,R,G,B);
  392.     setPixel(x2,y2,R,G,B);
  393.      // zmienne pomocnicze
  394.      int d, dx, dy, ai, bi, xi, yi;
  395.      int x = x1, y = y1;
  396.      // ustalenie kierunku rysowania
  397.      if (x1 < x2)
  398.      {
  399.          xi = 1;
  400.          dx = x2 - x1;
  401.      }
  402.      else
  403.      {
  404.          xi = -1;
  405.          dx = x1 - x2;
  406.      }
  407.      // ustalenie kierunku rysowania
  408.      if (y1 < y2)
  409.      {
  410.          yi = 1;
  411.          dy = y2 - y1;
  412.      }
  413.      else
  414.      {
  415.          yi = -1;
  416.          dy = y1 - y2;
  417.      }
  418.      // pierwszy piksel
  419.      setPixel(x, y, R, G, B);
  420.      // oś wiodąca OX
  421.      if (dx > dy)
  422.      {
  423.          ai = (dy - dx) * 2;
  424.          bi = dy * 2;
  425.          d = bi - dx;
  426.          // pętla po kolejnych x
  427.          while (x != x2)
  428.          {
  429.              // test współczynnika
  430.              if (d >= 0)
  431.              {
  432.                  x += xi;
  433.                  y += yi;
  434.                  d += ai;
  435.              }
  436.              else
  437.              {
  438.                  d += bi;
  439.                  x += xi;
  440.              }
  441.              setPixel(x, y, R, G, B);
  442.          }
  443.      }
  444.      // oś wiodąca OY
  445.      else
  446.      {
  447.          ai = ( dx - dy ) * 2;
  448.          bi = dx * 2;
  449.          d = bi - dy;
  450.          // pętla po kolejnych y
  451.          while (y != y2)
  452.          {
  453.              // test współczynnika
  454.              if (d >= 0)
  455.              {
  456.                  x += xi;
  457.                  y += yi;
  458.                  d += ai;
  459.              }
  460.              else
  461.              {
  462.                  d += bi;
  463.                  y += yi;
  464.              }
  465.              setPixel(x, y, R, G, B);
  466.          }
  467.      }
  468.     SDL_Flip(screen);
  469. }
  470.  
  471. void RysujOkrag(int x0, int y0, int x, int y, Uint8 R, Uint8 G, Uint8 B){
  472.     setPixel(x+x0, y+y0, R, G, B);
  473.     setPixel(y+x0, x+y0, R, G, B);
  474.     setPixel(y+x0, -x+y0, R, G, B);
  475.     setPixel(x+x0, -y+y0, R, G, B);
  476.     setPixel(-x+x0, -y+y0, R, G, B);
  477.     setPixel(-y+x0, -x+y0, R, G, B);
  478.     setPixel(-y+x0, x+y0, R, G, B);
  479.     setPixel(-x+x0, y+y0, R, G, B);;
  480. }
  481.  
  482.  
  483. void Okrag(int x0, int y0, int r, Uint8 R, Uint8 G, Uint8 B) {
  484.     int x =0;
  485.     int y=r;
  486.     int d = 3-2*r;
  487.  
  488.     while (x <= y){
  489.         if (d<0){
  490.             d=d+4*x+6;
  491.             RysujOkrag(x0, y0, x, y, R, G, B);
  492.         } else{
  493.             d=d+4*(x-y)+10;
  494.             y--;
  495.             RysujOkrag(x0, y0, x, y, R, G, B);
  496.         }
  497.         x++;
  498.     }
  499.     SDL_Flip(screen);
  500. }
  501.  
  502. void Elipsa(int x, int y, int a, int b, Uint8 R, Uint8 G, Uint8 B) {
  503.     int xc  = 0,
  504.         yc  = b;
  505.     int aa  = a * a,
  506.         aa2 = aa + aa,
  507.         bb  = b * b,
  508.         bb2 = bb + bb;
  509.     int d   = bb - aa * b + (aa / 4),
  510.         dx  = 0,
  511.         dy  = aa2 * b;
  512.  
  513.     while (dx < dy) {
  514.         setPixel (x - xc,y - yc, R, G, B);
  515.         setPixel (x - xc,y + yc, R, G, B);
  516.         setPixel (x + xc,y - yc, R, G, B);
  517.         setPixel (x + xc,y + yc, R, G, B);
  518.         if (d > 0){
  519.             yc  = yc-1;
  520.             dy -= aa2;
  521.             d  -= dy;
  522.         }
  523.         xc  =xc+1;
  524.         dx += bb2;
  525.         d  += bb + dx;
  526.     }
  527.     d += (3 * ((aa - bb) / 2) - (dx + dy) / 2);
  528.  
  529.     while (yc >= 0) {
  530.         setPixel (x - xc,y - yc, R, G, B);
  531.         setPixel (x - xc,y + yc, R, G, B);
  532.         setPixel (x + xc,y - yc, R, G, B);
  533.         setPixel (x + xc,y + yc, R, G, B);
  534.         if (d < 0) {
  535.             xc =xc+1;
  536.             dx += bb2;
  537.             d  += (bb + dx);
  538.         }
  539.         yc  = yc-1;
  540.         dy -= aa2;
  541.         d  += aa - dy;
  542.     }
  543.     SDL_Flip(screen);
  544. }
  545.  
  546. YCbCr RGBtoYCbCr(SDL_Color rgb) {
  547.     YCbCr ycbcr;
  548.  
  549.     ycbcr.y =        0.299 * rgb.r       + 0.587*rgb.g + 0.114*rgb.b;
  550.     ycbcr.cb = 128 - 0.168736 * rgb.r - 0.331264*rgb.g +   0.5*rgb.b;
  551.     ycbcr.cr = 128 + 0.5 * rgb.r      - 0.418688*rgb.g - 0.081312*rgb.b;
  552.  
  553.     return ycbcr;
  554. }
  555.  
  556. float normalizacja(float wartosc) {
  557.     float wynik = wartosc;
  558.     if (wartosc > 255) wartosc = 255;
  559.     if (wartosc < 0) wartosc = 0;
  560.     return wartosc;
  561. }
  562.  
  563. SDL_Color YCbCrtoRGB(YCbCr ycbcr) {
  564.     SDL_Color rgb;
  565.     int R, G, B;
  566.  
  567.     R = ycbcr.y + 1.402*(ycbcr.cr-128);
  568.     G = ycbcr.y - 0.344136*(ycbcr.cb-128) - 0.714136*(ycbcr.cr-128);
  569.     B = ycbcr.y + 1.772*(ycbcr.cb-128);
  570.  
  571.     R = normalizacja(R);
  572.     G = normalizacja(G);
  573.     B = normalizacja(B);
  574.  
  575.     rgb = {.r=R, .g=G, .b=B};
  576.     return rgb;
  577. }
  578.  
  579. HSV RGBtoHSV(SDL_Color rgb) {
  580.     HSV hsv;
  581.     unsigned char rgbMin, rgbMax;
  582.  
  583.     rgbMin = rgb.r < rgb.g ? (rgb.r < rgb.b ? rgb.r : rgb.b) : (rgb.g < rgb.b ? rgb.g : rgb.b);
  584.     rgbMax = rgb.r > rgb.g ? (rgb.r > rgb.b ? rgb.r : rgb.b) : (rgb.g > rgb.b ? rgb.g : rgb.b);
  585.  
  586.     hsv.v = rgbMax;
  587.     if (hsv.v == 0) {
  588.         hsv.h = 0;
  589.         hsv.s = 0;
  590.         return hsv;
  591.     }
  592.  
  593.     hsv.s = 255.0*(rgbMax-rgbMin)/hsv.v;
  594.  
  595.     if (hsv.s == 0) {
  596.         hsv.h = 0;
  597.         return hsv;
  598.     }
  599.  
  600.     if (rgbMax == rgb.r) {
  601.         hsv.h = 0 + 43.0*(rgb.g-rgb.b)/(rgbMax-rgbMin);
  602.     }
  603.     else if (rgbMax == rgb.g) {
  604.         hsv.h = 85 + 43.0*(rgb.b-rgb.r)/(rgbMax-rgbMin);
  605.     }
  606.     else {
  607.         hsv.h = 171 + 43.0*(rgb.r-rgb.g)/(rgbMax-rgbMin);
  608.     }
  609.  
  610.     if (hsv.h>255) hsv.h-=255;
  611.     if (hsv.h<0) hsv.h+=255;
  612.  
  613.     hsv.s = normalizacja(hsv.s);
  614.     hsv.v = normalizacja(hsv.v);
  615.  
  616.     return hsv;
  617. }
  618.  
  619.  
  620. SDL_Color HSVtoRGB(HSV hsv) {
  621.     SDL_Color rgb;
  622.     int R, G, B;
  623.  
  624.     if (hsv.h < 0) hsv.h += 255;
  625.     if (hsv.h > 255) hsv.h -= 255;
  626.     hsv.s = normalizacja(hsv.s);
  627.     hsv.v = normalizacja(hsv.v);
  628.  
  629.     unsigned char region, p, q, t;
  630.     double h;
  631.     unsigned int s, v, reszta;
  632.  
  633.     if (hsv.s == 0) {
  634.         R = hsv.v;
  635.         G = hsv.v;
  636.         B = hsv.v;
  637.     }
  638.  
  639.     h = hsv.h;
  640.     s = hsv.s;
  641.     v = hsv.v;
  642.  
  643.  
  644.     region = h / 43;
  645.     reszta = (h - (region * 43) ) * 6;
  646.  
  647.     p = (v * (255 - s)) >> 8;
  648.     q = (v * (255 - ((s * reszta) >> 8 ))) >> 8;
  649.     t = (v * (255 - ((s * (255 - reszta)) >> 8 ))) >> 8;
  650.  
  651.     switch (region) {
  652.     case 0:
  653.         R = v;  G = t;  B = p;
  654.         break;
  655.     case 1:
  656.         R = q;  G = v;  B = p;
  657.         break;
  658.     case 2:
  659.         R = p;  G = v;  B = t;
  660.         break;
  661.     case 3:
  662.         R = p;  G = q;  B = v;
  663.         break;
  664.     case 4:
  665.         R = t;  G = p;  B = v;
  666.         break;
  667.     default:
  668.         R = v;  G = p;  B = q;
  669.         break;
  670.     }
  671.     rgb = {R, G, B};
  672.     return rgb;
  673. }
  674.  
  675.  
  676. void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B)
  677. {
  678.   if ((x>=0) && (x<width) && (y>=0) && (y<height))
  679.   {
  680.     /* Zamieniamy poszczególne składowe koloru na format koloru piksela */
  681.     Uint32 pixel = SDL_MapRGB(screen->format, R, G, B);
  682.  
  683.     /* Pobieramy informację ile bajtów zajmuje jeden piksel */
  684.     int bpp = screen->format->BytesPerPixel;
  685.  
  686.     /* Obliczamy adres piksela */
  687.     Uint8 *p1 = (Uint8 *)screen->pixels + (y*2) * screen->pitch + (x*2) * bpp;
  688.     Uint8 *p2 = (Uint8 *)screen->pixels + (y*2+1) * screen->pitch + (x*2) * bpp;
  689.     Uint8 *p3 = (Uint8 *)screen->pixels + (y*2) * screen->pitch + (x*2+1) * bpp;
  690.     Uint8 *p4 = (Uint8 *)screen->pixels + (y*2+1) * screen->pitch + (x*2+1) * bpp;
  691.  
  692.     /* Ustawiamy wartość piksela, w zależności od formatu powierzchni*/
  693.     switch(bpp)
  694.     {
  695.         case 1: //8-bit
  696.             *p1 = pixel;
  697.             *p2 = pixel;
  698.             *p3 = pixel;
  699.             *p4 = pixel;
  700.             break;
  701.  
  702.         case 2: //16-bit
  703.             *(Uint16 *)p1 = pixel;
  704.             *(Uint16 *)p2 = pixel;
  705.             *(Uint16 *)p3 = pixel;
  706.             *(Uint16 *)p4 = pixel;
  707.             break;
  708.  
  709.         case 3: //24-bit
  710.             if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
  711.                 p1[0] = (pixel >> 16) & 0xff;
  712.                 p1[1] = (pixel >> 8) & 0xff;
  713.                 p1[2] = pixel & 0xff;
  714.                 p2[0] = (pixel >> 16) & 0xff;
  715.                 p2[1] = (pixel >> 8) & 0xff;
  716.                 p2[2] = pixel & 0xff;
  717.                 p3[0] = (pixel >> 16) & 0xff;
  718.                 p3[1] = (pixel >> 8) & 0xff;
  719.                 p3[2] = pixel & 0xff;
  720.                 p4[0] = (pixel >> 16) & 0xff;
  721.                 p4[1] = (pixel >> 8) & 0xff;
  722.                 p4[2] = pixel & 0xff;
  723.             } else {
  724.                 p1[0] = pixel & 0xff;
  725.                 p1[1] = (pixel >> 8) & 0xff;
  726.                 p1[2] = (pixel >> 16) & 0xff;
  727.                 p2[0] = pixel & 0xff;
  728.                 p2[1] = (pixel >> 8) & 0xff;
  729.                 p2[2] = (pixel >> 16) & 0xff;
  730.                 p3[0] = pixel & 0xff;
  731.                 p3[1] = (pixel >> 8) & 0xff;
  732.                 p3[2] = (pixel >> 16) & 0xff;
  733.                 p4[0] = pixel & 0xff;
  734.                 p4[1] = (pixel >> 8) & 0xff;
  735.                 p4[2] = (pixel >> 16) & 0xff;
  736.             }
  737.             break;
  738.  
  739.         case 4: //32-bit
  740.             *(Uint32 *)p1 = pixel;
  741.             *(Uint32 *)p2 = pixel;
  742.             *(Uint32 *)p3 = pixel;
  743.             *(Uint32 *)p4 = pixel;
  744.             break;
  745.  
  746.     }
  747.          /* ewentualna aktualizacja obrazu (aka double buffering) */
  748.   }
  749. }
  750.  
  751. SDL_Color getPixel(int x, int y) {
  752.     SDL_Color color ;
  753.     Uint32 col = 0 ;
  754.     if ((x>=0) && (x<width) && (y>=0) && (y<height)) {
  755.         //określamy pozycję
  756.         char* pPosition=(char*)screen->pixels ;
  757.         //przesunięcie względem y
  758.         pPosition+=(screen->pitch*y*2) ;
  759.         //przesunięcie względem x
  760.         pPosition+=(screen->format->BytesPerPixel*x*2);
  761.         //kopiujemy dane piksela
  762.         memcpy(&col, pPosition, screen->format->BytesPerPixel);
  763.         //konwertujemy kolor
  764.         SDL_GetRGB(col, screen->format, &color.r, &color.g, &color.b);
  765.     }
  766.     return ( color ) ;
  767. }
  768.  
  769. SDL_Color getPixelSurface(int x, int y, SDL_Surface *surface) {
  770.     SDL_Color color ;
  771.     Uint32 col = 0 ;
  772.     //określamy pozycję
  773.     char* pPosition=(char*)surface->pixels ;
  774.     //przesunięcie względem y
  775.     pPosition+=(surface->pitch*y) ;
  776.     //przesunięcie względem x
  777.     pPosition+=(surface->format->BytesPerPixel*x);
  778.     //kopiujemy dane piksela
  779.     memcpy(&col, pPosition, surface->format->BytesPerPixel);
  780.     //konwertujemy kolor
  781.     SDL_GetRGB(col, surface->format, &color.r, &color.g, &color.b);
  782.     return ( color ) ;
  783. }
  784.  
  785. void czyscEkran(Uint8 R, Uint8 G, Uint8 B)
  786. {
  787.     SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, R, G, B));
  788.     SDL_Flip(screen);
  789.  
  790. }
  791.  
  792. void ladujBMP(char const* nazwa, int x, int y)
  793. {
  794.     SDL_Surface* bmp = SDL_LoadBMP(nazwa);
  795.     if (!bmp)
  796.     {
  797.         printf("Unable to load bitmap: %s\n", SDL_GetError());
  798.     }
  799.     else
  800.     {
  801.         SDL_Color kolor;
  802.         for (int yy=0; yy<bmp->h; yy++) {
  803.             for (int xx=0; xx<bmp->w; xx++) {
  804.                 kolor = getPixelSurface(xx, yy, bmp);
  805.                 setPixel(xx, yy, kolor.r, kolor.g, kolor.b);
  806.             }
  807.         }
  808.         SDL_FreeSurface(bmp);
  809.         SDL_Flip(screen);
  810.     }
  811.  
  812. }
  813.  
  814.  
  815. int main ( int argc, char** argv )
  816. {
  817.     // console output
  818.     freopen( "CON", "wt", stdout );
  819.     freopen( "CON", "wt", stderr );
  820.  
  821.     // initialize SDL video
  822.     if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  823.     {
  824.         printf( "Unable to init SDL: %s\n", SDL_GetError() );
  825.         return 1;
  826.     }
  827.  
  828.     // make sure SDL cleans up before exit
  829.     atexit(SDL_Quit);
  830.  
  831.     // create a new window
  832.     screen = SDL_SetVideoMode(width*2, height*2, 32,
  833.                                            SDL_HWSURFACE|SDL_DOUBLEBUF);
  834.     if ( !screen )
  835.     {
  836.         printf("Unable to set video: %s\n", SDL_GetError());
  837.         return 1;
  838.     }
  839.  
  840.     SDL_WM_SetCaption( tytul , NULL );
  841.     // program main loop
  842.     bool done = false;
  843.     while (!done)
  844.     {
  845.         // message processing loop
  846.         SDL_Event event;
  847.         while (SDL_PollEvent(&event))
  848.         {
  849.             // check for messages
  850.             switch (event.type)
  851.             {
  852.                 // exit if the window is closed
  853.             case SDL_QUIT:
  854.                 done = true;
  855.                 break;
  856.  
  857.                 // check for keypresses
  858.             case SDL_KEYDOWN:
  859.                 {
  860.                     // exit if ESCAPE is pressed
  861.                     if (event.key.keysym.sym == SDLK_ESCAPE)
  862.                         done = true;
  863.                     if (event.key.keysym.sym == SDLK_1)
  864.                         Funkcja1();
  865.                     if (event.key.keysym.sym == SDLK_2)
  866.                         Funkcja2();
  867.                     if (event.key.keysym.sym == SDLK_3)
  868.                         Funkcja3();
  869.                     if (event.key.keysym.sym == SDLK_4)
  870.                         Funkcja4();
  871.                     if (event.key.keysym.sym == SDLK_5)
  872.                         Funkcja5();
  873.                     if (event.key.keysym.sym == SDLK_6)
  874.                         Funkcja6();
  875.                     if (event.key.keysym.sym == SDLK_7)
  876.                         Funkcja7();
  877.  
  878.                     if (event.key.keysym.sym == SDLK_a)
  879.                         ladujBMP("obrazek1.bmp", 0, 0);
  880.                     if (event.key.keysym.sym == SDLK_s)
  881.                         ladujBMP("obrazek2.bmp", 0, 0);
  882.                     if (event.key.keysym.sym == SDLK_d)
  883.                         ladujBMP("obrazek3.bmp", 0, 0);
  884.                     if (event.key.keysym.sym == SDLK_f)
  885.                         ladujBMP("obrazek4.bmp", 0, 0);
  886.                     if (event.key.keysym.sym == SDLK_z)
  887.                         ladujBMP("obrazek5.bmp", 0, 0);
  888.                     if (event.key.keysym.sym == SDLK_x)
  889.                         ladujBMP("obrazek6.bmp", 0, 0);
  890.                     if (event.key.keysym.sym == SDLK_c)
  891.                         ladujBMP("obrazek7.bmp", 0, 0);
  892.                     if (event.key.keysym.sym == SDLK_v)
  893.                         ladujBMP("obrazek8.bmp", 0, 0);
  894.  
  895.                     if (event.key.keysym.sym == SDLK_l)
  896.                         Linia(rand()%width, rand()%height, rand()%width, rand()%height, 100+rand()%155, 100+rand()%155, 100+rand()%155);
  897.                     if (event.key.keysym.sym == SDLK_o)
  898.                         Okrag(rand()%width, rand()%height, rand()%200, 100+rand()%155, 100+rand()%155, 100+rand()%155);
  899.                     if (event.key.keysym.sym == SDLK_e)
  900.                         Elipsa(rand()%width, rand()%height, rand()%200, rand()%200, 100+rand()%155, 100+rand()%155, 100+rand()%155);
  901.                     if (event.key.keysym.sym == SDLK_b)
  902.                         czyscEkran(0, 0, 10);          break;
  903.                      }
  904.             } // end switch
  905.         } // end of message processing
  906.  
  907.     } // end main loop
  908.  
  909.  
  910.     // all is well ;)
  911.     printf("Exited cleanly\n");
  912.     return 0;
  913. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!