Re: Graphics help please

In article <circle-20080128024321@ram.dialup.fu-berlin.de>,
 ram@zedat.fu-berlin.de (Stefan Ram) wrote:


I've got something similar, with a 3D turtle. You can move it forward
with move(), and you can turn it with pitch(), roll(), and yaw(). When
you move it, you give it a graphics object, and it will trail a line as
it moves. You can give it null for the graphics object if you don't
want the line.

You can also draw a line from (x0,y0,z0) to (x1,y1,z1), with the
coordinates in the coordinate system of the turtle's frame of reference.
The normal way to use this would be to write a function that draws
something interesting (like a spaceship or a pterodactyl) using the
line() function. Since that is using the coordinate system of the
turtle, when you move the turtle (or change its pitch, yaw, or roll),
and draw your thing again, your thing will be moved and rotated
accordingly.

There's also functions in the turtle class to save and restore the
turtle position. These are meant to allow you to use the turtle itself
to draw interesting things, that you then move. Say, for example, you
wanted to make a flying saucer. You could draw it using line(), but
that is kind of a pain. So instead what you do is save the turtle's
position, and then you can draw the flying saucer's circle by moving and
turning the turtle, in addition to using line(). When done, you restore,
and the turtle is back to the starting position and orientation, so you
can them move and pitch and roll and yaw to get to the next position for
drawing your flying saucer.

Here's the code, as part of a program that draws a simple little
dohickey 4 times, once stationary, once flying away from the camera and
rolling, once doing a pitch loop, and once doing a yaw loop.

The program is called Boxes even though there are no boxes anywhere in
there. That's because the purpose of this was to do some experiments
with perspective. I was trying to understand why my drawing (the pencil
and paper kind, not the Java kind) didn't look right, and needed to see
some boxes at various angles and positions to understand what was going
on. I worked out my perspective puzzlement without needing the program,
so it never got past the turtle implementation and the dohickey loops
that were for debugging.

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.Random;

// Eye is at (0,0,eye)
// Projection plane is at z = 0, and its (0, 0) is in center of view
// Room's smaller of x and y axis goes from -50 to +50

public class Boxes extends JPanel
{
    final int width = 1024;
    final int height = 768;
    RoomAndCamera env;
    Random r;

    JFrame frame;

    static public void main( String args[] )
    {
        new Boxes();
    }

    Boxes()
    {
        r = new Random();
        env = new RoomAndCamera( 100, width, height, -20 );

        JFrame frame = new JFrame( "Perspective Test" );
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        frame.setLocation( new Point(20,20) );
        frame.setSize( width, height + 30 );
        frame.setContentPane(this);

        frame.setVisible(true);
    }

    public void paintComponent( Graphics g )
    {
        super.paintComponent(g);
        draw_boxes(g);
    }

    public void dohickey( Graphics g, Turtle t )
    {
        g.setColor( Color.red );
        t.line( g, -5, 0, 0, 5, 0, 0 );
        g.setColor( Color.green );
        t.line( g, 0, 0, 0, 0, 5, 0 );
        g.setColor( Color.blue );
        t.line( g, 0, 0, 0, 0, 0, 5 );
    }

    public void draw_boxes( Graphics g )
    {
        Turtle t[] = new Turtle[3];
        t[0] = new Turtle( env, -3*env.size()/5, -3*env.size()/4,
env.size()/2 );
        t[1] = new Turtle( env, -env.size()/3, 4*env.size()/5,
env.size()/2 );
        t[2] = new Turtle( env, 3*env.size()/5, -3*env.size()/5,
env.size()/2 );

        Turtle ref = new Turtle( env, 3*env.size()/4, 4*env.size()/5,
env.size()/2 );

        dohickey( g, ref );

        for ( int tn = 0; tn < 3; ++tn )
        {
            dohickey( g, t[tn] );

            int len = 10;

            for ( int i = 0; i < 20; ++i )
            {
                if ( tn == 0 )
                    t[tn].pitch( Math.PI/10 );
                else if ( tn == 1 )
                    t[tn].roll( Math.PI/12 );
                else if ( tn == 2 )
                    t[tn].yaw( Math.PI/10 );

                t[tn].move( null, len );

                dohickey( g, t[tn] );
            }
        }
    }
}

class RoomAndCamera
{
    double room_size;
    int cx, cy;
    double eye;
    double conv;

    RoomAndCamera( double size, int disp_w, int disp_h, double camloc )
    {
        room_size = size;
        eye = camloc;
        cx = disp_w / 2;
        cy = disp_h / 2;
        if ( disp_w < disp_h )
            conv = disp_w / room_size;
        else
            conv = disp_h / room_size;
        conv *= -eye;
    }

    int project_x( double x, double z )
    {
        return cx + (int)(conv * x / (z - eye));
    }

    int project_y( double y, double z )
    {
        return cy + (int)(conv * y / (z - eye));
    }

    double size() { return room_size; }
}

class Turtle
{
    double x, y, z;
    double vx[]; // x vector from object's point of view
    double vy[]; // y vector from object's point of view
    double vz[]; // z vector from object's point of view

    double sx, sy, sz;
    double svx[], svy[], svz[];

    RoomAndCamera env;

    Turtle( RoomAndCamera aenv, double ax, double ay, double az )
    {
        env = aenv;

        x = ax;
        y = ay;
        z = az;

        vx = new double[3];
        vy = new double[3];
        vz = new double[3];

        vx[0] = 1; vx[1] = 0; vx[2] = 0;
        vy[0] = 0; vy[1] = 1; vy[2] = 0;
        vz[0] = 0; vz[1] = 0; vz[2] = 1;

        mark();
    }

    Turtle( Turtle that )
    {
        env = that.env;

        x = that.x;
        y = that.y;
        z = that.z;

        vx = new double[3];
        vy = new double[3];
        vz = new double[3];

        for ( int i = 0; i < 3; ++i )
        {
            vx[i] = that.vx[i];
            vy[i] = that.vy[i];
            vz[i] = that.vz[i];
        }

        mark();
    }

    void mark()
    {
        sx = x;
        sy = y;
        sz = z;

        svx = new double[3];
        svy = new double[3];
        svz = new double[3];
        for ( int i = 0; i < 3; ++i )
        {
            svx[i] = vx[i];
            svy[i] = vy[i];
            svz[i] = vz[i];
        }
    }

    void restore()
    {
        x = sx;
        y = sy;
        z = sz;
        for ( int i = 0; i < 3; ++i )
        {
            vx[i] = svx[i];
            vy[i] = svy[i];
            vz[i] = svz[i];
        }
    }

    void vector_rotate( double t, double v[], double w[] )
    {
        // v <- v cos(t) + w sin(t)
        // w <- -v sin(t) + w cos(t)

        double nv[] = new double[3];
        double nw[] = new double[3];
        int i;
        for ( i = 0; i < 3; ++i )
        {
            nv[i] = Math.cos(t) * v[i] + Math.sin(t) * w[i];
            nw[i] = -Math.sin(t) * v[i] + Math.cos(t) * w[i];
        }
        for ( i = 0; i < 3; ++i )
        {
            v[i] = nv[i];
            w[i] = nw[i];
        }
    }

    // spin around the x vector
    void pitch( double t )
    {
        vector_rotate( t, vy, vz );
    }

    // spin around the y vector
    void yaw( double t )
    {
        vector_rotate( t, vz, vx );
    }

    // spin around the z vector
    void roll( double t )
    {
        vector_rotate( t, vx, vy );
    }

    void move( Graphics g, double dist )
    {
        boolean clip = false;
        int x0 = env.project_x( x, z );
        int y0 = env.project_y( y, z );
        if ( z < 0 )
            clip = true;
        x += dist * vz[0];
        y += dist * vz[1];
        z += dist * vz[2];
        int x1 = env.project_x( x, z );
        int y1 = env.project_y( y, z );
        if ( z < 0 )
            clip = true;
        if ( g != null && ! clip )
            g.drawLine( x0, y0, x1, y1 );
    }

    void line( Graphics g, double x0, double y0, double z0, double x1,
double y1, double z1 )
    {
        double p0[] = new double[3];
        double p1[] = new double[3];
        for ( int i = 0; i < 3; ++i )
        {
            p0[i] = x0 * vx[i] + y0 * vy[i] + z0 * vz[i];
            p1[i] = x1 * vx[i] + y1 * vy[i] + z1 * vz[i];
        }
        p0[0] += x; p1[0] += x;
        p0[1] += y; p1[1] += y;
        p0[2] += z; p1[2] += z;
        int ix0 = env.project_x( p0[0], p0[2] );
        int iy0 = env.project_y( p0[1], p0[2] );
        int ix1 = env.project_x( p1[0], p1[2] );
        int iy1 = env.project_y( p1[1], p1[2] );
        if ( g != null && p0[2] >= 0 && p1[2] >= 0 )
            g.drawLine( ix0, iy0, ix1, iy1 );
    }
}

--
--Tim Smith