crfpclient.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

                lrlon,
                p,
                chartSeries);

        int size = results.size();

        if (size == 0) {
            return 0f;
        }

        // Now interpret the results and figure out the real total
        // percentage coverage for the chartSeries. First need to
        // figure out the current size of the subframes. Then create
        // a boolean matrix of those subframes that let you figure out
        // how many of them are available. Calculate the percentage
        // off that.
        //int pZone = p.getZone();
        int i, x, y;

        double frameLatInterval = Double.MAX_VALUE;
        double frameLonInterval = Double.MAX_VALUE;
        RpfCoverageBox rcb;
        for (i = 0; i < size; i++) {
            rcb = (RpfCoverageBox) results.elementAt(i);
            if (rcb.subframeLatInterval < frameLatInterval) {
                frameLatInterval = rcb.subframeLatInterval;
            }
            if (rcb.subframeLonInterval < frameLonInterval) {
                frameLonInterval = rcb.subframeLonInterval;
            }
        }

        if (frameLatInterval == Double.MAX_VALUE
                || frameLonInterval == Double.MAX_VALUE) {
            return 0.0f;
        }

        int numHFrames = (int) Math.ceil((lrlon - ullon) / frameLonInterval);
        int numVFrames = (int) Math.ceil((ullat - lrlat) / frameLatInterval);

        boolean[][] coverage = new boolean[numHFrames][numVFrames];
        for (i = 0; i < size; i++) {

            rcb = (RpfCoverageBox) results.elementAt(i);
            if (rcb.percentCoverage == 100) {
                return 1.0f;
            }

            for (y = 0; y < numVFrames; y++) {
                for (x = 0; x < numHFrames; x++) {
                    // degree location of indexs
                    float yFrameLoc = (float) (lrlat + (y * frameLatInterval));
                    float xFrameLoc = (float) (ullon + (x * frameLonInterval));
                    if (coverage[x][y] == false) {
                        if (rcb.within(yFrameLoc, xFrameLoc)) {
                            coverage[x][y] = true;
                        }
                    }
                }
            }
        }

        float count = 0;

        for (y = 0; y < numVFrames; y++) {
            for (x = 0; x < numHFrames; x++) {
                if (coverage[x][y] == true) {
                    //                  System.out.print("X");
                    count++;
                } else {
                    //                  System.out.print(".");
                }
            }
            //          Debug.output("");
        }

        return count / (float) (numHFrames * numVFrames);
    }

    /**
     * Convert CRFPCoverageBox[] to vector of RpfCoverageBox.
     * 
     * @param boxes CRFPCoverageBox[].
     * @return java.util.Vector
     */
    protected Vector translateCRFPCoverageBoxes(CRFPCoverageBox[] boxes) {

        Vector vector = new Vector();
        for (int i = 0; i < boxes.length; i++) {
            CRFPCoverageBox box = boxes[i];
            RpfCoverageBox rcb = new RpfCoverageBox();
            rcb.nw_lat = box.nw_lat;
            rcb.nw_lon = box.nw_lon;
            rcb.se_lat = box.se_lat;
            rcb.se_lon = box.se_lon;
            rcb.subframeLatInterval = box.subframeLatInterval;
            rcb.subframeLonInterval = box.subframeLonInterval;
            rcb.chartCode = box.chartCode;
            rcb.startIndexes = new Point(box.startIndexes.x, box.startIndexes.y);
            rcb.endIndexes = new Point(box.endIndexes.x, box.endIndexes.y);
            rcb.tocNumber = (int) box.tocNumber;
            rcb.entryNumber = (int) box.entryNumber;
            rcb.scale = box.scale;
            rcb.percentCoverage = box.percentCoverage;
            rcb.zone = box.zone;
            vector.addElement(rcb);
        }
        return vector;
    }

    /**
     * Given the indexes to a certain RpfTocEntry within a certain
     * A.TOC, find the frame/subframe data, decompress it, and return
     * image pixels. The tocNumber and entryNumber are given within
     * the RpfCoverageBox received from a getCoverage call. With the
     * CORBA implementation, we are assuming that the byte array is an
     * encoded jpeg image.
     * 
     * @param tocNumber the toc id for a RpfTocHandler for a
     *        particular frame provider.
     * @param entryNumber the RpfTocEntry id for a RpfTocHandler for a
     *        particular frame provider.
     * @param x the horizontal subframe index, from the left side of a
     *        boundary rectangle of the entry.
     * @param y the vertical subframe index, from the top side of a
     *        boundary rectangle of the entry.
     * @see #getCoverage(float ullat, float ullon, float lrlat, float
     *      lrlon, CADRG p)
     * @return integer pixel data.
     */
    public int[] getSubframeData(int tocNumber, int entryNumber, int x, int y) {
        Server serv = getServer();
        if (serv == null)
            return null;
        byte[] jpegData;
        Debug.message("crfp", "CRFPClient: getting subframe data from server.");

        try {
            jpegData = serv.getSubframeData((short) tocNumber,
                    (short) entryNumber,
                    (short) x,
                    (short) y,
                    jpegQuality,
                    clientID);
            if (Debug.debugging("crfpdetail")) {
                Debug.output("CRFPClient: got subframe data length "
                        + jpegData.length);
            }

            // Need to check for the corba rendition of an allowable
            // null image (length 0)
            if (jpegData.length == 0)
                return null;

            ByteArrayInputStream bais = new ByteArrayInputStream(jpegData);
            JPEGImageDecoder jid = JPEGCodec.createJPEGDecoder(bais);

            BufferedImage bi = jid.decodeAsBufferedImage();
            int height = bi.getHeight();
            int width = bi.getWidth();
            int[] pixels = bi.getRGB(0, 0, width, height, null, 0, width);
            return pixels;
        } catch (IOException ioe) {
            Debug.error("CRFPClient: IOException decoding jpeg bytes");
        } catch (org.omg.CORBA.SystemException e) {
            handleCORBAError(e);
        }
        return null;
    }

    public RpfIndexedImageData getRawSubframeData(int tocNumber,
                                                  int entryNumber, int x, int y) {
        Server serv = getServer();
        if (serv == null)
            return null;

        Debug.message("crfp",
                "CRFPClient: getting raw subframe data from server.");

        try {
            RawImage ri = serv.getRawSubframeData((short) tocNumber,
                    (short) entryNumber,
                    (short) x,
                    (short) y,
                    clientID);

            // Need to check for the corba rendition of an allowable
            // null image (length 0)
            if (ri.imagedata.length == 0 || ri.colortable.length == 0) {
                return null;
            }

            RpfIndexedImageData riid = new RpfIndexedImageData();
            riid.imageData = ri.imagedata;
            riid.colortable = new OMColor[ri.colortable.length];

            for (int i = 0; i < riid.colortable.length; i++) {
                riid.colortable[i] = new OMColor(ri.colortable[i]);
            }
            return riid;

        } catch (org.omg.CORBA.SystemException e) {
            handleCORBAError(e);
            return null;
        }
    }

    /**
     * Given the indexes to a certain RpfTocEntry within a certain
     * A.TOC, find the frame and return the attribute information. The
     * tocNumber and entryNumber are given within the RpfCoverageBox
     * received from a getCoverage call.
     * 
     * @param tocNumber the toc id for a RpfTocHandler for a
     *        particular frame provider.
     * @param entryNumber the RpfTocEntry id for a RpfTocHandler for a
     *        particular frame provider.
     * @param x the horizontal subframe index, from the left side of a
     *        boundary rectangle of the entry.
     * @param y the vertical subframe index, from the top side of a
     *        boundary rectangle of the entry.
     * @see #getCoverage(float ullat, float ullon, float lrlat, float
     *      lrlon, CADRG p)
     * @return string.
     */
    public String getSubframeAttributes(int tocNumber, int entryNumber, int x,
                                        int y) {

        Server serv = getServer();
        if (serv == null)
            return "";

        Debug.message("crfp",
                "CRFPClient: getting subframe attributes from server.");
        try {
            return serv.getSubframeAttributes((short) tocNumber,
                    (short) entryNumber,
                    (short) x,
                    (short) y,
                    clientID);
        } catch (org.omg.CORBA.SystemException e) {
            handleCORBAError(e);
        }
        return "";
    }

    //////////////// Corba management

    /**
     * get the server proxy.
     * 
     * @return Server server or null if error.
     *  
     */
    public Server getServer() {
        if (server == null)
            initServer();
        return server;
    }

    /**
     * bind to the server.
     *  
     */
    private void initServer() {
        String ior = null;
        org.omg.CORBA.Object object = null;

        com.bbn.openmap.util.corba.CORBASupport cs = new com.bbn.openmap.util.corba.CORBASupport();

        try {
            object = cs.readIOR(iorURL);
            server = ServerHelper.narrow(object);
        } catch (IOException ioe) {
            if (Debug.debugging("crfp")) {
                Debug.output("CRFPClient.initServer() IO Exception with ior: "
                        + iorURL);
            }
            server = null;
            return;
        }

        if (server == null) {
            object = cs.resolveName(naming);

            if (object != null) {
                server = ServerHelper.narrow(object);
                if (Debug.debugging("crfp")) {
                    Debug.output("Have a RPF server:");
                    Debug.output("*** Server: is a "
                            + server.getClass().getName() + "\n" + server);
                }
            }
        }

        if (Debug.debugging("crfp")) {
            if (server == null) {
                Debug.error("CRFPClient.initServer: null server!\n  IOR=" + ior
                        + "\n  Name = " + naming);
            } else {
                Debug.output("CRFPClient: server is golden.");
            }
        }
    }

    protected void handleCORBAError(org.omg.CORBA.SystemException e) {
        // don't freak out if we were only interrupted...
        if (e.toString().indexOf("InterruptedIOException") != -1) {
            Debug.error("CRFPClient server communication interrupted!");
        } else {
            Debug.error("CRFPClient caught CORBA exception: " + e + "\n"
                    + "CRFPClient Exception class: " + e.getClass().getName()
                    + "\n" + e.getMessage());
            e.printStackTrace();
        }

        server = null;// dontcha just love CORBA? reinit later
    }

}