imageserver.java

来自「OpenMap是一个基于JavaBeansTM的开发工具包。利用OpenMap你」· Java 代码 · 共 1,104 行 · 第 1/3 页

     * 
     * @param iFormatters Hashtable of ImageFormatters
     * @param defaultFormatterKey the key label of the formatter to use for a
     *        default.
     */
    public synchronized void setFormatters(Hashtable iFormatters,
                                           String defaultFormatterKey) {
        imageFormatters = iFormatters;
        formatter = (ImageFormatter) imageFormatters.get(defaultFormatterKey.intern());
    }

    /**
     * Create an ImageFormatter from the contents of a properties object.
     * 
     * @param p Properties used to initialize the Properties.
     * @return default formatter.
     */
    protected ImageFormatter getFormatters(Properties p) {
        String formattersString;
        ImageFormatter iFormatter = null;

        String prefix = PropUtils.getScopedPropertyPrefix(this);
        formattersString = p.getProperty(prefix + ImageFormattersProperty);

        // First, look at the formatters string to get a marker list
        // of available formatters.
        if (formattersString != null) {
            Vector markerNames = PropUtils.parseSpacedMarkers(formattersString);
            Vector formatters = ComponentFactory.create(markerNames, p);

            int size = formatters.size();

            if (imageFormatters == null) {
                imageFormatters = new Hashtable(size);
            }

            for (int i = 0; i < size; i++) {
                ImageFormatter formatter = (ImageFormatter) formatters.get(i);
                imageFormatters.put(formatter.getFormatLabel(), formatter);

                if (i == 0) {
                    iFormatter = formatter;
                }
            }

        } else {
            Debug.message("imageserver",
                    "ImageServer.getFormatters: no formatters specified");
        }

        return iFormatter;
    }

    /**
     * Create an array of Layers from a properties object.
     */
    protected Layer[] getLayers(Properties p) {
        return getLayers(p, (Hashtable) null);
    }

    /**
     * Create an array of Layers from a properties object. Reuse the layer from
     * the hashtable if it's there under the same property name. The Hashtable
     * is kept for an ImageServer that is used buy an ImageMaster or another
     * object that is using different layers for it's image. It will reuse the
     * layers it's already created if the marker names are the same.
     * 
     * @param p properties
     * @param instantiatedLayers a hashtable containing layers, with the prefix
     *        layer name used as the key.
     */
    protected Layer[] getLayers(Properties p, Hashtable instantiatedLayers) {

        String layersValue;
        String prefix = PropUtils.getScopedPropertyPrefix(this);
        layersValue = p.getProperty(prefix + ImageServerLayersProperty);

        if (layersValue == null) {
            // get openmap.layers value
            layersValue = p.getProperty(OpenMapPrefix
                    + ImageServerLayersProperty);

            if (layersValue == null) {
                Debug.error("ImageServer: No property \""
                        + ImageServerLayersProperty
                        + "\" found in ImageServer properties.");
                return new Layer[0];
            }
        }

        Vector layerNames = PropUtils.parseSpacedMarkers(layersValue);

        if (Debug.debugging("imageserver")) {
            Debug.output("OpenMap.getLayers(): " + layerNames);
        }

        int nLayerNames = layerNames.size();
        Vector layers = new Vector(nLayerNames);

        for (int i = 0; i < nLayerNames; i++) {
            String layerName = (String) layerNames.elementAt(i);

            // Check to see if some other ImageServer has used this
            // layer, and reuse it.
            if (instantiatedLayers != null) {
                Layer iLayer = (Layer) instantiatedLayers.get(layerName);
                if (iLayer != null) {

                    // We might want to consider adding this:
                    // iLayer.setProperties(layerName, p);

                    layers.add(iLayer);
                    if (Debug.debugging("imageserver")) {
                        Debug.output("ImageServer: adding instantiated layer /"
                                + layerName + "/");
                    }
                    continue;
                }
            }

            // Brand new layer, so instantiate it.
            String classProperty = layerName + ".class";
            String className = p.getProperty(classProperty);
            if (className == null) {
                Debug.error("Failed to locate property \"" + classProperty
                        + "\"");
                Debug.error("Skipping layer \"" + layerName + "\"");
                continue;
            }

            Object obj = ComponentFactory.create(className, layerName, p);
            if (obj instanceof Layer || obj instanceof PlugIn) {
                Layer l = null;

                if (obj instanceof PlugIn) {
                    PlugIn pi = (PlugIn) obj;
                    PlugInLayer pil = new PlugInLayer();
                    pil.setPlugIn(pi);
                    pil.setName(p.getProperty(PropUtils.getScopedPropertyPrefix(pi)
                            + Layer.PrettyNameProperty));
                    l = pil;
                } else {
                    l = (Layer) obj;
                }

                layers.addElement(l);

                if (instantiatedLayers != null) {
                    instantiatedLayers.put(layerName, l);
                    if (Debug.debugging("imageserver")) {
                        Debug.output("ImageServer: Saving /" + layerName
                                + "/ to instantiated layers hashtable.");
                    }
                }
            }
        }

        int nLayers = layers.size();
        if (nLayers == 0) {
            return new Layer[0];
        } else {
            Layer[] value = new Layer[nLayers];
            layers.copyInto(value);
            return value;
        }
    }

    // protected void finalize() {
    // if (Debug.debugging("gc")) {
    // Debug.output("ImageServer: GC'd.");
    // }
    // }

    /**
     * For convenience, to create an image file based on the contents of a
     * properties file (like an openmap.properties file).
     * 
     * @param prefix The prefix for the ImageServer properties (layers and
     *        formatters) to use in the properties file. If defined, then this
     *        method will look for 'prefix.layers' and prefix.formatters'
     *        properties. If null, then this method will look 'layers' and
     *        'formatters' properties.
     * 
     * @param props The properties to use for defining the layers and plugins to
     *        use on the map image. Standard openmap.properties formats for
     *        layer definitions. See the standard openmap.properties file for
     *        more details on how to define layers and plugins.
     * 
     * @param proj The projection to use for the map. If null, then the
     *        Environment projection properties will be looked for in the
     *        Properties.
     * 
     * @param outputPath The output path for the image file. The image file
     *        should not have an appendix defined. This method will check which
     *        formatter is being used, and will assign one based on the image
     *        format (leave off the ., too).
     * 
     * @return the final path of the written image file, with the chosen
     *         appendix attached.
     */
    public static String createImageFile(String prefix, Properties props,
                                         Projection proj, String outputPath)

    throws MalformedURLException, IOException {

        String appendix = "";

        ImageServer is = new ImageServer(props);

        ImageFormatter formatter = is.getFormatter();
        if (formatter == null) {
            is.setFormatter(new SunJPEGFormatter());
            appendix = ".jpg";
        } else {
            String fileType = formatter.getFormatLabel();
            if (fileType.equals(WMTConstants.IMAGEFORMAT_JPEG)) {
                appendix = ".jpg";
            } else {
                appendix = "." + fileType.toLowerCase();
            }
        }

        Color background = MapBean.DEFAULT_BACKGROUND_COLOR;
        background = (Color) PropUtils.parseColorFromProperties(props,
                Environment.BackgroundColor,
                background);

        is.setBackground(background);

        // Initialize the map projection, scale, center with
        // user prefs or defaults
        if (proj == null) {
            String projName = props.getProperty(Environment.Projection);
            Class projClass = ProjectionFactory.getProjClassForName(projName);

            if (projClass == null) {
                projClass = Mercator.class;
            }

            proj = ProjectionFactory.makeProjection(projClass,
                    PropUtils.floatFromProperties(props,
                    Environment.Latitude,
                            0f),
                    PropUtils.floatFromProperties(props,
                    Environment.Longitude,
                            0f),
                    PropUtils.floatFromProperties(props,
                            Environment.Scale,
                            MapBean.DEFAULT_SCALE),
                    PropUtils.intFromProperties(props,
                            Environment.Width,
                            MapBean.DEFAULT_WIDTH),
                    PropUtils.intFromProperties(props,
                            Environment.Height,
                            MapBean.DEFAULT_HEIGHT));
        }

        if (Debug.debugging("imageserver")) {
            Debug.output("ImageServer: creating image with projection " + proj);
        }

        byte[] imageBytes = is.createImage(proj);
        String finalOutputPath = outputPath + appendix;
        FileOutputStream fos = new FileOutputStream(finalOutputPath);

        fos.write(imageBytes);
        fos.flush();
        fos.close();

        return finalOutputPath;
    }

    /**
     * Paint object used for map backgrounds.
     */
    protected Paint background;

    /**
     * Set the Paint to use for image backgrounds.
     */
    public void setBackground(Paint bg) {
        background = bg;
    }

    /**
     * Get the Paint to use for image backgrounds.
     */
    public Paint getBackground() {
        return background;
    }

    /**
     * The ImageServer class main function will create a map image from a
     * modified openmap.properties file.
     * 
     * <pre>
     *                 
     *                  
     *                   java com.bbn.openmap.image.ImageServer -properties (path
     *                    to properties file) -file (path to output image) 
     *                   
     *                  
     * </pre>
     * 
     * <P>
     * The path to the output image should not have an appendix on it, that will
     * get assigned depending on what image format is used.
     */
    public static void main(String[] argv) {

        Debug.init();
        Debug.put("imageserver");
        Debug.put("image");

        com.bbn.openmap.util.ArgParser ap = new com.bbn.openmap.util.ArgParser("ImageServer");

        ap.add("properties", "The properties file to use for the image.", 1);
        ap.add("file",
                "The output image file, without appendix (default is 'image').",
                1);

        if (!ap.parse(argv)) {
            ap.printUsage();
            System.exit(0);
        }

        String imagefile = "image";
        String arg[];

        arg = ap.getArgValues("file");
        if (arg != null) {
            imagefile = arg[0];
        }

        Properties props = null;
        arg = ap.getArgValues("properties");
        if (arg != null) {
            String ps = arg[0];
            try {
                ProjectionFactory.loadDefaultProjections();
                URL url = PropUtils.getResourceOrFileOrURL(null, ps);
                InputStream inputStream = url.openStream();

                props = new Properties();
                props.load(inputStream);

                Projection proj = null;

                String finalOutputPath = ImageServer.createImageFile(null,
                        props,
                        proj,
                        imagefile);

                if (Debug.debugging("imageserver")) {
                    Debug.output("Writing image file to: " + finalOutputPath);
                }

            } catch (MalformedURLException murle) {
                Debug.error("ImageServer can't find properties file: " + arg[0]);
            } catch (IOException ioe) {
                Debug.error("ImageServer can't write output image: IOException");
            }
        }

        System.exit(0);
    }
}