imagemerger.java

esri的ArcGIS Server超级学习模板程序（for java）

    /**
    * convert an image to a (TIFF,PNG8,PNG,JPEG)
    */
    public void convertImage(
        byte[] inputFile,
        String outputFile,
        String type
    ) throws java.io.IOException, java.io.FileNotFoundException, Exception {
        javax.media.jai.PlanarImage src = readSourceImage(inputFile);
        src = checkImageBands(src);
        saveImage(src,outputFile,type, true);
    }

    /*****************************************************************************************************
    ******************************** private methods *****************************************************
    *****************************************************************************************************/

    /**
    * read the images from file system or URL
    */
    private javax.media.jai.PlanarImage readSourceImage(
       byte[] imageData
    ) throws java.net.MalformedURLException, java.io.IOException {
        javax.media.jai.PlanarImage src = null;
		com.sun.media.jai.codec.ByteArraySeekableStream byteStream = new 
			com.sun.media.jai.codec.ByteArraySeekableStream(imageData);
		src = javax.media.jai.JAI.create("stream", byteStream);
        return src;
    }

    /**
    * get an image with only the alpha values
    */
    private javax.media.jai.PlanarImage calculateAlphaImage(
        javax.media.jai.PlanarImage src,
        double transparency,
        String imageExtension,
        boolean bottom
    ) throws Exception {

        javax.media.jai.PlanarImage afa = null;
        if (src.getNumBands() == 4) {
            // get the existing alpha band only
            double[][] alphaMatrix = {{ .000D, .000D, .000D, 1.0D, 0.0D }};
            if (bottom)
            {
              alphaMatrix[0][0] = 255.0D;
              alphaMatrix[0][1] = 255.0D;
              alphaMatrix[0][2] = 255.0D;
              alphaMatrix[0][3] = 1.0D;
              alphaMatrix[0][4] = 255.0D;
            }
            java.awt.image.renderable.ParameterBlock pb = new java.awt.image.renderable.ParameterBlock();
            pb.addSource(src);
            pb.add(alphaMatrix);
            javax.media.jai.PlanarImage afaSrc = javax.media.jai.JAI.create("bandcombine", pb, null);
            // now add the transparency
            double[] constants = new double[1];
            constants[0] = transparency; // this image has only one band
            pb = new java.awt.image.renderable.ParameterBlock();
            pb.addSource(afaSrc);
            pb.add(constants);
            afa = javax.media.jai.JAI.create("multiplyconst", pb, null);

        } else if (src.getNumBands() <= 3) {
            // define alpha value for image on top
            int alpha = (int)(transparency*255);
            Byte [] bandValues = new Byte[3];
            bandValues[0] = new Byte((byte)alpha);
            bandValues[1] = new Byte((byte)alpha);
            bandValues[2] = new Byte((byte)alpha);
            java.awt.image.renderable.ParameterBlock pb = new java.awt.image.renderable.ParameterBlock();
            pb.add((float)src.getWidth()); // needs a graphic display
            pb.add((float)src.getHeight());
            pb.add(bandValues);
            afa = javax.media.jai.JAI.create("constant", pb, null);

//        } else {
//            throw new Exception("only images with 3 or 4 bands are supported");
        }

        return afa;
    }

    /**
    * get an image with only the 3 color bands
    */
    private javax.media.jai.PlanarImage checkImageBands(
        javax.media.jai.PlanarImage src
    ) {

        javax.media.jai.PlanarImage src3Bands = src;
        if (src.getNumBands() > 3) {

            // source image with only 3 bands
            double[][] matrix = {{ 1.0D, 0.0D, 0.0D, 0.0D, 0.0D },
                                 { 0.0D, 1.0D, 0.0D, 0.0D, 0.0D },
                                 { 0.0D, 0.0D, 1.0D, 0.0D, 0.0D }};
            java.awt.image.renderable.ParameterBlock pb = new java.awt.image.renderable.ParameterBlock();
            pb.addSource(src);
            pb.add(matrix);
            src3Bands = javax.media.jai.JAI.create("bandcombine", pb, null);
        }

        return src3Bands;
    }

    /**
    * if user didn't supply transparency factors, then set default values
    */
    private double[] checkTransparencyFactors(
        double[] transparencyFactors,
        int length
    ) {
        if (transparencyFactors == null) {
            transparencyFactors = new double[length];
            transparencyFactors[0] = 1.0;
            for (int i = 1; i < length; i++)
                transparencyFactors[i] = 0.5;
        }
        return transparencyFactors;
    }

    static int[][] getPixels(java.awt.Image image) throws java.io.IOException {
        int w = image.getWidth(null);
        int h = image.getHeight(null);
        int pix[] = new int[w * h];
        java.awt.image.PixelGrabber grabber = new java.awt.image.PixelGrabber(image, 0, 0, w, h, pix, 0, w);

        try {
            if (grabber.grabPixels() != true) {
                throw new java.io.IOException("Grabber returned false: " +
                                      grabber.status());
            }
        } catch (java.lang.InterruptedException e) {
			logger.warn("Unable to get pixels", e);
		}

        int pixels[][] = new int[w][h];
        for (int x = w; x-- > 0; ) {
            for (int y = h; y-- > 0; ) {
                pixels[x][y] = pix[y * w + x];
            }
        }

        return pixels;
    }

    /**
    * save image to file
    */
    private void saveImage(
        javax.media.jai.PlanarImage src,
        String fileName,
        String type,
        boolean reduceBand
    ) throws java.io.FileNotFoundException, java.io.IOException {

        if (type.equalsIgnoreCase("PNG8")) {
            type = "PNG";
            // convert 24 bit to 8 bit (3 band to 1 band)
            java.awt.image.renderable.ParameterBlock pb = new java.awt.image.renderable.ParameterBlock();

            javax.media.jai.ColorCube colorMap = javax.media.jai.ColorCube.BYTE_496;
            javax.media.jai.KernelJAI[] ditherMask = javax.media.jai.KernelJAI.DITHER_MASK_443;
            pb.addSource(src).add(colorMap).add(ditherMask);
            src = javax.media.jai.JAI.create("ordereddither", pb);
/*
            pb.addSource(src);
            pb.add(javax.media.jai.ColorCube.BYTE_496);
            pb.add(kernel);
            src = (javax.media.jai.PlanarImage)javax.media.jai.JAI.create("errordiffusion", pb, null);
*/
        } else if (type.equalsIgnoreCase("PNG") && src.getNumBands() >= 3) {
            com.sun.media.jai.codec.PNGEncodeParam.RGB param = new com.sun.media.jai.codec.PNGEncodeParam.RGB();
            int[] rgb = new int[3];
            rgb[0] = rgb[1] = rgb[2] = 255;
            param.setTransparentRGB(rgb);
            javax.media.jai.JAI.create("filestore", src, fileName, type, param);
            return;
        } else if (type.equalsIgnoreCase("JPG")) {
            type = "JPEG";
        } else if (type.equalsIgnoreCase("TIF")) {
            type = "TIFF";
        } else if (type.equalsIgnoreCase("GIF")) {
			int pos = fileName.indexOf(".GIF");
			String pngfile = fileName.substring(0, pos);
			pngfile = pngfile + ".PNG";
			if (src.getNumBands() >= 3){
				if (src.getNumBands() == 3){
					java.awt.image.renderable.ParameterBlock pb = new java.awt.image.renderable.ParameterBlock();

					javax.media.jai.ColorCube colorMap = javax.media.jai.ColorCube.BYTE_496;
					javax.media.jai.KernelJAI[] ditherMask = javax.media.jai.KernelJAI.DITHER_MASK_443;
					pb.addSource(src).add(colorMap).add(ditherMask);
					src = javax.media.jai.JAI.create("ordereddither", pb);
					javax.media.jai.JAI.create("filestore", src, pngfile, "PNG", null);
				}
				else{
					src = checkImageBands(src);
					com.sun.media.jai.codec.PNGEncodeParam.RGB param = new com.sun.media.jai.codec.PNGEncodeParam.RGB();
					int[] rgb = new int[3];
					rgb[0] = rgb[1] = rgb[2] = 255;
					param.setTransparentRGB(rgb);
					javax.media.jai.JAI.create("filestore", src, pngfile, "PNG", param);
				}
			}else
				javax.media.jai.JAI.create("filestore", src, pngfile, "PNG", null);

			javax.media.jai.PlanarImage planar = javax.media.jai.JAI.create("FileLoad", pngfile);
			java.awt.image.BufferedImage bufImg = planar.getAsBufferedImage();
			try{
				GifEncoder encoder = new GifEncoder(bufImg);
				GifEncoder.writeFile(bufImg, new java.io.File(fileName));
				encoder = null;
			}catch(Exception e){
				logger.warn("Unable to encode gif", e);
			}
			return;
//            setImage(src.getAsBufferedImage(), fileName);
        } else if (type.equalsIgnoreCase("TIFF") || type.equalsIgnoreCase("BMP") ||
			type.equalsIgnoreCase("JPEG") || type.equalsIgnoreCase("PNG") || type.equalsIgnoreCase("PNM")) {
            // leave it
        } else  {
            type = "JPEG";
        }

        javax.media.jai.JAI.create("filestore", src, fileName, type, null);
    }

    /**
    * merge images using the composite operation
    */
    private javax.media.jai.PlanarImage mergeImages(
        javax.media.jai.PlanarImage srcTop,
        javax.media.jai.PlanarImage srcBottom,
        javax.media.jai.PlanarImage afaTop,
        javax.media.jai.PlanarImage afaBottom
    ) {
        // first image in parameterBlock needs to be the image on top
        java.awt.image.renderable.ParameterBlock pb = new java.awt.image.renderable.ParameterBlock();
        pb.addSource(srcTop);
        pb.addSource(srcBottom);
        pb.add(afaTop);
        pb.add(afaBottom);
        pb.add(new Boolean(false));
        pb.add(javax.media.jai.operator.CompositeDescriptor.NO_DESTINATION_ALPHA);
        return javax.media.jai.JAI.create("composite", pb, null);
    }

    private void checkImageList(String[] imageList, double[] transFactors)
    {
      int cnt=0;

      int[] idx;
      idx = new int[imageList.length];
      for (int i=0; i<imageList.length; i++)
      {
        long curtime = System.currentTimeMillis();
        while (!checkImage(imageList[i]) && (System.currentTimeMillis() - curtime) < 15000)
            while ((System.currentTimeMillis() - curtime) < 2000) {}
        if (!checkImage(imageList[i]))
        {
          idx[cnt] = i;
          cnt++;
        }
      }
      String[] newStrings = new String[imageList.length - cnt];
      double[] newFactors = new double[imageList.length - cnt];
      int ncnt=0;
      boolean fnd=false;
      for (int i=0; i<imageList.length; i++)
      {
        fnd=false;
        for (int j=0; j<cnt; j++)
        {
          if (i == idx[j])
          {
            fnd=true;
            break;
          }
        }
        if (!fnd)
        {
          newStrings[ncnt] = imageList[i];
          newFactors[ncnt] = transFactors[i];
          ncnt++;
        }
      }
      _imageList = newStrings;
      _transFactors = newFactors;

    }

    private boolean checkImage(String fileName){
      javax.media.jai.PlanarImage src = null;
      try{
          if (fileName.startsWith("http://") || fileName.startsWith("https://")){
            java.net.URL imageUrl = new java.net.URL(fileName);
            java.net.URLConnection con = imageUrl.openConnection();
            java.io.InputStream imageStream = com.sun.media.jai.codec.SeekableStream.wrapInputStream(con.getInputStream(),true);
            src = javax.media.jai.JAI.create("stream", imageStream);
          }
          else
            src = javax.media.jai.JAI.create("FileLoad", fileName);
          return true;
      }
      catch(java.net.MalformedURLException e){
		  logger.warn("Unable to check image:MalformedURLException", e);
	  }
      catch(java.io.IOException e){
		  logger.warn("Unable to check image:IOException", e);
      }      
      return false;
    }

}