adaptive supersampling

import javax.media.opengl.*;
 
public class adaptive_raytracing extends J3_11_rayTracing {
 
    public void display(GLAutoDrawable glDrawable) {
        float[] viewpt = new float[3];
        float[] raypt = new float[3], raypt1 = new float[3], raypt2 = new float[3], raypt3 = new float[3], raypt4 = new float[3];
        // initial ray: viewpt -> raypt
 
        float[] color = new float[3]; // traced color
 
        float[] icolor = new float[3], icolor1 = new float[3], icolor2 = new float[3], icolor3 = new float[3], icolor4 = new float[3]; // traced color
 
 
        // initialize 'ns' number of spheres
        for (int i = 0; i < ns; i++) {
            sphere[i][0] = 10 + WIDTH * Math.random() / 10; // radius
 
            for (int j = 1; j < 4; j++) { // center
 
                sphere[i][j] = -WIDTH / 4 + WIDTH * Math.random() / 2;
            }
        }
 
        // initialize 'nl' light source locations
        for (int i = 0; i < nl; i++) {
            for (int j = 0; j < 3; j++) { // light source positions
 
                lightSrc[i][j] = (float) (- 2 * WIDTH + 4 * WIDTH * Math.random());
            }
        }
 
        // starting viewpoint on positive z axis
        viewpt[0] = 0;
        viewpt[1] = 0;
        viewpt[2] = (float) (1.5 * HEIGHT);
 
        boolean done = false;
 
        // trace rays against the spheres and a plane
        for (double y = -HEIGHT / 2; y < HEIGHT / 2; y++) {
            for (double x = -WIDTH / 2; x < WIDTH / 2; x++) {
 
                // ray from viewpoint to a pixel on the screen
                // tracing the ray (viewpt to raypt) for depth bounces
 
                raypt[0] = (float) x;
                raypt[1] = (float) y;
                raypt[2] = 0;
                rayTracing(icolor, viewpt, raypt, depth);
                gl.glColor3fv(icolor, 0);
 
 
                // adaptive ray tracing
                for (int k = 0; k < 5; k++) {
 
                    double selfx = x, selfy = y;
                    double leftx = x - 0.5, lefty = y;
                    double rightx = x + 0.5, righty = y;
                    double upx = x, upy = y - 0.5;
                    double downx = x, downy = y + 0.5;
 
                    // for the middle value
                    raypt[0] = (float) selfx;
                    raypt[1] = (float) selfy;
                    raypt[2] = 0;
                    rayTracing(icolor, viewpt, raypt, depth);
 
                    // for the leftvalue
                    raypt1[0] = (float) leftx;
                    raypt1[1] = (float) lefty;
                    raypt1[2] = 0;
                    rayTracing(icolor1, viewpt, raypt1, depth);
 
                    // for the value right
                    raypt2[0] = (float) rightx;
                    raypt2[1] = (float) righty;
                    raypt2[2] = 0;
                    rayTracing(icolor2, viewpt, raypt2, depth);
 
                    // for the up value
                    raypt3[0] = (float) upx;
                    raypt3[1] = (float) upy;
                    raypt3[2] = 0;
                    rayTracing(icolor3, viewpt, raypt3, depth);
 
                    // for the down value
                    raypt4[0] = (float) downx;
                    raypt4[1] = (float) downy;
                    raypt4[2] = 0;
                    rayTracing(icolor4, viewpt, raypt4, depth);
 
                    float[] temp = getColorAverage(icolor, icolor1, icolor2, icolor3, icolor4);
 
 
                    if (temp[0] < 0.1 || temp[1] < 0.1 || temp[2] < 0.1) {
 
                        for (int i = 0; i < 3; i++) {
                            color[i] = temp[i];
                        }
                        gl.glColor3fv(color, 0);
                        gl.glViewport(0, 0, WIDTH, HEIGHT);
                        drawPoint(x, y);
                        done = true;
 
                    } else {
 
                        x = x / 2;
                        y = y / 2;
                        done = false;
                    }
 
                }
 
            }
        }
    }
 
    public float[] getColorAverage(float[] c, float[] c1, float[] c2, float[] c3, float[] c4) {
        float[] averageA = new float[3];
 
        for (int i = 0; i < 3; i++) {
            averageA[i] = (((c[i] - c1[i]) + (c[i] - c2[i]) + (c[i] - c3[i]) + (c[i] - c4[i])) / 4);
        }
 
        return averageA;
    }
 
    public static void main(String[] args) {
        adaptive_raytracing f = new adaptive_raytracing();
 
        f.setTitle("Adaptive ray tracing by Duc Tran");
        f.setSize(WIDTH, HEIGHT);
        f.setVisible(true);
    }
}

    public void display(GLAutoDrawable glDrawable) {
        float[] viewpt = new float[3];
 
        float[] raypt = new float[3], raypt1 = new float[3], raypt2 = new float[3], raypt3 = new float[3], raypt4 = new float[3];
        // initial ray: viewpt -> raypt
 
        float[] color = new float[3]; // traced color
 
        float[] icolor = new float[3], icolor1 = new float[3], icolor2 = new float[3], icolor3 = new float[3], icolor4 = new float[3]; // traced color
 
        float[] avgColor = new float[3];
        float[] diffColor = new float[3];
 
 
        for (int l = 0; l < 3; l++) {
            icolor[l] = 0;
            icolor1[l] = 0;
            icolor2[l] = 0;
            icolor3[l] = 0;
            icolor4[l] = 0;
            avgColor[l] = 0;
            diffColor[l] = 0;
        }
 
        // initialize 'ns' number of spheres
        for (int i = 0; i < ns; i++) {
            sphere[i][0] = 10 + WIDTH * Math.random() / 10; // radius
 
            for (int j = 1; j < 4; j++) { // center
 
                sphere[i][j] = -WIDTH / 4 + WIDTH * Math.random() / 2;
            }
        }
 
        // initialize 'nl' light source locations
        for (int i = 0; i < nl; i++) {
            for (int j = 0; j < 3; j++) { // light source positions
 
                lightSrc[i][j] = (float) (-8 * WIDTH + 40 * WIDTH * Math.random());
            }
        }
 
        // starting viewpoint on positive z axis
        viewpt[0] = 0;
        viewpt[1] = 0;
        viewpt[2] = (float) (1.5 * HEIGHT);
        boolean done = false;
        int count = 0;
        
        // trace rays against the spheres and a plane
        for (double y = -HEIGHT+10 / 2; y < HEIGHT / 2; y++) {
            for (double x = -WIDTH+10 / 2; x < WIDTH / 2; x++) {
 
                // adaptive ray tracing
                while (!done || count<2) {
 
                    // value of the middle points and 4 corner points
                    double selfx = x, selfy = y;
 
                    double upleftx = x - 0.5, uplefty = y + 0.5;
                    double uprightx = x + 0.5, uprighty = y + 0.5;
                    double downleftx = x - 0.5, downlefty = y - 0.5;
                    double downrightx = x + 0.5, downrighty = y - 0.5;
 
                    // for the middle value
                    raypt[0] = (float) selfx;
                    raypt[1] = (float) selfy;
                    raypt[2] = 0;
                    rayTracing(icolor, viewpt, raypt, depth);
 
 
                    // for the leftvalue
                    raypt1[0] = (float) upleftx;
                    raypt1[1] = (float) uplefty;
                    raypt1[2] = 0;
                    rayTracing(icolor1, viewpt, raypt1, depth);
 
 
                    // for the value right
                    raypt2[0] = (float) uprightx;
                    raypt2[1] = (float) uprighty;
                    raypt2[2] = 0;
                    rayTracing(icolor2, viewpt, raypt2, depth);
 
 
                    // for the up value
                    raypt3[0] = (float) downleftx;
                    raypt3[1] = (float) downlefty;
                    raypt3[2] = 0;
                    rayTracing(icolor3, viewpt, raypt3, depth);
 
 
                    // for the down value
                    raypt4[0] = (float) downrightx;
                    raypt4[1] = (float) downrighty;
                    raypt4[2] = 0;
                    rayTracing(icolor4, viewpt, raypt4, depth);
 
                    avgColor = getColorAverage(icolor1, icolor2, icolor3, icolor4);
 
                    for (int j = 0; j < 3; j++) {
 
                        diffColor[j] = Math.abs(avgColor[j] - icolor[j]);
                    }
                    if (diffColor[0] < 0.0001 || diffColor[1] < 0.0001 || diffColor[2] < 0.0001) {
 
                        for (int i = 0; i < 3; i++) {
                            color[i] = color[i] + diffColor[i];
                        }
                        done = true;
                        x = selfx;
                        y = selfy;
 
                    } else {
                        done = false;
                        count++;
                        x = selfx / 2;
                        y = selfy / 2;
                    }
 
                }
 
                gl.glColor3fv(color, 0);
                gl.glViewport(0, 0, WIDTH, HEIGHT);
                drawPoint(x, y);
            }
        }
 
 
    }
 
    public float[] getColorAverage(float[] c1, float[] c2, float[] c3, float[] c4) {
 
        float[] averageA = new float[3];
 
        for (int i = 0; i < 3; i++) {
            averageA[i] = (c1[i] + c2[i] + c3[i] + c4[i]) / 4;
            System.out.println("Average Color       : " + averageA[i]);
        }
 
        return averageA;
    }
 
    // recursive rayTracing from vpt to rpt for depth bounces, finding final color
    public void rayTracing(float[] color, float[] vpt, float[] rpt, int depth) {
 
        float[] reflectClr = new float[3], transmitClr = new float[3];
        float[] rpoint = new float[3]; // a point on ray direction
 
        float[] rD = new float[3]; // ray direction
 
        float[] vD = new float[3]; // view direction
 
        float[] n = new float[3]; // normal
 
        float[] p = new float[3]; // intersection point
 
 
        for (int i = 0; i < 3; i++) {
            color[i] = 0;
        }
 
        if (depth != 0) {// calculate color
 
            // find intersection of ray from vpt to rpt
            // with the closest object or the background
            intersect(vpt, rpt, p, n); // intersect at p with normal n
 
            // calculate lighting of the intersection point
            if (n[0] * n[0] + n[1] * n[1] + n[2] * n[2] > 0.001) {
 
                // view direction vector for lighting and reflection
                for (int i = 0; i < 3; i++) {
                    vD[i] = vpt[i] - rpt[i];
                }
 
                normalize(n);
                normalize(vD);
 
                // calculate color using Phong shading
                phong(color, p, vD, n);
 
                // reflected ray
                reflect(vD, n, rD);
 
                for (int i = 0; i < 3; i++) {
                    // a point on the reflected ray starting from p
                    rpoint[i] = rD[i] + p[i];
                }
 
                // recursion to find a bounce at lower level
                rayTracing(reflectClr, p, rpoint, depth - 1);
 
                for (int i = 0; i < 3; i++) {
                    color[i] = (float) (color[i] + 0.9 * reflectClr[i]);
 
                    if (color[i] > 1) //color values are not normalized. 
                    {
                        color[i] = 1;
                    }
                }
            }
        }
    }