SHARE
TWEET

CWICZENIE_NR_4_KOMPRESJA_I_DEKOMPRESJA_JPEG

pabloducato Jun 8th, 2019 67 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "stdafx.h" //CWICZENIE NR 4 KOMPRESJA I DEKOMPRESJA OBRAZOW JPEG
  2. #include <opencv2/imgproc/imgproc.hpp>  // Gaussian Blur
  3. #include <opencv2/core/core.hpp>        // Basic OpenCV structures (CV::Mat, Scalar)
  4. #include <opencv2/highgui/highgui.hpp>
  5. #include <stdio.h>
  6. #include <math.h>
  7. #include <iostream>
  8. #define PI (3.141592653589793)
  9. using namespace std;
  10. using namespace CV;
  11.  
  12. int _tmain(int argc, _TCHAR* argv[])
  13. {
  14.     // Stworzenie okna w którym przechwycone obrazy będą wyświetlane
  15.     cvNamedWindow("JPEG", CV_WINDOW_AUTOSIZE);
  16.     // Pobranie obrazu
  17.     Mat imageFruits = imread("fruits2.jpg",CV_LOAD_IMAGE_GRAYSCALE);
  18.     // Uzyskanie macierzy pikseli na podstawie obiektów Mat
  19.     Mat_<uchar> fruitsPixels = imageFruits;
  20.     const int blockCols = 320/8;
  21.     const int blockRows = 240/8;
  22.     // Utworzenie bloków przechowujących odpowiednio: oryginalny obraz, obraz po DCT, obraz po IDCT
  23.     float block[blockRows][blockCols][8][8];
  24.     float blockDCT[blockRows][blockCols][8][8];
  25.     float blockIDCT[blockRows][blockCols][8][8];
  26.     // TODO
  27.         // podział obrazu na bloki
  28.     for(int i = 0; i<blockRows; i++)
  29.     {
  30.         for(int j = 0; j<blockCols; j++)
  31.         {
  32.             for(int k = 0; k<8; k++)
  33.             {
  34.                 for(int l = 0; l<8; l++)
  35.                 {
  36.                     block[i][j][k][l] = fruitsPixels[i*8 + k][j*8 + l];
  37.                     blockDCT[i][j][k][l] = 0;
  38.                     blockIDCT[i][j][k][l] = 0;
  39.                 }
  40.             }
  41.         }
  42.     }
  43. /*for(int i = 0; i<8; i++)
  44. {
  45.     for (int j = 0; j<8; j++)
  46.     {
  47.         block[1][1][i][j] = 0;
  48.     }
  49. }*/
  50. // zerowanie blockDCT i blockIDCT  
  51. // TODO
  52. // DCT
  53. for(int i = 0; i<blockRows; i++)
  54. {
  55.     for(int j = 0; j<blockCols; j++)
  56.     {
  57.         for(int k = 0; k<8; k++)
  58.         {
  59.             for(int l = 0; l<8; l++)
  60.             {
  61.                 for(int m = 0; m<8; m++)
  62.                 {
  63.                     for(int n = 0; n<8; n++)
  64.                     {
  65.                         blockDCT[i][j][k][l] += block[i][j][m][n] * cos(((2*m + 1)*k*PI)/(2*8)) * cos(((2*n + 1)*l*PI)/(2*8));
  66.                     }
  67.                 }
  68.                 blockDCT[i][j][k][l] /= 64.0;
  69.             }
  70.         }
  71.     }
  72. }
  73. // KWANTYZACJA
  74. float qMatrix[8][8]={
  75.                         {16,11,10,16,24,40,51,61},
  76.                         {12,12,14,19,26,58,60,55},
  77.                         {14,13,16,24,40,57,69,56},
  78.                         {14,17,22,29,51,87,80,62},
  79.                         {18,22,37,56,68,109,103,77},
  80.                         {24,35,55,64,81,104,114,92},
  81.                         {49,64,78,87,103,121,120,101},
  82.                         {72,92,95,98,112,100,103,99}
  83.                     };
  84. float qualityLevel = 50;
  85. for(int i = 0; i < 8; i++)
  86. {
  87.     for (int j = 0; j < 8; j++)
  88.     {
  89.         qMatrix[i][j] = qMatrix[i][j] * ((100 - qualityLevel)/99)*0.18+0.02;
  90.     }
  91. }
  92. for(int i = 0; i < blockRows; i++)
  93. {
  94.     for (int j = 0; j < blockCols; j++)
  95.     {
  96.         for(int k = 0; k < 8; k++)
  97.         {
  98.             for (int l = 0; l < 8; l++)
  99.             {
  100.                 blockDCT[i][j][k][l] = (int)(blockDCT[i][j][k][l] / qMatrix[k][l]);
  101.             }
  102.         }
  103.     }
  104. }
  105. // DEKWANTYZACJA
  106. for(int i = 0; i < blockRows; i++)
  107. {
  108.     for (int j = 0; j < blockCols; j++)
  109.     {
  110.         for(int k = 0; k < 8; k++)
  111.         {
  112.             for (int l = 0; l < 8; l++)
  113.             {
  114.                 blockDCT[i][j][k][l] = blockDCT[i][j][k][l] * qMatrix[k][l];
  115.             }
  116.         }
  117.     }
  118. }
  119. // IDCT
  120. for(int m = 0; m<blockRows; m++)
  121.     {
  122.         for(int n = 0; n<blockCols; n++)
  123.         {
  124.             for(int k = 0; k<8; k++)
  125.             {
  126.                 for(int l = 0; l<8; l++)
  127.                 {
  128.                     for(int i = 0; i<8; i++)
  129.                     {
  130.                         for(int j = 0; j<8; j++)
  131.                         {
  132.                             int CU, CV;
  133.                             if(i == 0) CU = 1;
  134.                             else CU = 2;
  135.                             if(j == 0) CV = 1;
  136.                             else CV = 2;
  137.                             //blockIDCT[i][j][k][l] += CU * CV * blockDCT[i][j][m][n] * cos(((2*k + 1)*m*PI)/(2*8)) * cos(((2*l + 1)*n*PI)/(2*8));
  138.                             blockIDCT[m][n][k][l] += CU * CV * blockDCT[m][n][i][j] * cos(((2*k + 1)*i*PI)/(2*8)) * cos(((2*l + 1)*j*PI)/(2*8));
  139.                         }
  140.                     }
  141.                 }
  142.             }
  143.         }
  144.     }
  145.     // TODO
  146.     // "składanie" obrazu z bloków
  147.     for(int i = 0; i<blockRows; i++)
  148.     {
  149.         for(int j = 0; j<blockCols; j++)
  150.         {
  151.             for(int k = 0; k<8; k++)
  152.             {
  153.                 for(int l = 0; l<8; l++)
  154.                 {
  155.                     blockIDCT[i][j][k][l] > 255 ? blockIDCT[i][j][k][l] = 255 : blockIDCT[i][j][k][l] < 0 ? blockIDCT[i][j][k][l] = 0 : blockIDCT[i][j][k][l] = blockIDCT[i][j][k][l];
  156.                     fruitsPixels[i*8+k][j*8+l] = blockIDCT[i][j][k][l];
  157.                 }
  158.             }
  159.         }
  160.     }
  161.     // Wyświetlenie obrazu
  162.     imshow("JPEG", imageFruits);
  163.     // Oczekiwanie na wciśnięcie klawisza Esc lub Enter
  164.     char key;
  165.     do  key = cvWaitKey(1);
  166.     while(key != 27 && key != 13);
  167.     // Niszczenie okna
  168.     cvDestroyWindow("JPEG");
  169.     return 0;
  170. }
RAW Paste Data
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
 
Top