CzarnyBarszcz

Zad3_grafika

Mar 8th, 2021 (edited)
707
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * GLUT Shapes Demo
  3.  *
  4.  * Written by Nigel Stewart November 2003
  5.  *
  6.  * This program is test harness for the sphere, cone
  7.  * and torus shapes in GLUT.
  8.  *
  9.  * Spinning wireframe and smooth shaded shapes are
  10.  * displayed until the ESC or q key is pressed.  The
  11.  * number of geometry stacks and slices can be adjusted
  12.  * using the + and - keys.
  13.  */
  14. #include <windows.h>
  15. #ifdef __APPLE__
  16. #include <GLUT/glut.h>
  17. #else
  18. #include <GL/glut.h>
  19. #endif
  20.  
  21. #include <stdlib.h>
  22. #include <fstream>
  23. #include <iostream>
  24. #include <math.h>
  25. using namespace std;
  26.  
  27. static int slices = 16;
  28. static int stacks = 16;
  29. double gamma=1.0;
  30. const int nx = 1339;
  31. const int ny = 2000;
  32. double rOrg[nx][ny];
  33. double rO0[nx][ny];
  34. double rNew[nx][ny];
  35. double gOrg[nx][ny];
  36. double gO0[nx][ny];
  37. double gNew[nx][ny];
  38. double bOrg[nx][ny];
  39. double bO0[nx][ny];
  40. double bNew[nx][ny];
  41. double mUsK[3][3]={{-1,-1,-1},
  42.                   {-1,9,-1},
  43.                   {-1,-1,-1}};
  44. double mUs[3][3]={{0,-1,0},
  45.                   {0,1,0},
  46.                   {0,0,0}};
  47. double mUs2[3][3]={{0,0,0},
  48.                   {-1,1,0},
  49.                   {0,0,0}};
  50. double mUw[3][3]={{-1,1,1},
  51.                   {-1,-2,1},
  52.                   {-1,1,1}};
  53. double pS=1;
  54.  
  55. int czytanie(const string& nazwaPliku)
  56. {
  57.     int szer,wys;
  58.     ifstream plik(nazwaPliku.c_str());
  59.     plik>>szer>>wys;
  60.     for(int i=0;i<nx;i++)
  61.         for(int j=0;j<ny;j++)
  62.     {
  63.         plik>>rOrg[i][j];
  64.         plik>>gOrg[i][j];
  65.         plik>>bOrg[i][j];
  66.         rOrg[i][j]/=255.0;
  67.         gOrg[i][j]/=255.0;
  68.         bOrg[i][j]/=255.0;
  69.      //   cout<<rOrg[i][j]<<"\t"<<gOrg[i][j]<<"\t"<<bOrg[i][j]<<endl;
  70.     }
  71.     for(int i=0;i<nx;i++)
  72.         for(int j=0;j<ny;j++)
  73.     {
  74.         rNew[i][j]=rOrg[i][j];
  75.         gNew[i][j]=gOrg[i][j];
  76.         bNew[i][j]=bOrg[i][j];
  77.         rO0[i][j]=rOrg[i][j];
  78.         gO0[i][j]=gOrg[i][j];
  79.         bO0[i][j]=bOrg[i][j];
  80.      //   cout<<rOrg[i][j]<<"\t"<<gOrg[i][j]<<"\t"<<bOrg[i][j]<<endl;
  81.     }
  82.     cout<<"szer="<<szer<<"\twys="<<wys<<endl;
  83.     plik.close();
  84.  
  85.     return 0;
  86. }
  87. /* GLUT callback Handlers */
  88.  
  89. static void resize(int width, int height)
  90. {
  91.     const float ar = (float) width / (float) height;
  92.  
  93.     glViewport(0, 0, width, height);
  94.     glMatrixMode(GL_PROJECTION);
  95.     glLoadIdentity();
  96.     glOrtho(0,ny,0,nx,-5,5);
  97.     if((double)width/ny>(double)height/nx)
  98.         pS=(double)width/ny;
  99.     else
  100.         pS=(double)height/nx;
  101.  
  102.     glMatrixMode(GL_MODELVIEW);
  103.     glLoadIdentity() ;
  104. }
  105.  
  106. static void display(void)
  107. {
  108.     const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
  109.     const double a = t*90.0;
  110.  
  111.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  112.     glPointSize(pS);
  113.     glBegin(GL_POINTS);
  114.     for(int i=0;i<nx;i++)
  115.         for(int j=0;j<ny;j++)
  116.         {
  117.         glColor3d(rNew[i][j],gNew[i][j],bNew[i][j]);
  118.         glVertex3d(j,i,0);
  119.         }
  120.     glEnd();
  121.     glutSwapBuffers();
  122. }
  123.  
  124. void wypisz()
  125. {
  126.     for(int i=0;i<nx;i++)
  127.         for(int j=0;j<ny;j++)
  128.         {
  129.             cout<<rOrg[i][j]<<" : ";
  130.             cout<<gOrg[i][j]<<" : ";
  131.             cout<<bOrg[i][j]<<" : ";
  132.         }
  133. }
  134.  
  135. void maxymalny()
  136. {
  137.     double rmax =0.0,gmax=0.0,bmax=0.0;
  138.     for(int i=1;i<nx-1;i++)
  139.         for(int j=1;j<ny-1;j++)
  140.     {
  141.         rmax =0.0;
  142.         gmax =0.0;
  143.         bmax =0.0;
  144.         for(int k=0;k<3;k++)
  145.             for(int l=0;l<3;l++)
  146.             {
  147.                 if(rmax<rOrg[i+k-1][j+l-1])
  148.                     rmax=rOrg[i+k-1][j+l-1];
  149.                 if(gmax<gOrg[i+k-1][j+l-1])
  150.                     gmax=gOrg[i+k-1][j+l-1];
  151.                 if(bmax<bOrg[i+k-1][j+l-1])
  152.                     bmax=bOrg[i+k-1][j+l-1];
  153.             }
  154.             rNew[i][j]=rmax;
  155.             gNew[i][j]=gmax;
  156.             bNew[i][j]=bmax;
  157.     }
  158.  
  159. }
  160. void minimalny()
  161. {
  162.     double rmin =0.0,gmin=0.0,bmin=0.0;
  163.     for(int i=1;i<nx-1;i++)
  164.         for(int j=1;j<ny-1;j++)
  165.     {
  166.         rmin =1.0;
  167.         gmin =1.0;
  168.         bmin =1.0;
  169.         for(int k=0;k<3;k++)
  170.             for(int l=0;l<3;l++)
  171.             {
  172.                 if(rmin>rOrg[i+k-1][j+l-1])
  173.                     rmin=rOrg[i+k-1][j+l-1];
  174.                 if(gmin>gOrg[i+k-1][j+l-1])
  175.                     gmin=gOrg[i+k-1][j+l-1];
  176.                 if(bmin>bOrg[i+k-1][j+l-1])
  177.                     bmin=bOrg[i+k-1][j+l-1];
  178.             }
  179.             rNew[i][j]=rmin;
  180.             gNew[i][j]=gmin;
  181.             bNew[i][j]=bmin;
  182.     }
  183.  
  184. }
  185. void funkcja_gamma()
  186. {
  187.     for(int i=0;i<nx;i++)
  188.                     for(int j=0;j<ny;j++)
  189.                 {
  190.                     rNew[i][j]=pow(rOrg[i][j],gamma);
  191.                     gNew[i][j]=pow(gOrg[i][j],gamma);
  192.                     bNew[i][j]=pow(bOrg[i][j],gamma);
  193.                 }
  194. }
  195.  
  196. void bubblesort ()
  197. {
  198.  
  199. }
  200. static void key(unsigned char key, int x, int y)
  201. {
  202.  
  203.     switch (key)
  204.     {
  205.         case 'q':
  206.             exit(0);
  207.             break;
  208.             //reset filtrów
  209.         case '0':
  210.             {
  211.  
  212.             for(int i=0; i<nx; i++)
  213.                 for(int j=0; j<ny; j++)
  214.                 {
  215.                     rNew[i][j]=rO0[i][j];
  216.                     gNew[i][j]=gO0[i][j];
  217.                     bNew[i][j]=bO0[i][j];
  218.                     rOrg[i][j]=rO0[i][j];
  219.                     gOrg[i][j]=rO0[i][j];
  220.                     bOrg[i][j]=rO0[i][j];
  221.                 }
  222.               gamma=1.0;
  223.             }
  224.             break;
  225.             //Kolor czerwony
  226.         case 'r':
  227.             for(int i=0;i<nx;i++)
  228.                 for(int j=0;j<ny;j++)
  229.             {
  230.                 rNew[i][j]+=0.1;
  231.             }
  232.             break;
  233.             //Kolor zielony
  234.         case 'g':
  235.             for(int i=0;i<nx;i++)
  236.                 for(int j=0;j<ny;j++)
  237.             {
  238.                 gNew[i][j]+=0.1;
  239.             }
  240.             //Kolor niebieski
  241.         case 'b':
  242.             for(int i=0;i<nx;i++)
  243.                 for(int j=0;j<ny;j++)
  244.             {
  245.                 bNew[i][j]+=0.1;
  246.             }
  247.             break;
  248.             //rozjaœnienie
  249.         case '1':
  250.             for(int i=0;i<nx;i++)
  251.                 for(int j=0;j<ny;j++)
  252.             {
  253.                 rNew[i][j]+=0.1;
  254.                 gNew[i][j]+=0.1;
  255.                 bNew[i][j]+=0.1;
  256.             }
  257.             break;
  258.             //korekcja + gamma
  259.         case '3':
  260.             {
  261.                 funkcja_gamma();
  262.                 gamma+=0.1;
  263.                 cout<<"gamma = "<<gamma<<endl;
  264.             }
  265.             break;
  266.             //korekcja - gamma
  267.         case '4':
  268.             {
  269.                 funkcja_gamma();
  270.  
  271.                 gamma-=0.1;
  272.                 cout<<"gamma = "<<gamma<<endl;
  273.             }
  274.             break;
  275.             //przyciemnienie
  276.         case '2':
  277.             for(int i=0;i<nx;i++)
  278.                 for(int j=0;j<ny;j++)
  279.             {
  280.                 rNew[i][j]-=0.1;
  281.                 gNew[i][j]-=0.1;
  282.                 bNew[i][j]-=0.1;
  283.             }
  284.             break;
  285.         //filtr krawedziowy (przesuwajacy pionowy)
  286.     case '5':
  287.         {
  288.             double sumaWg,rSum=0.0,gSum=0.0,bSum=0.0;
  289.             for(int i=0; i<3; i++)
  290.             {
  291.                 for(int j=0; j<3; j++)
  292.                 {
  293.                     sumaWg +=mUs[i][j];
  294.                 }
  295.             }
  296.             cout<<sumaWg;
  297.             if (sumaWg==0)sumaWg=1;
  298.             for(int i=1; i<nx-1; i++)
  299.                 for(int j=1; j<ny-1; j++)
  300.                 {
  301.                     for(int k=0; k<3; k++)
  302.                         for(int l=0; l<3; l++)
  303.                         {
  304.                             rSum+=(mUs[k][l]*rOrg[i+k-1][j+l-1]);
  305.                             gSum+=(mUs[k][l]*gOrg[i+k-1][j+l-1]);
  306.                             bSum+=(mUs[k][l]*bOrg[i+k-1][j+l-1]);
  307.                         }
  308.  
  309.                     rNew[i][j]=(rSum/sumaWg);
  310.                     gNew[i][j]=(gSum/sumaWg);
  311.                     bNew[i][j]=(bSum/sumaWg);
  312.  
  313.                     rSum=0.0;
  314.                     gSum=0.0;
  315.                     bSum=0.0;
  316.                 }
  317.     for(int i=0;i<nx;i++)
  318.         for(int j=0;j<ny;j++)
  319.     {
  320.         rOrg[i][j]=rNew[i][j];
  321.         gOrg[i][j]=gNew[i][j];
  322.         bOrg[i][j]=bNew[i][j];
  323.     }
  324.             }
  325.             break;
  326.             //filtr krawedziowy (przesuwajacy poziomy)
  327. case '6':
  328.             {
  329.         double sumaWg,rSum=0.0,gSum=0.0,bSum=0.0;
  330.         for(int i=0;i<3;i++)
  331.         {
  332.             for(int j=0;j<3;j++)
  333.             {
  334.                 sumaWg +=mUs2[i][j];
  335.             }
  336.         }
  337.         cout<<sumaWg;
  338.         if (sumaWg==0)sumaWg=1;
  339.  
  340.             for(int i=1;i<nx-1;i++)
  341.                 for(int j=1;j<ny-1;j++)
  342.                 {
  343.                     for(int k=0; k<3; k++)
  344.                         for(int l=0; l<3; l++)
  345.                         {
  346.                             rSum+=(mUs2[k][l]*rOrg[i+k-1][j+l-1]);
  347.                             gSum+=(mUs2[k][l]*gOrg[i+k-1][j+l-1]);
  348.                             bSum+=(mUs2[k][l]*bOrg[i+k-1][j+l-1]);
  349.                         }
  350.  
  351.                     rNew[i][j]=(rSum/sumaWg);
  352.                     gNew[i][j]=(gSum/sumaWg);
  353.                     bNew[i][j]=(bSum/sumaWg);
  354.  
  355.                     rSum=0.0;
  356.                     gSum=0.0;
  357.                     bSum=0.0;
  358.                 }
  359.     for(int i=0;i<nx;i++)
  360.         for(int j=0;j<ny;j++)
  361.     {
  362.         rOrg[i][j]=rNew[i][j];
  363.         gOrg[i][j]=gNew[i][j];
  364.         bOrg[i][j]=bNew[i][j];
  365.  
  366.     }
  367.             }
  368.             break;
  369.  
  370.             //filtr wschód
  371.             case 'w':
  372.             {
  373.         double sumaWg,rSum=0.0,gSum=0.0,bSum=0.0;
  374.         for(int i=0;i<3;i++)
  375.         {
  376.             for(int j=0;j<3;j++)
  377.             {
  378.                 sumaWg +=mUw[i][j];
  379.             }
  380.         }
  381.         //cout<<sumaWg;
  382.         if (sumaWg==0)sumaWg=1;
  383.  
  384.             for(int i=1;i<nx-1;i++)
  385.                 for(int j=1;j<ny-1;j++)
  386.                 {
  387.  
  388.                     for(int k=0; k<3; k++)
  389.                         for(int l=0; l<3; l++)
  390.                         {
  391.                             rSum+=(mUw[k][l]*rOrg[i+k-1][j+l-1]);
  392.                             gSum+=(mUw[k][l]*gOrg[i+k-1][j+l-1]);
  393.                             bSum+=(mUw[k][l]*bOrg[i+k-1][j+l-1]);
  394.                         }
  395.  
  396.                     rNew[i][j]=(rSum/sumaWg);
  397.                     gNew[i][j]=(gSum/sumaWg);
  398.                     bNew[i][j]=(bSum/sumaWg);
  399.  
  400.                     rSum=0.0;
  401.                     gSum=0.0;
  402.                     bSum=0.0;
  403.                 }
  404.     for(int i=0;i<nx;i++)
  405.         for(int j=0;j<ny;j++)
  406.     {
  407.         rOrg[i][j]=rNew[i][j];
  408.         gOrg[i][j]=gNew[i][j];
  409.         bOrg[i][j]=bNew[i][j];
  410.  
  411.     }
  412.             }
  413.             break;
  414.                 case 'm':
  415.                 {
  416.                     maxymalny();
  417.                 }
  418.                 break;
  419.                 case 'n':
  420.                 {
  421.                     minimalny();
  422.                 }
  423.                 break;
  424.     }
  425.  
  426.  
  427.     glutPostRedisplay();
  428. }
  429.  
  430. static void idle(void)
  431. {
  432.     glutPostRedisplay();
  433. }
  434.  
  435. const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
  436. const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
  437. const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  438. const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };
  439.  
  440. const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
  441. const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
  442. const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
  443. const GLfloat high_shininess[] = { 100.0f };
  444.  
  445. /* Program entry point */
  446.  
  447. int main(int argc, char *argv[])
  448. {
  449.     cout<<"'q' ->EXIT"<<endl;
  450.     cout<<"'0' ->RESET FILTROW"<<endl;
  451.     cout<<"'r' ->PODNOSZENIE POZIOMU CZERWIENI"<<endl;
  452.     cout<<"'g' ->PODNOSZENIE POZIOMU ZILENI"<<endl;
  453.     cout<<"'b' ->PODNOSZENIE POZIOMU NIEBIESKIEGO"<<endl;
  454.     cout<<"'1' ->ROZJASNIANIE"<<endl;
  455.     cout<<"'2' ->PRZYCIEMNIANIE"<<endl;
  456.     cout<<"'3' ->KORELACJA GAMMA +"<<endl;
  457.     cout<<"'4' ->KORELACJA GAMMA -"<<endl;
  458.     cout<<"'5' ->FILTR PRZESUWAJACY PIONOWY"<<endl;
  459.     cout<<"'6' ->FILTR PRZESUWAJACY POZIOMY"<<endl;
  460.     cout<<"'w' ->FILTR WSCHOD"<<endl;
  461.     cout<<"'m' ->FILTR MAXIMUM"<<endl;
  462.     cout<<"'n' ->FILTR MINIMUM"<<endl;
  463.     czytanie("c:\\tmp\\zd5.txt");
  464.     glutInit(&argc, argv);
  465.     glutInitWindowSize(ny,nx);
  466.     glutInitWindowPosition(10,10);
  467.     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  468.  
  469.     glutCreateWindow("GLUT Shapes");
  470.  
  471.     glutReshapeFunc(resize);
  472.     glutDisplayFunc(display);
  473.     glutKeyboardFunc(key);
  474.     glutIdleFunc(idle);
  475.  
  476.     glClearColor(1,1,1,1);
  477.     glEnable(GL_CULL_FACE);
  478.     glCullFace(GL_BACK);
  479.  
  480.     glEnable(GL_DEPTH_TEST);
  481.     glDepthFunc(GL_LESS);
  482.  
  483.     glEnable(GL_LIGHT0);
  484.     glEnable(GL_NORMALIZE);
  485.     glEnable(GL_COLOR_MATERIAL);
  486.     glEnable(GL_LIGHTING);
  487.  
  488.     glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
  489.     glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
  490.     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  491.     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  492.  
  493.     glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
  494.     glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
  495.     glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
  496.     glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
  497.  
  498.     glutMainLoop();
  499.  
  500.     return EXIT_SUCCESS;
  501. }
  502.  
RAW Paste Data