Gráficos por computadora usando JOGL. Oscar Gabriel Caballero Martínez

Чтение книги онлайн.

СКАЧАТЬ Secante

      5. Cosecante

      Continuando con el manejo de las gráficas primitivas, se realizará el fractal del triángulo de Sierpinsky. En una clase llamada Sierpinsky se modifcan los métodos siguientes, agregando además el método dibujaTriangulo.

      1. public void init(GLAutoDrawable glad) {

      2. GL2 gl = glad.getGL().getGL2();

      3. 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 СКАЧАТЬ