Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Fr Jul 18, 2025 08:51

Foren-Übersicht » Programmierung » OpenGL
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 126 Beiträge ]  Gehe zu Seite Vorherige  1 ... 4, 5, 6, 7, 8, 9  Nächste
Autor Nachricht
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 09:45 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Die stärke von Software ist es gerade sequenzen zu bearbeiten.
Es ist eigentlich egal ob die ein Polynom 2. oder 120. Grades berechnen sollst. Du musst du zuerst vom Nutzer abfragen, welchen Grad er berechnen will, danach die Formel und dann deinen Code mit diesen Daten füttern. Die Schleifen laufen dann einfach länger, die Felder müssen größer sein etc.
Aber das Prinzip ist das gleiche.

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 09:52 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mär 30, 2007 18:35
Beiträge: 331
Genau so ist es. Dafür gibt es mehrere Möglichkeiten:

Hast du ein Consolenprogramm kannst du zB <iostream> die Zahl eingeben lassen:

Code:
  1.    
  2. std::cout << "Grad des Polynoms eingeben:" << std::endl;
  3. std::cin >> n;
  4.  


du kannst das Programm aber auch mittels eines Parameters starten welcher den Grad angibt. Dieser würde dann in argv stehen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 10:01 
Offline
DGL Member

Registriert: Mi Jul 15, 2009 18:29
Beiträge: 52
ja, das mit diesem cin und cout kann ich nur weiss net wie ich das dann einfügn soll


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 10:07 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Jan 04, 2008 21:29
Beiträge: 419
Wohnort: Lübeck
cin und cout funktioniert genauso wie "hello world", nur dass man noch ein wenig Programmcode drumherum schreibt. In deinem Fall machste dann ein cout und cin direkt am Anfang deiner Funktion und speicherst die eingegebene Zahl als 'n'. 'n' benutzt du dann als Maximalzahl für deine Schleife und als Anzahl der Arrayeinträge die im Speicher angelegt werden sollen. Vielleicht funktioniert es ja dann.

Achja.. in der Schleife musst du bis MaximalZahl-1 zählen, also n-1, weil, dein array mit n einträgen geht nicht von 1 bis n sondern von 0 bis n-1 und wenn die schleife aber bis n zählt, dann versuchst du einen wert zu lesen (den mit der nummer 'n'), der garnicht exisitiert und dann fliegt dir dein Programm um die Ohren... obwohl ich glaub C/C++ nimmt das einfach so hin und gibt dir Datenschrott ausm hintersten Nirvana zurück.

_________________
Klar Soweit?


Zuletzt geändert von Sellmann am Di Jul 21, 2009 10:19, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 10:08 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mär 30, 2007 18:35
Beiträge: 331
Code:
  1.  
  2. #ifdef __APPLE__
  3. #include <GLUT/glut.h>
  4. #else
  5. #include <GL/glut.h>
  6. #endif
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <math.h>
  10.  
  11. #include <iostream>
  12.  
  13. ...
  14.  
  15. int main(int argc, char **argv)
  16. {
  17. std::cout << "Grad des Polynoms eingeben:" << std::endl;
  18. std::cin >> n;
  19. printf("TEST");/* Intialize the program */fflush(stdout);
  20. glutInit(&argc, argv);
  21. glutInitDisplayMode(GLUT_RGB);
  22. glutInitWindowSize(width, height);
  23. glutInitWindowPosition(600,50);
  24. glutCreateWindow("APPROXIMATION CURVES");
  25. glEnable(GL_MAP1_VERTEX_3);
  26. glClearColor(1.0, 1.0, 1.0, 1.0);
  27. /* Register the callbacks */
  28. glutDisplayFunc(display);
  29. glutMouseFunc(mouse);
  30. glutKeyboardFunc(keyboard);
  31. glutReshapeFunc(reshape);
  32. glutMainLoop();
  33. return 0;
  34. }


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 10:50 
Offline
DGL Member

Registriert: Mi Jul 15, 2009 18:29
Beiträge: 52
ich versuch mal was sich machen lässt =)
erstmal vielen lieben dank. meld mich dann später nochmal beu euch
grüße
jule


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 21, 2009 23:33 
Offline
DGL Member

Registriert: Mi Jul 15, 2009 18:29
Beiträge: 52
ich bekomm das nicht hin =(
hab versucht aber geht nicht, und am freitag ist abgabe =(((((((
mein prof schreibt:
Das Auswählen des Polynomgrades soll der andere aus dem Projekt übernehmen. Sie bekommen den Grad vorgegeben.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 06:49 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Jan 04, 2008 21:29
Beiträge: 419
Wohnort: Lübeck
wer ist der andere?
UND
wenn der Grad vorgegeben ist, in welcher Variable ist er dann zu finden?

_________________
Klar Soweit?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 07:21 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Okt 04, 2006 15:42
Beiträge: 78
Wohnort: Bonn
Programmiersprache: Python, C++, Delphi
Zitat:
ich bekomm das nicht hin =(
hab versucht aber geht nicht, und am freitag ist abgabe =(((((((


Eben beim Zähneputzen hab ich leider die Kristallkugel vom Badezimmerschrank geschubst. Ich
hoffe es stört dich deshalb nicht, wenn ich frage:

- Was hast du denn versucht? Zeig im Idealfall mal dein verändertes Listing.

- Was geht nicht? Beskommst du ein Fehler beim Kompilieren oder hat der geänderte Code nicht
den von dir geschwünschten Effekt?

- Warum rückt der Abgabetermin eigentlich immer weiter in die Ferne (war das nicht mal ein Mittwoch)?

- Und warum nimmst du dir die Kritik an deiner Postweise nicht zu Herzen und lässt zur Abwechslung mal
brauchbare Infos durchblicken. Das ist nicht böse gemeint, aber es wäre dann vielleicht einfacher (nein -
es wäre dann erst überhaupt möglich) dir bei deinem Problem zu helfen.

Und vor allem beantworte die Frage von Sellman - was auch die Frage aufwirft: Warum kommst du
damit erst jetzt raus?

Wenn der Grad des Polynoms von jemand anderem frei festgelegt werden soll, wäre es sicher nicht
verkehrt, wenn du dir mal dynamische Arrays in C++ anschaust (die releavanten Schlüsselwörter für
Google sind: new und dispose) - alternativ kannst du aber auch die Vector-Klasse aus der STL verwenden
(frag nicht wie, steht im Netz).


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 09:23 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mär 30, 2007 18:35
Beiträge: 331
Soll das am Ende so aussehen? (Das ist Grad = 5)

PS: Den Code so zu verändern dass er höhere Grade auch berechnet hat nicht so lange gedauert wie die Header und Libs runterzuladen.


Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 12:44 
Offline
DGL Member
Benutzeravatar

Registriert: Di Sep 20, 2005 13:18
Beiträge: 1054
Wohnort: Dresden
Programmiersprache: C, C++, Pascal, OPL
@Markus: Lass dir Geld geben. :roll:

_________________
Denn wer nur schweigt, weil er Konflikte scheut, der macht Sachen, die er hinterher bereut.
Und das ist verkehrt, denn es ist nicht so schwer, jeden Tag zu tun als ob's der letzte wär’.
Und du schaust mich an und fragst ob ich das kann.
Und ich denk, ich werd' mich ändern irgendwann.

_________________Farin Urlaub - Bewegungslos


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 13:16 
Offline
DGL Member

Registriert: Mi Jul 15, 2009 18:29
Beiträge: 52
der andere ist der, dem ich das abgeben muss und der das dann in einem menü einbindet mein programm.
der abgabe termin ist freitag, aber er wird leider nicht verlängert.
am freitag um 13uhr !!!
der grad muss von dem andeeren festgelegt werden und darf nur maximal 25 sein.
und das was der andere dann wählt muss dann mein programm übernehmen.
hab versucht diesen code von meinem prof einzubinden aber lautet fehler.

Code:
  1.  
  2.  
  3. void drawParabel()
  4. {
  5.       /* Draw the curve using OpenGL evaluators */
  6.   int i,k,m,n=2,l,r,p;
  7.   float a[n][n], s, rs[n],z[n],koeff[n],h,x,y;
  8.   int double Ac[i], double Ax[i], int n, double x;
  9.   glColor3f(0.0,0.0,1.0);
  10.  
  11. {
  12.  
  13.     int i;
  14.     double y = 0;
  15.     for(i=n; i>=0; i--) {
  16.         y = (y * x)  + Ac[i];
  17.     }
  18.     return y;
  19. }
  20.    
  21.     // links
  22.     for (k = 0; k <= n; k++)
  23.       {
  24.       for (m = 0; m <= n; m++)
  25.           {
  26.               s=0;
  27.               for (l = 0; l <ncpts; l++)
  28.               {
  29.                    s = s + pow(cpts [l] [0], k + m );
  30.               }
  31.               a[k][m] = s;
  32.           }
  33.       }
  34.      
  35.       // rechts
  36.  
  37.       for (m = 0; m <= n; m++)
  38.           {
  39.               s=0;
  40.               for (l = 0; l <ncpts; l++)
  41.               {
  42.                    s = s + pow(cpts [l] [0], m ) * cpts [l] [1];
  43.               }
  44.               rs[m]=s;
  45.           }
  46.    
  47.     // matrix
  48.    
  49.  for (p = 0; p <= n-1; p++)
  50.  {
  51.          for (k=p+1; k <= n; k++)
  52.          {
  53.              a[k][p]=a[k][p]/a[p][p]; /*(* = lkm *);*/
  54.              for (m=p+1; m<=n; m++)
  55.                   {
  56.                     a[k][m]=a[k][m]-a[k][p]*a[p][m]; /* = a[m]km *); */
  57.                   }
  58.          }
  59.  }
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  for(k=0;k<=n;k++)
  67.    {
  68.      s=rs[k];
  69.      for(m=0;m<=k-1;m++)
  70.        {
  71.      s=s-a[k][m]*z[m];
  72.        }
  73.      z[k]=s;
  74.    }
  75.  for(k=n;k>=0;k--)
  76.    {
  77.      s=z[k];
  78.      for(m=k+1;m<=n;m++)
  79.        {
  80.      s=s-a[k][m]*koeff[m];
  81.        }
  82.      koeff[k]=s/a[k][k];
  83.    }
  84.          
  85.    
  86.     glBegin(GL_LINE_STRIP);    
  87.     x=cpts[0][0]-1;
  88.     y=koeff[n];
  89.         for (m=n-1; m>=0; m--)
  90.         {
  91.             y=y*x+koeff[m];
  92.         }
  93.  
  94.     glVertex2f(x,y);
  95.     h=(cpts[ncpts-1][0]+1-cpts[0][0])/100;
  96.    
  97.     for (k=1; k<=100; k++)
  98.     {
  99.         x=cpts[0][0]-1+k*h;
  100.         y=koeff[n];
  101.         for (m=n-1; m>=0; m--)
  102.         {
  103.             y=y*x+koeff[m];
  104.         }
  105.     glVertex2f(x,y);
  106.     }      
  107.    
  108.     glEnd();
  109.     glFlush();
  110. }
  111.  
  112.  
  113.  


was verlangst du denn markus ? :p


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 13:32 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mär 30, 2007 18:35
Beiträge: 331
Dass du dich selbst drum bemühst. Es wurde alles schon mehr als einmal gesagt. Ich weiß zwar immernoch nicht, wer der "andere" sein soll, aber ich habe dir ja den Code gegeben der eine Zahl einlesen kann. Das einzige was du dann noch brauchst ist eine globale Variable welche du zum Beispiel "grad" nennst.

Code:
  1.  
  2.  
  3. #ifdef __APPLE__
  4. #include <GLUT/glut.h>
  5. #else
  6. #include <GL/glut.h>
  7. #endif
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <math.h>
  11.  
  12. #include <iostream>          // einfügen!
  13.  
  14. int grad = 0;                      // einfügen!
  15.  
  16. ...
  17.  
  18. int main(int argc, char **argv)
  19. {
  20. std::cout << "Grad des Polynoms eingeben:" << std::endl;       // einfügen!
  21. std::cin >> grad;                                                                   // einfügen!
  22.  
  23. glutInit(&argc, argv);
  24. glutInitDisplayMode(GLUT_RGB);
  25. glutInitWindowSize(width, height);
  26. glutInitWindowPosition(600,50);
  27. glutCreateWindow("APPROXIMATION CURVES");
  28. glEnable(GL_MAP1_VERTEX_3);
  29. glClearColor(1.0, 1.0, 1.0, 1.0);
  30. /* Register the callbacks */
  31. glutDisplayFunc(display);
  32. glutMouseFunc(mouse);
  33. glutKeyboardFunc(keyboard);
  34. glutReshapeFunc(reshape);
  35. glutMainLoop();
  36. return 0;
  37. }


So, jetzt hast du die Grade in einer Variable stehen. Was dein Prof dir gegeben hat ist natürlich kompletter blödsinn und kann überhaupt nicht funktionieren. Was du tun musst ist in der Funktion drawParabel() "n" mit "grad" zu initialisieren.
Dann brauchst du natürlich noch Arrays die lang genug sind. Hier bieten sich dynamische Arrays an. Die kann man natürlich nicht so:
Code:
  1. float a[n][n], s, rs[n],z[n],koeff[n],h,x,y;

deklarieren.
Dazu musst du dir den Speicher holen:
Code:
  1.  
  2. float *rs = new float[n+1];
  3. ...
  4. delete[] rs; // am Ende von drawParabel()
  5.  


Du kannst die Arrays aber auch einfach so groß machen, dass die Grenzen nicht erreicht werden.

Ich weiß nicht, was daran jetzt so schwer gewesen sein soll - gerade weil ALLES hier schon geschrieben wurde. Wenn man sieht was der Prof dir andauernd für einen Müll zuschiebt kann man sogar davon ausgehen, dass er überhaupt nicht merkt, dass keine einzige Zeile von diesem Programm von dir stammt.

Edit: sei froh, dass ich überhaupt noch was schreibe. So wie du dich hier aufführst gehört dir eigentlich nicht geholfen. Wahrscheinlich liest du dir nichtmal durch was die Leute hier schreiben. Ein paar Posts über meinem wird noch gesagt, dass du sagen sollst welche Fehler der Code verursacht und du schreibst wieder nur von "Fehlern". Das ist doch lächerlich, das einzige was du tust ist Code von anderen sinnlos bei dir einzufügen ohne nur die leiseste Ahnung davon zu haben.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 14:11 
Offline
DGL Member

Registriert: Mi Jul 15, 2009 18:29
Beiträge: 52
so ist dann meine abfragen ?

Code:
  1.  
  2.  
  3. #ifdef __APPLE__
  4. #include <GLUT/glut.h>
  5. #else
  6. #include <GL/glut.h>
  7. #endif
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <math.h>
  11. #include <stdlib.h>
  12. #include <iostream>          // einfügen!
  13.  
  14. float a[n][n], s, rs[n],z[n],koeff[n],h,x,y;
  15.  
  16. int grad = 0;                      // einfügen!
  17.  
  18. ...
  19.  
  20. int main(int argc, char **argv)
  21. {
  22. std::cout << "Grad des Polynoms eingeben:" << std::endl;       // einfügen!
  23. std::cin >> grad;                                                                   // einfügen!
  24.  
  25. float *rs = new float[n+1];
  26.  
  27. delete[] rs; // am Ende von drawParabel()
  28.  
  29. glutInit(&argc, argv);
  30. glutInitDisplayMode(GLUT_RGB);
  31. glutInitWindowSize(width, height);
  32. glutInitWindowPosition(600,50);
  33. glutCreateWindow("APPROXIMATION CURVES");
  34. glEnable(GL_MAP1_VERTEX_3);
  35. glClearColor(1.0, 1.0, 1.0, 1.0);
  36. /* Register the callbacks */
  37. glutDisplayFunc(display);
  38. glutMouseFunc(mouse);
  39. glutKeyboardFunc(keyboard);
  40. glutReshapeFunc(reshape);
  41. glutMainLoop();
  42. return 0;
  43. }
  44.  


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Jul 22, 2009 14:16 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mär 30, 2007 18:35
Beiträge: 331
Das ist ja wohl der Gipfel. Hast du dir durchgelesen was ich geschrieben habe? Naja... was soll die Frage, natürlich hast du es nicht sonst hättest du nicht so was sinnloses gemacht. Das das nicht richtig ist sollte schon alleine durch die Compilerfehler die dir um die Ohren fliegen offensichtlich sein.

Ich bin es Leid, und werde diesem Trauerspiel ein Ende setzen und hoffen dass du nicht noch ein Problem hast - ich werde dir dabei sicher nicht helfen.

Code:
  1.  
  2. #ifdef __APPLE__
  3. #include <GLUT/glut.h>
  4. #else
  5. #include <GL/glut.h>
  6. #endif
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <math.h>
  10.  
  11. #include <iostream>
  12.  
  13. #define MAX_CPTS  50            /* Fixed maximum number of control points */
  14.  
  15. GLfloat cpts[MAX_CPTS][3];
  16. int ncpts = 0;
  17. int key_Approcurve=0;
  18. int key_Parabel=0;
  19. int key_ctrlpoly=0;
  20. int key_input=2;
  21. int key_points=0;
  22. int indx;
  23.  
  24. int num = 0;
  25.  
  26. static int width = 1000, height = 1000;           /* Window width and height */
  27.  
  28. void drawAppro()
  29. {
  30.       /* Draw the curve using OpenGL evaluators */
  31.      int i;
  32.      float b,m,sxy,sx,sy,sx2,xmin,xmax,ymin,ymax;
  33.     glColor3f(1.0,0.0,0.0);
  34.     sx=0;
  35.     sy=0;
  36.     sxy=0;
  37.     sx2=0;
  38.    
  39.     for (i = 0; i < ncpts; i++)
  40.       {
  41.         sx = sx + cpts[i][0];
  42.         sy = sy + cpts[i][1] ;
  43.         sxy = sxy + cpts[i][0] * cpts[i][1] ;
  44.         sx2 = sx2 + cpts[i][0] * cpts[i][0];
  45.       }
  46.     m = (ncpts * sxy - sx*sy) / (ncpts * sx2 - sx *sx) ;
  47.     //b = (ncpts * sx2 * sy - sx * sxy) / (ncpts * sx2 - sx *sx) ;
  48.     b=sy/ncpts-m*sx/ncpts;
  49.    
  50.     xmin = cpts[0][0] ;
  51.     for (i = 1; i < ncpts; i++)
  52.       {
  53.     if(cpts[i][0] < xmin)
  54.       xmin = cpts[i][0];
  55.       }
  56.     xmax = cpts[0][0] ;
  57.     for (i = 1; i < ncpts; i++)
  58.       {
  59.     if(cpts[i][0] > xmax)
  60.       xmax = cpts[i][0];
  61.       }
  62.    
  63.     xmin=xmin-1;
  64.     xmax=xmax+1;
  65.     ymin = m * xmin + b;
  66.     ymax = m * xmax + b;
  67.  
  68.    
  69.     glBegin(GL_LINES);
  70.     glVertex2f (xmin,ymin);
  71.     glVertex2f (xmax,ymax);
  72.     glEnd();
  73.     glFlush();
  74. }
  75.  
  76. void drawParabel()
  77. {
  78.     /* Draw the curve using OpenGL evaluators */
  79.     int i,k,m,n=num,l,r,p;
  80.     float s,h,x,y;
  81.  
  82.  
  83.     float **a = new float *[n+1];
  84.     for (int x = 0; x <= n; ++x)
  85.         a[x] = new float[n+1];
  86.  
  87.  
  88.     float *rs = new float[n+1];
  89.     float *z = new float[n+1];
  90.     float *koeff = new float[n+1];
  91.  
  92.   glColor3f(0.0,0.0,1.0);
  93.    
  94.     // links
  95.     for (k = 0; k <= n; k++)
  96.       {
  97.       for (m = 0; m <= n; m++)
  98.           {
  99.               s=0;
  100.               for (l = 0; l <ncpts; l++)
  101.               {
  102.                    s = s + pow(cpts [l] [0], k + m );
  103.               }
  104.               a[k][m] = s;
  105.           }
  106.       }
  107.      
  108.       // rechts
  109.  
  110.       for (m = 0; m <= n; m++)
  111.           {
  112.               s=0;
  113.               for (l = 0; l <ncpts; l++)
  114.               {
  115.                    s = s + pow(cpts [l] [0], m ) * cpts [l] [1];
  116.               }
  117.               rs[m]=s;
  118.           }
  119.    
  120.     // matrix
  121.      
  122.    
  123.  for (p = 0; p <= n-1; p++)
  124.  {
  125.          for (k=p+1; k <= n; k++)
  126.          {
  127.              a[k][p]=a[k][p]/a[p][p]; /*(* = lkm *);*/
  128.              for (m=p+1; m<=n; m++)
  129.                   {
  130.                     a[k][m]=a[k][m]-a[k][p]*a[p][m]; /* = a[m]km *); */
  131.                   }
  132.          }
  133.  }
  134.  for(k=0;k<=n;k++)
  135.    {
  136.      s=rs[k];
  137.      for(m=0;m<=k-1;m++)
  138.        {
  139.      s=s-a[k][m]*z[m];
  140.        }
  141.      z[k]=s;
  142.    }
  143.  for(k=n;k>=0;k--)
  144.    {
  145.      s=z[k];
  146.      for(m=k+1;m<=n;m++)
  147.        {
  148.      s=s-a[k][m]*koeff[m];
  149.        }
  150.      koeff[k]=s/a[k][k];
  151.    }
  152.          
  153.    
  154.     glBegin(GL_LINE_STRIP);    
  155.     x=cpts[0][0]-1;
  156.     y=koeff[n];
  157.         for (m=n-1; m>=0; m--)
  158.         {
  159.             y=y*x+koeff[m];
  160.         }
  161.  
  162.     glVertex2f(x,y);
  163.     h=(cpts[ncpts-1][0]+1-cpts[0][0])/100;
  164.    
  165.     for (k=1; k<=100; k++)
  166.     {
  167.         x=cpts[0][0]-1+k*h;
  168.         y=koeff[n];
  169.         for (m=n-1; m>=0; m--)
  170.         {
  171.             y=y*x+koeff[m];
  172.         }
  173.     glVertex2f(x,y);
  174.     }      
  175.    
  176.     glEnd();
  177.     glFlush();
  178.  
  179.     for(int x = 0; x <= n; ++x)
  180.         delete[] a[x];
  181.     delete[] a;
  182.     delete[] rs;
  183.     delete[] z;
  184.     delete[] koeff;
  185. }
  186.  
  187. void drawPoly()
  188. {
  189.     int i;
  190.     glColor3f(0.0,0.0,1.0);
  191.     glLineStipple(1,0x00FF);
  192.     glEnable(GL_LINE_STIPPLE);
  193.     glBegin(GL_LINE_STRIP);
  194.     for (i = 0; i < ncpts; i++)
  195.         glVertex3fv(cpts[i]);
  196.     glEnd();
  197.     glDisable(GL_LINE_STIPPLE);
  198. }
  199.  
  200. void drawPoints()
  201. {
  202.     int i;
  203.     glColor3f(0.0,0.0,0.0);
  204.     glPointSize(5.0);
  205.     glBegin(GL_POINTS);
  206.     for (i = 0; i < ncpts; i++)
  207.         glVertex3fv(cpts[i]);
  208.     glEnd();
  209. }
  210.  
  211.  
  212. /* This routine displays all */
  213. void display(void)
  214. {
  215.     glClear(GL_COLOR_BUFFER_BIT);
  216.     if(key_points==1)
  217.       drawPoints();
  218.     if(key_Approcurve==1)
  219.       drawAppro();
  220.     if(key_Parabel==1)
  221.       drawParabel();
  222.     if(key_ctrlpoly==1)
  223.       drawPoly();
  224.     glFlush();
  225. }
  226. void move(int x,int y)
  227. {
  228.   float wx,wy;
  229.   wx = (2.0 * x) / (float)(width - 1) - 1.0;
  230.   wy = (2.0 * (height - 1 - y)) / (float)(height - 1) - 1.0;
  231.   cpts[indx][0]=wx;
  232.   cpts[indx][1]=wy;
  233.   display();
  234. }
  235.  
  236.  
  237. /* This routine inputs new control points */
  238. static void mouse(int button, int state, int x, int y)
  239. {
  240.     float wx, wy;
  241.     int i,found;
  242.  
  243.     /* We are only interested in left clicks */
  244.     if (button != GLUT_LEFT_BUTTON || state != GLUT_DOWN)
  245.         return;
  246.     if ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN) && (key_input==1))
  247.       {
  248.     /* Translate back to our coordinate system */
  249.     wx = (2.0 * x) / (float)(width - 1) - 1.0;
  250.     wy = (2.0 * (height - 1 - y)) / (float)(height - 1) - 1.0;
  251.     /* See if we have room for any more control points */
  252.     if (ncpts == MAX_CPTS)
  253.       return;
  254.     /* Save the point */
  255.     //printf("\n%d",ncpts);fflush(stdout);
  256.     cpts[ncpts][0] = wx;
  257.     cpts[ncpts][1] = wy;
  258.     cpts[ncpts][2] = 0.0;
  259.     ncpts++;
  260.     glutPostRedisplay();
  261.       }
  262.     if ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN) && (key_input==0))
  263.       {
  264.     i=-1;
  265.     found=0;
  266.     while((i<(ncpts-1)) && (found == 0))
  267.     {
  268.         i++;
  269.         //printf("\n index=%d, found= %d,%4d,%4d",i,found,x,y);fflush(stdout);
  270.         wx = (2.0 * x) / (float)(width - 1) - 1.0;
  271.         wy = (2.0 * (height - 1 - y)) / (float)(height - 1) - 1.0;
  272.         if((fabs((double)(wx-cpts[i][0]))<0.1) && (fabs((double)(wy-cpts[i][1]))<0.1))
  273.         {
  274.         found = 1;
  275.         indx = i;      
  276.         }
  277.     }
  278.     if(found == 1)
  279.     {
  280.       glutMotionFunc(move);
  281.     }
  282.       }
  283. }
  284.  
  285.  
  286. /* This routine handles keystroke commands */
  287. void keyboard(unsigned char key, int x, int y)
  288. {
  289.     switch (key)
  290.     {
  291.         case 'q': case 'Q':
  292.             exit(0);
  293.             break;
  294.         case 'c': case 'C':
  295.         ncpts = 0;
  296.         key_Approcurve=0;
  297.         key_Parabel=0;
  298.         key_ctrlpoly=0;
  299.         key_input=0;
  300.         key_points=0;
  301.         glutPostRedisplay();
  302.             break;
  303.         case 'b': case 'B':
  304.         key_Approcurve=1;
  305.         key_input=0;
  306.         glutPostRedisplay();
  307.             break;
  308.         case 'a': case 'A':
  309.         key_Parabel=1;
  310.         key_input=0;
  311.         glutPostRedisplay();
  312.             break;     
  313.         case 'p': case 'P':
  314.         if(key_ctrlpoly==0)
  315.          key_ctrlpoly=1;
  316.         else key_ctrlpoly=0;
  317.         key_input=0;
  318.         glutPostRedisplay();
  319.             break;              
  320.     case 'i': case 'I':
  321.         key_input=1;
  322.         key_points=1;
  323.             break;
  324.     case 'm': case 'M':
  325.         key_input=0;
  326.             break;
  327.            
  328.     }
  329. }
  330.  
  331. /* This routine handles window resizes */
  332. void reshape(int w, int h)
  333. {
  334.     width = w;
  335.     height = h;
  336.  
  337.     /* Set the transformations */
  338.     glMatrixMode(GL_PROJECTION);
  339.     glLoadIdentity();
  340.     glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
  341.     glMatrixMode(GL_MODELVIEW);
  342.     glViewport(0, 0, w, h);
  343. }
  344.  
  345. int main(int argc, char **argv)
  346. {
  347.  
  348.  
  349.   std::cout << "Grad des Polynoms eingeben: " << std::endl;
  350.   std::cin >> num;
  351.     glutInit(&argc, argv);
  352.     glutInitDisplayMode(GLUT_RGB);
  353.     glutInitWindowSize(width, height);
  354.     glutInitWindowPosition(600,50);
  355.     glutCreateWindow("APPROXIMATION CURVES");
  356.     glEnable(GL_MAP1_VERTEX_3);
  357.     glClearColor(1.0, 1.0, 1.0, 1.0);
  358.  
  359.     /* Register the callbacks */
  360.     glutDisplayFunc(display);
  361.     glutMouseFunc(mouse);
  362.     glutKeyboardFunc(keyboard);
  363.     glutReshapeFunc(reshape);
  364.     glutMainLoop();
  365.     return 0;
  366. }
  367.  


Zuletzt geändert von Markus am Mi Jul 22, 2009 14:39, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 126 Beiträge ]  Gehe zu Seite Vorherige  1 ... 4, 5, 6, 7, 8, 9  Nächste
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: Google [Bot] und 10 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.012s | 16 Queries | GZIP : On ]