Rognebær

Rekursjon

Vi lager løsningen rekursiv. Hovedkomponenten i løsningen er en funksjon som er bygget opp slik:

void DrawOneBranch(...)
{
  if(< end of branchdepth >)
  {
    < draw berry >
    return;
  }

  < draw a single stem >
  glTranslate( < to the end of this stem >);
  for ( < all subbranches >)
  {
     glPushMatrix();
     < rotate for next branch >
     DrawOneBranch(...);
     glPopMatrix();
  }
}

Tidsoptimering

I løsningen er det valgt å bruke sylindere til grenene. Dette kan fort bli tidkrevende og det er lagt opp til en strategi der det tegnes ut en forenklet figur basert på streker, uten rognebær, når figuren manipuleres. Dette gjør det mulig for brukeren å se treets struktur mens manipuleringen pågår. Når manipuleringen opphører tegnes treet komplett ut.

Det er introdusert et flagg

boolean is_moving;

som settes når museknappen presses ned og frigjøres når den slippes.

Tegnekode

Denne strategien er realisert ved følgende metoder

public void display(GLAutoDrawable drawable)
{
    GL gl = drawable.getGL();
    GLU glu = new GLU();
    // Clear the drawing area
    gl.glClear(GL.GL_COLOR_BUFFER_BIT |
               GL.GL_DEPTH_BUFFER_BIT |
               GL.GL_ACCUM_BUFFER_BIT);
    // Reset the current matrix to the "identity"
    gl.glLoadIdentity();
    glu.gluLookAt(  30.0f,0.0f,10.0f,// eye
                    0.0f,0.0f,0.0f,  // looking at
                    0.0f,0.0f,1.0f); // is up
    // take it away
    gl.glTranslatef(0.0f,0.0f,-10.0f);
    // rotate around x-axis
    gl.glRotatef(rotx,1.0f,0.0f,0.0f);
    // rotate around z-axis
    gl.glRotatef(rotz,0.0f,0.0f,1.0f);
    // want same tree on redraw
    rand_rot.setSeed(m_rand_seed);
    setStemMaterial(gl);
    DrawOneBranch(gl,0.3f, 3, 6);
    // Flush all drawing operations to the graphics card
    gl.glFlush();
}

og selve uttegningen

public void DrawOneBranch(GL gl,
                         float radius, int branches, int depth)
{
  GLU glu=new GLU();
  GLUquadric glpQ=glu.gluNewQuadric();
  if(depth==0)
  {
    // end of a branch
    // dont use time on berrys when manipulating
    if(!is_moving)
    {
      setBerryMaterial(gl);
      glu.gluSphere(glpQ,5*radius,5,5);
      setStemMaterial(gl);
    }
    glu.gluDeleteQuadric(glpQ);
    return;
  }
  // branch is set to 20 times the radius
  float len=radius*20;
  if(!is_moving)
    glu.gluCylinder(glpQ,radius,radius,len,10,1);
  else
  {
    // speed up with simple lines while manipulating
    gl.glBegin(GL.GL_LINES);
    gl.glVertex3f(0.0f,0.0f,0.0f);
    gl.glVertex3f(0.0f,0.0f,len);
    gl.glEnd();
  }
  gl.glTranslatef(0.0f,0.0f,len);
  // to end of the branch
  for(int bix=0;bix<branches;bix++)
  {
    // do each subtree
    gl.glPushMatrix();
    gl.glRotatef(1.0f+(float)rand_rot.nextFloat()%360.0f,0.0f,0.0f,1.0f);
    gl.glRotatef(-90.0f*(1.0f+(float)rand_rot.nextFloat()%90.0f),1.0f,0.0f,0.0f);
    gl.glRotatef(-90.0f*(1.0f+(float)rand_rot.nextFloat()%90.0f),0.0f,1.0f,0.0f);
    DrawOneBranch(gl,radius*0.8f,branches,depth-1);
    gl.glPopMatrix();
    glu.gluDeleteQuadric(glpQ);
  }
}

Tilfeldighet

Som det framgår av koden ovenfor brukes metoden rand_rot.nextFloat() ,der rand_rot er et objekt av typen java.util.Random, til å bestemme hvordan forgreiningene er fra en delstamme.

Det er et forhold som det er viktig å merke seg. Siden vår framstilling retegnes ofte, feks. ved resizing av vinduet og ved interkativ manipulering, vil treets struktur endre seg ved hver uttegning dersom vi lar rand() plukke tilfeldige tall kontinuerlig. Dersom vi ønsker å beholde treets struktur ved retegning, må vi sørge for at randomgeneratoren gjentar seg selv. Vi må kunne rekonstruere en sekvens av "tilfeldige" tall. Vi må starte sekvensen av tilfeldige tall på samme sted ved hver retegning.

Dette kan vi oppnå ved å kalle rutina rand_rot.setSeed(m_rand_seed) ved hver uttegning. m_rand_seed er en medlemsvariabel som vi kan sette til et heltall.

Vi kan administrere dette ved en menystyrt endring av m_rand_seed for det tilfellet at vi ønsker å endre treets struktur. Dette er gjort når vi høyreklikker i vinduet:

    public void mouseClicked(MouseEvent e) 
    {
        if(e.getButton()==MouseEvent.BUTTON3)
            m_rand_seed=rand_rot.nextLong();
    }

Vi bruker altså randomgeneratoren til å lage et nytt "seed"-tall til randomgeneratoren. Tallteoretisk er dette en tvilsom løsning. Men for vårt enkle eksempel gjør det jobben. Det har den konsekvensen at programmet alltid kommer opp med den samme sekvensen av trær.