Java/3D/Canvas3D

Java 3D and the User Interface

/*
The Joy of Java 3D
by Greg Hopkins
Copyright Copyright 2001

*/
/*
Canvas3D
Each area where three-dimensional graphics can be painted is called a Canvas3D.  This is 
a rectangle that contains a view of the objects in your universe. You place the canvas 
inside a frame, then you create a universe to be displayed in the canvas.
The following example shows how to create a canvas in a frame with labels at the top and 
bottom. The program can be run as either an applet or an application. 

Java 3D and Swing
The Canvas3D takes advantage of your computer"s graphics card to increase performance. 
Unfortunately, this means that it does not mix very well with Sun"s swing user interface 
components. These components are called "lightweight" Lightweight components can be 
hidden by a Canvas3D even if they are supposed to be at the front.
There are several solutions to this problem:
* You can mix lightweight and heavyweight components on the same screen if you keep them in separate containers. 
* if you use Popup menus, a static function on JPopupMenu fixes the problem:
setDefaultLightWeightPopupEnabled(false);
* You can use the older AWT components insteadof swing.

*/
//

import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.GraphicsConfiguration;
import java.awt.Label;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.SimpleUniverse;
public class CanvasDemo extends Applet {
  public CanvasDemo() {
    setLayout(new BorderLayout());
    GraphicsConfiguration config = SimpleUniverse
        .getPreferredConfiguration();
    Canvas3D canvas = new Canvas3D(config);
    add("North", new Label("This is the top"));
    add("Center", canvas);
    add("South", new Label("This is the bottom"));
    BranchGroup contents = new BranchGroup();
    contents.addChild(new ColorCube(0.3));
    SimpleUniverse universe = new SimpleUniverse(canvas);
    universe.getViewingPlatform().setNominalViewingTransform();
    universe.addBranchGraph(contents);
  }
  public static void main(String[] args) {
    CanvasDemo demo = new CanvasDemo();
    new MainFrame(demo, 400, 400);
  }
}

Off Screen Test

/*
 *  @(#)OffScreenTest.java 1.13 02/10/21 13:46:49
 *
 * Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
 * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
 * OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
 * FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that Software is not designed,licensed or intended
 * for use in the design, construction, operation or maintenance of
 * any nuclear facility.
 */
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.GraphicsConfiguration;
import java.awt.image.BufferedImage;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.ImageComponent;
import javax.media.j3d.ImageComponent2D;
import javax.media.j3d.Raster;
import javax.media.j3d.Screen3D;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.View;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3d;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.SimpleUniverse;
/**
 * OffScreenTest issues renderOffScreenBuffer from the postSwap callback of the
 * OnScreen canvas.
 */
public class OffScreenTest extends Applet {
  private SimpleUniverse u = null;
  public BranchGroup createSceneGraph(Raster drawRaster) {
    // Create the root of the branch graph
    BranchGroup objRoot = new BranchGroup();
    // spin object has composited transformation matrix
    Transform3D spin = new Transform3D();
    Transform3D tempspin = new Transform3D();
    spin.rotX(Math.PI / 4.0d);
    tempspin.rotY(Math.PI / 5.0d);
    spin.mul(tempspin);
    spin.setScale(0.7);
    spin.setTranslation(new Vector3d(-0.4, 0.3, 0.0));
    TransformGroup objTrans = new TransformGroup(spin);
    objRoot.addChild(objTrans);
    // Create a simple shape leaf node, add it to the scene graph.
    // ColorCube is a Convenience Utility class
    objTrans.addChild(new ColorCube(0.4));
    //Create a raster
    Shape3D shape = new Shape3D(drawRaster);
    objRoot.addChild(shape);
    // Let Java 3D perform optimizations on this scene graph.
    objRoot.rupile();
    return objRoot;
  }
  public OffScreenTest() {
  }
  public void init() {
    setLayout(new BorderLayout());
    GraphicsConfiguration config = SimpleUniverse
        .getPreferredConfiguration();
    BufferedImage bImage = new BufferedImage(200, 200,
        BufferedImage.TYPE_INT_ARGB);
    ImageComponent2D buffer = new ImageComponent2D(
        ImageComponent.FORMAT_RGBA, bImage);
    buffer.setCapability(ImageComponent2D.ALLOW_IMAGE_READ);
    Raster drawRaster = new Raster(new Point3f(0.0f, 0.0f, 0.0f),
        Raster.RASTER_COLOR, 0, 0, 200, 200, buffer, null);
    drawRaster.setCapability(Raster.ALLOW_IMAGE_WRITE);
    // create the main scene graph
    BranchGroup scene = createSceneGraph(drawRaster);
    // create the on-screen canvas
    OnScreenCanvas3D d = new OnScreenCanvas3D(config, false);
    add("Center", d);
    // create a simple universe
    u = new SimpleUniverse(d);
    // This will move the ViewPlatform back a bit so the
    // objects in the scene can be viewed.
    u.getViewingPlatform().setNominalViewingTransform();
    // create an off Screen Canvas
    OffScreenCanvas3D c = new OffScreenCanvas3D(config, true, drawRaster);
    // set the offscreen to match the onscreen
    Screen3D sOn = d.getScreen3D();
    Screen3D sOff = c.getScreen3D();
    sOff.setSize(sOn.getSize());
    sOff.setPhysicalScreenWidth(sOn.getPhysicalScreenWidth());
    sOff.setPhysicalScreenHeight(sOn.getPhysicalScreenHeight());
    // attach the same view to the offscreen canvas
    View v = u.getViewer().getView();
    v.addCanvas3D(c);
    // tell onscreen about the offscreen so it knows to
    // render to the offscreen at postswap
    d.setOffScreenCanvas(c);
    u.addBranchGraph(scene);
    v.stopView();
    // Make sure that image are render completely
    // before grab it in postSwap().
    d.setImageReady();
    v.startView();
  }
  public void destroy() {
    u.cleanup();
  }
  public static void main(String argv[]) {
    new MainFrame(new OffScreenTest(), 500, 500);
  }
}
class OffScreenCanvas3D extends Canvas3D {
  Raster drawRaster;
  boolean printing = false;
  public OffScreenCanvas3D(GraphicsConfiguration gconfig,
      boolean offscreenflag, Raster drawRaster) {
    super(gconfig, offscreenflag);
    this.drawRaster = drawRaster;
  }
  public void print(boolean toWait) {
    if (!toWait)
      printing = true;
    BufferedImage bImage = new BufferedImage(200, 200,
        BufferedImage.TYPE_INT_ARGB);
    ImageComponent2D buffer = new ImageComponent2D(
        ImageComponent.FORMAT_RGBA, bImage);
    buffer.setCapability(ImageComponent2D.ALLOW_IMAGE_READ);
    this.setOffScreenBuffer(buffer);
    this.renderOffScreenBuffer();
    if (toWait) {
      this.waitForOffScreenRendering();
      drawOffScreenBuffer();
    }
  }
  public void postSwap() {
    if (printing) {
      super.postSwap();
      drawOffScreenBuffer();
      printing = false;
    }
  }
  void drawOffScreenBuffer() {
    BufferedImage bImage = this.getOffScreenBuffer().getImage();
    ImageComponent2D newImageComponent = new ImageComponent2D(
        ImageComponent.FORMAT_RGBA, bImage);
    drawRaster.setImage(newImageComponent);
  }
}
class OnScreenCanvas3D extends Canvas3D {
  OffScreenCanvas3D c;
  boolean print = false;
  boolean imageReady = false;
  public OnScreenCanvas3D(GraphicsConfiguration gconfig, boolean offscreenflag) {
    super(gconfig, offscreenflag);
  }
  public void setOffScreenCanvas(OffScreenCanvas3D c) {
    this.c = c;
  }
  public void setImageReady() {
    imageReady = true;
  }
  public void postSwap() {
    if (imageReady && !print) {
      c.print(false);
      print = true;
    }
  }
}

Print Canvas3D

/*
 * @(#)PrintCanvas3D.java 1.5 02/04/01 15:04:11
 * 
 * Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met: -
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer. - Redistribution in binary
 * form must reproduce the above copyright notice, this list of conditions and
 * the following disclaimer in the documentation and/or other materials provided
 * with the distribution.
 * 
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
 * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
 * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
 * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGES.
 * 
 * You acknowledge that Software is not designed,licensed or intended for use in
 * the design, construction, operation or maintenance of any nuclear facility.
 */
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
import java.io.FileNotFoundException;
import javax.media.j3d.Alpha;
import javax.media.j3d.AmbientLight;
import javax.media.j3d.Background;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.ImageComponent;
import javax.media.j3d.ImageComponent2D;
import javax.media.j3d.RotationInterpolator;
import javax.media.j3d.Screen3D;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3f;
import com.sun.j3d.loaders.IncorrectFormatException;
import com.sun.j3d.loaders.ParsingErrorException;
import com.sun.j3d.loaders.Scene;
import com.sun.j3d.loaders.objectfile.ObjectFile;
import com.sun.j3d.utils.behaviors.mouse.MouseRotate;
import com.sun.j3d.utils.behaviors.mouse.MouseTranslate;
import com.sun.j3d.utils.behaviors.mouse.MouseZoom;
import com.sun.j3d.utils.universe.SimpleUniverse;
public class PrintCanvas3D extends JFrame implements ActionListener {
  private static final boolean spin = false;
  private static final boolean noTriangulate = false;
  private static final boolean noStripify = false;
  private static final double creaseAngle = 60.0;
  private JMenuItem snapshotItem;
  private JMenuItem printItem;
  private JMenuItem quitItem;
  private SimpleUniverse u;
  private Canvas3D canvas3D;
  private OffScreenCanvas3D offScreenCanvas3D;
  private static final int OFF_SCREEN_SCALE = 3;
  private class AppPanel extends JPanel {
    private String filename = null;
    public BranchGroup createSceneGraph(String args[]) {
      // Create the root of the branch graph
      BranchGroup objRoot = new BranchGroup();
      // Create a Transformgroup to scale all objects so they
      // appear in the scene.
      TransformGroup objScale = new TransformGroup();
      Transform3D t3d = new Transform3D();
      t3d.setScale(0.7);
      objScale.setTransform(t3d);
      objRoot.addChild(objScale);
      // Create the transform group node and initialize it to the
      // identity. Enable the TRANSFORM_WRITE capability so that
      // our behavior code can modify it at runtime. Add it to the
      // root of the subgraph.
      TransformGroup objTrans = new TransformGroup();
      objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
      objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
      objScale.addChild(objTrans);
      int flags = ObjectFile.RESIZE;
      if (!noTriangulate)
        flags |= ObjectFile.TRIANGULATE;
      if (!noStripify)
        flags |= ObjectFile.STRIPIFY;
      ObjectFile f = new ObjectFile(flags,
          (float) (creaseAngle * Math.PI / 180.0));
      Scene s = null;
      try {
        s = f.load(filename);
      } catch (FileNotFoundException e) {
        System.err.println(e);
        System.exit(1);
      } catch (ParsingErrorException e) {
        System.err.println(e);
        System.exit(1);
      } catch (IncorrectFormatException e) {
        System.err.println(e);
        System.exit(1);
      }
      objTrans.addChild(s.getSceneGroup());
      BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0,
          0.0), 100.0);
      if (spin) {
        Transform3D yAxis = new Transform3D();
        Alpha rotationAlpha = new Alpha(-1, Alpha.INCREASING_ENABLE, 0,
            0, 4000, 0, 0, 0, 0, 0);
        RotationInterpolator rotator = new RotationInterpolator(
            rotationAlpha, objTrans, yAxis, 0.0f,
            (float) Math.PI * 2.0f);
        rotator.setSchedulingBounds(bounds);
        objTrans.addChild(rotator);
      } else {
        // Create the rotate behavior node
        MouseRotate behavior = new MouseRotate();
        behavior.setTransformGroup(objTrans);
        objTrans.addChild(behavior);
        behavior.setSchedulingBounds(bounds);
        // Create the zoom behavior node
        MouseZoom behavior2 = new MouseZoom();
        behavior2.setTransformGroup(objTrans);
        objTrans.addChild(behavior2);
        behavior2.setSchedulingBounds(bounds);
        // Create the translate behavior node
        MouseTranslate behavior3 = new MouseTranslate();
        behavior3.setTransformGroup(objTrans);
        objTrans.addChild(behavior3);
        behavior3.setSchedulingBounds(bounds);
      }
      // Set up the background
      Color3f bgColor = new Color3f(0.05f, 0.05f, 0.5f);
      Background bgNode = new Background(bgColor);
      bgNode.setApplicationBounds(bounds);
      objRoot.addChild(bgNode);
      // Set up the ambient light
      Color3f ambientColor = new Color3f(0.1f, 0.1f, 0.1f);
      AmbientLight ambientLightNode = new AmbientLight(ambientColor);
      ambientLightNode.setInfluencingBounds(bounds);
      objRoot.addChild(ambientLightNode);
      // Set up the directional lights
      Color3f light1Color = new Color3f(1.0f, 1.0f, 0.9f);
      Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);
      Color3f light2Color = new Color3f(0.3f, 0.3f, 0.4f);
      Vector3f light2Direction = new Vector3f(-6.0f, -2.0f, -1.0f);
      DirectionalLight light1 = new DirectionalLight(light1Color,
          light1Direction);
      light1.setInfluencingBounds(bounds);
      objRoot.addChild(light1);
      DirectionalLight light2 = new DirectionalLight(light2Color,
          light2Direction);
      light2.setInfluencingBounds(bounds);
      objRoot.addChild(light2);
      return objRoot;
    }
    private void usage() {
      System.out.println("Usage: java PrintCanvas3D <.obj file>");
      System.exit(0);
    } // End of usage
    // Create the Canvas3D (both on-screen and off-screen)
    private void createCanvas3D(String[] args) {
      if (args.length == 0) {
        usage();
      } else {
        for (int i = 0; i < args.length; i++) {
          if (args[i].startsWith("-")) {
            System.err.println("Argument "" + args[i]
                + "" ignored.");
          } else {
            filename = args[i];
          }
        }
      }
      if (filename == null) {
        usage();
      }
      // Create Canvas3D
      GraphicsConfiguration config = SimpleUniverse
          .getPreferredConfiguration();
      canvas3D = new Canvas3D(config);
      canvas3D.setSize(600, 450);
      // Create a simple scene and attach it to the virtual universe
      BranchGroup scene = createSceneGraph(args);
      u = new SimpleUniverse(canvas3D);
      // This will move the ViewPlatform back a bit so the
      // objects in the scene can be viewed.
      u.getViewingPlatform().setNominalViewingTransform();
      u.addBranchGraph(scene);
      // Create the off-screen Canvas3D object
      offScreenCanvas3D = new OffScreenCanvas3D(config, true);
      // Set the off-screen size based on a scale factor times the
      // on-screen size
      Screen3D sOn = canvas3D.getScreen3D();
      Screen3D sOff = offScreenCanvas3D.getScreen3D();
      Dimension dim = sOn.getSize();
      dim.width *= OFF_SCREEN_SCALE;
      dim.height *= OFF_SCREEN_SCALE;
      sOff.setSize(dim);
      sOff.setPhysicalScreenWidth(sOn.getPhysicalScreenWidth()
          * OFF_SCREEN_SCALE);
      sOff.setPhysicalScreenHeight(sOn.getPhysicalScreenHeight()
          * OFF_SCREEN_SCALE);
      // attach the offscreen canvas to the view
      u.getViewer().getView().addCanvas3D(offScreenCanvas3D);
    }
    private AppPanel(String args[]) {
      setLayout(new BorderLayout());
      // Create Canvas3D and scene graph
      createCanvas3D(args);
      add("Center", canvas3D);
    }
  }
  public void actionPerformed(ActionEvent event) {
    Object target = event.getSource();
    if ((target == snapshotItem) || (target == printItem)) {
      Point loc = canvas3D.getLocationOnScreen();
      offScreenCanvas3D.setOffScreenLocation(loc);
      Dimension dim = canvas3D.getSize();
      dim.width *= OFF_SCREEN_SCALE;
      dim.height *= OFF_SCREEN_SCALE;
      BufferedImage bImage = offScreenCanvas3D.doRender(dim.width,
          dim.height);
      if (target == snapshotItem) {
        new ImageDisplayer(bImage);
      } else { // (target == printItem)
        new ImagePrinter(bImage).print();
      }
    } else if (target == quitItem) {
      u.removeAllLocales();
      System.exit(0);
    }
  }
  private JMenuBar createMenuBar() {
    JMenuBar menuBar = new JMenuBar();
    JMenu fileMenu = new JMenu("File");
    snapshotItem = new JMenuItem("Snapshot");
    snapshotItem.addActionListener(this);
    printItem = new JMenuItem("Print...");
    printItem.addActionListener(this);
    quitItem = new JMenuItem("Quit");
    quitItem.addActionListener(this);
    fileMenu.add(snapshotItem);
    fileMenu.add(printItem);
    fileMenu.add(new JSeparator());
    fileMenu.add(quitItem);
    menuBar.add(fileMenu);
    return menuBar;
  }
  private PrintCanvas3D(String args[]) {
    this.setTitle("Canvas3D Print Test");
    // Create and initialize menu bar
    JPopupMenu.setDefaultLightWeightPopupEnabled(false);
    this.setJMenuBar(createMenuBar());
    // Handle the close event
    this.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent winEvent) {
        System.exit(0);
      }
    });
    // Add main panel to top-level frame and make it visible
    this.getContentPane().add(new AppPanel(args));
    this.pack();
    this.setVisible(true);
  }
  public static void main(String[] args) {
    new PrintCanvas3D(args);
  }
}
class OffScreenCanvas3D extends Canvas3D {
  OffScreenCanvas3D(GraphicsConfiguration graphicsConfiguration,
      boolean offScreen) {
    super(graphicsConfiguration, offScreen);
  }
  BufferedImage doRender(int width, int height) {
    BufferedImage bImage = new BufferedImage(width, height,
        BufferedImage.TYPE_INT_ARGB);
    ImageComponent2D buffer = new ImageComponent2D(
        ImageComponent.FORMAT_RGBA, bImage);
    setOffScreenBuffer(buffer);
    renderOffScreenBuffer();
    waitForOffScreenRendering();
    bImage = getOffScreenBuffer().getImage();
    return bImage;
  }
  public void postSwap() {
    // No-op since we always wait for off-screen rendering to complete
  }
}
class ImageDisplayer extends JFrame implements ActionListener {
  BufferedImage bImage;
  private class ImagePanel extends JPanel {
    public void paint(Graphics g) {
      g.setColor(Color.black);
      g.fillRect(0, 0, getSize().width, getSize().height);
      g.drawImage(bImage, 0, 0, this);
    }
    private ImagePanel() {
      setPreferredSize(new Dimension(bImage.getWidth(), bImage
          .getHeight()));
    }
  }
  private JMenuItem printItem;
  private JMenuItem closeItem;
  public void actionPerformed(ActionEvent event) {
    Object target = event.getSource();
    if (target == printItem) {
      new ImagePrinter(bImage).print();
    } else if (target == closeItem) {
      this.removeAll();
      this.setVisible(false);
      bImage = null;
    }
  }
  private JMenuBar createMenuBar() {
    JMenuBar menuBar = new JMenuBar();
    JMenu fileMenu = new JMenu("File");
    printItem = new JMenuItem("Print...");
    printItem.addActionListener(this);
    closeItem = new JMenuItem("Close");
    closeItem.addActionListener(this);
    fileMenu.add(printItem);
    fileMenu.add(new JSeparator());
    fileMenu.add(closeItem);
    menuBar.add(fileMenu);
    return menuBar;
  }
  ImageDisplayer(BufferedImage bImage) {
    this.bImage = bImage;
    this.setTitle("Off-screen Canvas3D Snapshot");
    // Create and initialize menu bar
    this.setJMenuBar(createMenuBar());
    // Create scroll pane, and embedded image panel
    ImagePanel imagePanel = new ImagePanel();
    JScrollPane scrollPane = new JScrollPane(imagePanel);
    scrollPane.getViewport().setPreferredSize(new Dimension(700, 700));
    // Add scroll pane to the frame and make it visible
    this.getContentPane().add(scrollPane);
    this.pack();
    this.setVisible(true);
  }
}
class ImagePrinter implements Printable, ImageObserver {
  BufferedImage bImage;
  public int print(Graphics g, PageFormat pf, int pi) throws PrinterException {
    if (pi >= 1) {
      return Printable.NO_SUCH_PAGE;
    }
    Graphics2D g2d = (Graphics2D) g;
    //g2d.translate(pf.getImageableX(), pf.getImageableY());
    AffineTransform t2d = new AffineTransform();
    t2d.translate(pf.getImageableX(), pf.getImageableY());
    double xscale = pf.getImageableWidth() / (double) bImage.getWidth();
    double yscale = pf.getImageableHeight() / (double) bImage.getHeight();
    double scale = Math.min(xscale, yscale);
    t2d.scale(scale, scale);
    try {
      g2d.drawImage(bImage, t2d, this);
    } catch (Exception ex) {
      ex.printStackTrace();
      return Printable.NO_SUCH_PAGE;
    }
    return Printable.PAGE_EXISTS;
  }
  void print() {
    PrinterJob printJob = PrinterJob.getPrinterJob();
    PageFormat pageFormat = printJob.defaultPage();
    pageFormat.setOrientation(PageFormat.LANDSCAPE);
    pageFormat = printJob.validatePage(pageFormat);
    printJob.setPrintable(this, pageFormat);
    if (printJob.printDialog()) {
      try {
        printJob.print();
      } catch (PrinterException ex) {
        ex.printStackTrace();
      }
    }
  }
  public boolean imageUpdate(Image img, int infoflags, int x, int y,
      int width, int height) {
    return false;
  }
  ImagePrinter(BufferedImage bImage) {
    this.bImage = bImage;
  }
}