JuliaSet2.java Source code

Java tutorial

Introduction

Here is the source code for JuliaSet2.java

Source

/*
 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.com/javaexamples3.
 */
//package je3.print;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.JobAttributes;
import java.awt.PageAttributes;
import java.awt.PrintJob;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;

import javax.swing.JComponent;
import javax.swing.JOptionPane;

/**
 * This class extends JuliaSet1 and overrides the print() method to demonstrate
 * the Java 1.2 printing API.
 */
public class JuliaSet2 extends JuliaSet1 {
    public JuliaSet2() {
        this(.4, .4);
    } // Display a different set by default

    public JuliaSet2(double cx, double cy) {
        super(cx, cy);
    }

    // This method demonstrates the Java 1.2 printing API.
    // Test it using the ShowBean program.
    public void print() {
        // Java 1.1 used java.awt.PrintJob.
        // In Java 1.2 we use java.awt.print.PrinterJob
        PrinterJob job = PrinterJob.getPrinterJob();

        // Alter the default page settings to request landscape mode
        PageFormat page = job.defaultPage();
        page.setOrientation(PageFormat.LANDSCAPE); // landscape by default

        // Tell the PrinterJob what Printable object we want to print.
        // PrintableComponent is defined as an inner class below
        String title = "Julia set for c={" + cx + "," + cy + "}";
        Printable printable = new PrintableComponent(this, title);
        job.setPrintable(printable, page);

        // Call the printDialog() method to give the user a chance to alter
        // the printing attributes or to cancel the printing request.
        if (job.printDialog()) {
            // If we get here, then the user did not cancel the print job
            // So start printing, displaying a dialog for errors.
            try {
                job.print();
            } catch (PrinterException e) {
                JOptionPane.showMessageDialog(this, e.toString(), "PrinterException", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    // This inner class implements the Printable interface for an AWT component
    public static class PrintableComponent implements Printable {
        Component c;

        String title;

        public PrintableComponent(Component c, String title) {
            this.c = c;
            this.title = title;
        }

        // This method should print the specified page number to the specified
        // Graphics object, abiding by the specified page format.
        // The printing system will call this method repeatedly to print all
        // pages of the print job. If pagenum is greater than the last page,
        // it should return NO_SUCH_PAGE to indicate that it is done. The
        // printing system may call this method multiple times per page.
        public int print(Graphics g, PageFormat format, int pagenum) {
            // This implemenation is always a single page
            if (pagenum > 0)
                return Printable.NO_SUCH_PAGE;

            // The Java 1.2 printing API passes us a Graphics object, but we
            // can always cast it to a Graphics2D object
            Graphics2D g2 = (Graphics2D) g;

            // Translate to accomodate the requested top and left margins.
            g2.translate(format.getImageableX(), format.getImageableY());

            // Figure out how big the drawing is, and how big the page
            // (excluding margins) is
            Dimension size = c.getSize(); // component size
            double pageWidth = format.getImageableWidth(); // Page width
            double pageHeight = format.getImageableHeight(); // Page height

            // If the component is too wide or tall for the page, scale it down
            if (size.width > pageWidth) {
                double factor = pageWidth / size.width; // How much to scale
                g2.scale(factor, factor); // Adjust coordinate system
                pageWidth /= factor; // Adjust page size up
                pageHeight /= factor;
            }
            if (size.height > pageHeight) { // Do the same thing for height
                double factor = pageHeight / size.height;
                g2.scale(factor, factor);
                pageWidth /= factor;
                pageHeight /= factor;
            }

            // Now we know the component will fit on the page. Center it by
            // translating as necessary.
            g2.translate((pageWidth - size.width) / 2, (pageHeight - size.height) / 2);

            // Draw a line around the outside of the drawing area and label it
            g2.drawRect(-1, -1, size.width + 2, size.height + 2);
            g2.drawString(title, 0, -15);

            // Set a clipping region so the component can't draw outside of
            // its won bounds.
            g2.setClip(0, 0, size.width, size.height);

            // Finally, print the component by calling its paint() method.
            // This prints the background, border, and children as well.
            // For swing components, if you don't want the background, border,
            // and children, then call printComponent() instead.
            c.paint(g);

            // Tell the PrinterJob that the page number was valid
            return Printable.PAGE_EXISTS;
        }
    }
}

class JuliaSet1 extends JComponent {
    // These constants are hard-coded for simplicity
    double x1 = -1.5, y1 = -1.5, x2 = 1.5, y2 = 1.5; // Region of complex plane

    int width = 400, height = 400; // Mapped to these pixels

    double cx, cy; // This complex constant defines the set we display

    BufferedImage image; // The image we compute

    // We compute values between 0 and 63 for each point in the complex plane.
    // This array holds the color values for each of those values.
    static int[] colors;
    static { // Static initializer for the colors[] array.
        colors = new int[64];
        for (int i = 0; i < colors.length; i++) {
            colors[63 - i] = (i * 4 << 16) + (i * 4 << 8) + i * 4; // grayscale
            // (i*4) ^ ((i * 3)<<6) ^ ((i * 7)<<13); // crazy technicolor
        }
    }

    // No-arg constructor with default values for cx, cy.
    public JuliaSet1() {
        this(-1, 0);
    }

    // This constructor specifies the {cx,cy} constant.
    // For simplicity, the other constants remain hardcoded.
    public JuliaSet1(double cx, double cy) {
        this.cx = cx;
        this.cy = cy;
        setPreferredSize(new Dimension(width, height));
        computeImage();
    }

    // This method computes a color value for each pixel of the image
    void computeImage() {
        // Create the image
        image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        // Now loop through the pixels
        int i, j;
        double x, y;
        double dx = (x2 - x1) / width;
        double dy = (y2 - y1) / height;
        for (j = 0, y = y1; j < height; j++, y += dy) {
            for (i = 0, x = x1; i < width; i++, x += dx) {
                // For each pixel, call testPoint() to determine a value.
                // Then map that value to a color and set it in the image.
                // If testPoint() returns 0, the point is part of the Julia set
                // and is displayed in black. If it returns 63, the point is
                // displayed in white. Values in-between are displayed in
                // varying shades of gray.
                image.setRGB(i, j, colors[testPoint(x, y)]);
            }
        }
    }

    // This is the key method for computing Julia sets. For each point z
    // in the complex plane, we repeatedly compute z = z*z + c using complex
    // arithmetic. We stop iterating when the magnitude of z exceeds 2 or
    // after 64 iterations. We return the number of iterations-1.
    public int testPoint(double zx, double zy) {
        for (int i = 0; i < colors.length; i++) {
            // Compute z = z*z + c;
            double newx = zx * zx - zy * zy + cx;
            double newy = 2 * zx * zy + cy;
            zx = newx;
            zy = newy;
            // Check magnitude of z and return iteration number
            if (zx * zx + zy * zy > 4)
                return i;
        }
        return colors.length - 1;
    }

    // This method overrides JComponent to display the julia set.
    // Just scale the image to fit and draw it.
    public void paintComponent(Graphics g) {
        g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
    }

    // This method demonstrates the Java 1.1 java.awt.PrintJob printing API.
    // It also demonstrates the JobAttributes and PageAttributes classes
    // added in Java 1.3. Display the Julia set with ShowBean and use
    // the Command menu to invoke this print command.
    public void print() {
        // Create some attributes objects. This is Java 1.3 stuff.
        // In Java 1.1, we'd use a java.util.Preferences object instead.
        JobAttributes jattrs = new JobAttributes();
        PageAttributes pattrs = new PageAttributes();

        // Set some example attributes: monochrome, landscape mode
        pattrs.setColor(PageAttributes.ColorType.MONOCHROME);
        pattrs.setOrientationRequested(PageAttributes.OrientationRequestedType.LANDSCAPE);
        // Print to file by default
        jattrs.setDestination(JobAttributes.DestinationType.FILE);
        jattrs.setFileName("juliaset.ps");

        // Look up the Frame that holds this component
        Component frame = this;
        while (!(frame instanceof Frame))
            frame = frame.getParent();

        // Get a PrintJob object to print the Julia set with.
        // The getPrintJob() method displays a print dialog and allows the user
        // to override and modify the default JobAttributes and PageAttributes
        Toolkit toolkit = this.getToolkit();
        PrintJob job = toolkit.getPrintJob((Frame) frame, "JuliaSet1", jattrs, pattrs);

        // We get a null PrintJob if the user clicked cancel
        if (job == null)
            return;

        // Get a Graphics object from the PrintJob.
        // We print simply by drawing to this Graphics object.
        Graphics g = job.getGraphics();

        // Center the image on the page
        Dimension pagesize = job.getPageDimension(); // how big is page?
        Dimension panesize = this.getSize(); // how big is image?
        g.translate((pagesize.width - panesize.width) / 2, // center it
                (pagesize.height - panesize.height) / 2);

        // Draw a box around the Julia Set and label it
        g.drawRect(-1, -1, panesize.width + 2, panesize.height + 2);
        g.drawString("Julia Set for c={" + cx + "," + cy + "}", 0, -15);

        // Set a clipping region
        g.setClip(0, 0, panesize.width, panesize.height);

        // Now print the component by calling its paint method
        this.paint(g);

        // Finally tell the printer we're done with the page.
        // No output will be generated if we don't call dispose() here.
        g.dispose();
    }
}