API tools faq
paste
CzarnyBarszcz

Zad3_grafika

CzarnyBarszcz
Mar 8th, 2021 (edited)
1,106
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.17 KB | None | 0 0
raw download clone embed print report
  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.  
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!