root/trunk/BuildingMap.java

/**
 * BuildingMap.java
 *
 * This is a map which just shows one floor of a building.
 */

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.*;
import java.net.*;

public class BuildingMap extends BackgroundMap implements Serializable {
        //static final long serialVersionUID = 0L;


        /**
         * Creates a map which has a grid of rows x cols which covers an area
         * of the world specified by realRectangle (in real coordinates).
         */

        public BuildingMap(
                int floor,
                int height,
                int width,
                AffineTransform imageToReal,
                String rootUri,
                String treeUri,
                String extension)
        {
                this.floor = floor;
                this.height = height;
                this.width = width;
                setImageToReal(imageToReal);
                setRootUri(rootUri);
                setTreeUri(treeUri);
                setExtension(extension);
        }

        public void setImageToReal(AffineTransform imageToReal) {
                this.imageToReal = imageToReal;
                try {
                        realToImage = imageToReal.createInverse();
                } catch(NoninvertibleTransformException e) {
                        throw new IllegalArgumentException("Couldn't invert the transform");
                }
        }

        public AffineTransform getImageToReal() { return imageToReal; }
        public AffineTransform getRealToImage() { return realToImage; }

        public Rectangle2D getRealBoundingRectangle() {
                return imageToReal
                        .createTransformedShape(new Rectangle(0, 0, width, height))
                        .getBounds2D();
        };

        /**
         * Paints the map onto the given Graphics2D object, using realToScreen
         * to transform the real coordinates the map knows about to screen
         * coordinates it uses to draw on the Graphics2D.
         */
        public void paint(Graphics2D g, AffineTransform realToScreen, ImageObserver observer) {
                
                if(image == null) image = getImage(floor);
                
                // image (imageToReal)-> real (realToScreen)-> screen
                AffineTransform imageToScreen = new AffineTransform(realToScreen);
                imageToScreen.concatenate(imageToReal);

                // ok, draw it.
                g.drawImage(image, imageToScreen, observer);
        }

        private Image getImage(int floor) {
                System.out.println("BuildingMap requesting image " + getUrl(floor));
                return Toolkit.getDefaultToolkit().getImage(getUrl(floor));
        }

        /**
         * This returns the filename (no path components) for an image file 
         * for the given floor.  It will be concatenated with
         * the base and tree URIs.  It can be overridden for flexibility, though
         * it may be easier in the long run not to.
         *
         * Note that it cannot be declared as static, because then even if
         * subclasses override it, the subclass's version won't be run because
         * the call will be resolved at compile time to this implementation.
         */

        public String getFilename(int floor) {
                return new String("floor_" + floor + "." + extension);
        }

        public URL getUrl(int floor) {
                try {
                        if(rootUri == null) rootUri = (new File(".")).toURI();
                        if(treeUri == null) treeUri = new URI("");
                        return rootUri.resolve(treeUri).resolve(new URI(getFilename(floor))).toURL();
                } catch(Exception e) {
                        throw new RuntimeException(e);
                }
        }

        public URI getRootUri() { return rootUri; }
        public void setRootUri(String rootUri) {
                if(rootUri == null || rootUri.equals("")) {
                        this.rootUri = null;
                        return;
                }                       
                try {
                        this.rootUri = new URI(rootUri);
                } catch(URISyntaxException e) {
                        throw new IllegalArgumentException("malformed URI " + rootUri);
                }
        }

        public URI getTreeUri() { return treeUri; }
        public void setTreeUri(String treeUri) {
                try {
                        this.treeUri = new URI(treeUri);
                } catch(URISyntaxException e) {
                        throw new IllegalArgumentException("malformed URI " + treeUri);
                }
        }

        public String getExtension() { return extension; }
        public void setExtension(String extension) {
                this.extension = extension;
        }

        private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
                in.defaultReadObject();
        }

        // in pixels per meter
        public double getPixelForPixelScale() {
                Rectangle2D boundingRect = getRealBoundingRectangle();
                double xScale = width / boundingRect.getWidth();
                double yScale = height / boundingRect.getHeight();
                return (xScale + yScale) / 2.0;
        }
        
        public int getFloor() { return floor; }
        public void setFloor(int floor) {
                this.floor = floor;
                image = null;
        }

        /**
         * Where we get our pictures from.  This can be blank for the filesystem,
         * or http://example.com/pathways/, for example.  Essentially the
         * document root.
         */
        private transient URI rootUri;

        /**
         * The location in the tree our pictures come from.  For example,
         * images/uiucmap/.  This is so that a map knows were to get its
         * pictures, but we can move the directory tree between servers without
         * changing code.
         */
        private URI treeUri;

        /**
         * The extension for the image files
         */
        private String extension;

        // these must be kept inverse of each other
        private AffineTransform imageToReal;
        private AffineTransform realToImage;

        /// size in pixels of the map
        private int height, width;
        
        private int floor;

        /// image for the current floor
        private transient Image image;
}