Gráficos por computadora usando JOGL. Oscar Gabriel Caballero Martínez
GLU glu = new GLU();
4. gl.glClearColor(1,1,1,0);
5. gl.glMatrixMode(GL2.GL_PROJECTION);
6. glu.gluOrtho2D (0.0, 10.0, 0.0, 10.0);
7. gl.glMatrixMode(GL2.GL_MODELVIEW);
8. gl.glLoadIdentity();
9. }
10. public void display(GLAutoDrawable drawable)
11. {
12. GL2 gl = glad.getGL().getGL2();
13.
14. gl.glClear(GL2.GL_COLOR_BUFFER_BIT);
15. gl.glLoadIdentity();
16. gl.glPointSize(3.0f);
17. gl.glColor3d(24/255.0,128/255.0,21/255.0);
18. dibujaTriangulo(gl);
19. gl.glFlush();
20. }
21. public void reshape(GLAutoDrawable glad, int i, int i1, int i2, int i3) {
22. GL2 gl = glad.getGL().getGL2();
23. gl.glViewport(0, 0, i2, i3);
24. }
25. public void dibujaTriangulo(GL2 gl){
26. double ax,ay,bx,by,cx,cy,px,py;
27. double r;
28. int i,rprima;
29. i=0;
30. ax=1.0;
31. ay=1.0;
32. bx=5.0;
33. by=9.0;
34. cx=9.0;
35. cy=1.0;
36. px=9.0;
37. py=9.0;
38. gl.glBegin(GL2.GL_POINTS);
39. gl.glVertex2d(ax,ay);
40. gl.glVertex2d(bx,by);
41. gl.glVertex2d(cx,cy);
42. do{
43. gl.glVertex2d(px,py);
44. r=Math.random()*1000;
45. rprima = (int)r%3;
46. switch(rprima){
47. case 0: px=(px+ax)/2;
48. py=(py+ay)/2;
49. break;
50. case 1: px=(px+bx)/2;
51. py=(py+by)/2;
52. break;
53. case 2: px=(px+cx)/2;
54. py=(py+cy)/2;
55. break;
56. }
57. i++;
58. }while(i<10000);
59. gl.glEnd();
60. }
Código 3.3 Sierpinsky.java
La idea para construir el triángulo se basa en que se tienen tres puntos fijos A, B y C, definidos desde la línea 30 a la 35, dentro del método dibujaTriangulo, y un cuarto punto P que se define en las líneas 36 y 37. El algoritmo trabaja tomando cualquier punto A, B y C al azar; ya que se tiene, se calcula el punto medio entre el punto escogido y el punto P y el resultado se asigna al punto P; esto se hace desde la línea 44, donde r toma el valor aleatorio (Math.random()*1000), la línea 45 donde rprima toma el módulo 3 del valor truncado de r ((int)r%3) que puede tomar los valores de 0, 1 y 2; de la línea 46 a la línea 56, dependiendo del valor de rprima se calcula el punto medio requerido. Esto se aplica hasta que el valor de i alcance el valor de 10000 (de la línea 42 a la 58). Al finalizar genera la figura 3.7.
Figura 3.7 Salida del triángulo de Sierpinsky
Fuente: Elaboración propia.
Para continuar con las metodologías de programación llevadas al momento se construirá otra versión de la clase anterior que se llamará SierpinskyV2, que consiste en apoyarse de una clase, la cual llevará el nombre de MisPuntos2D.
1. import com.jogamp.opengl.GL2;
2. public class MisPuntos2D {
3. double x,y;
4. MisPuntos2D(){
5. x = y = 0.0;
6. }
7. MisPuntos2D(double px, double py){
8. x = px;
9. y = py;
10. }
11. void puntoMedio(MisPuntos2D p){
12. x = (x+p.x)/2;
13. y = (y+p.y)/2;
14. }
15. void dibuja(GL2 gl){
16. gl.glBegin(GL2.GL_POINTS);
17. gl.glVertex2d(x, y);
18. gl.glEnd();
19. }
20. }
Código 3.4 MisPuntos2D.java
Las características de esta clase son los valores de las coordenadas x e y línea 3. En la línea 1 se importa el paquete que contiene a la clase GL2, que nos ayudará a dibujar el punto en dos dimensiones (ver líneas de la 15 a la 19). De las líneas 11 a la 14, el método puntoMedio recibe como parámetro un objeto MisPuntos2D y calcula el punto medio entre el parámetro y el objeto que manda llamar al método. Los constructores (líneas de la 4 a la 6 y de la 7 a la línea 10) funcionan de la siguiente forma: si no hay parámetros al momento de construir al objeto, el valor del punto es el origen, en cambio, si llegan dos valores como parámetros el punto es (px, py).
Para programar la nueva versión se genera una nueva clase llamada SierpinskyV2 y se sustituyen los métodos
• init
• display
• reshape
de la clase Sierpinsky a la clase SierpinskyV2. Y en la línea 18 del método display se cambia por dibujaTrianguloV2(gl).
Y se transcribe el siguiente código
1. void dibujaTrianguloV2(GL2 gl){
2. MisPuntos2D A,B,C,P;
3. double r;
4. int i=0,rprima;
5. A = new MisPuntos2D(1,1);
6. B = new MisPuntos2D(5,9);
7. C = new MisPuntos2D(9,1);
8. P = new MisPuntos2D(4,4);
9. A.dibuja(gl);
10. B.dibuja(gl);
11. C.dibuja(gl);
12. do{
13. P.dibuja(gl);
14. r = Math.random()*10000;
15. rprima = (int)r%3;
16. switch(rprima){
17. case 0: P.puntoMedio(A);
18. break;
19. case 1: P.puntoMedio(B);
20. break;
21. case 2: P.puntoMedio(C);
22. break;
23.