Java ImageFormat.IMAGE_FORMAT_BMP属性代码示例

private static ImageFormat getImageFormat(String ext){
    ImageFormat format = ImageFormat.IMAGE_FORMAT_PNG;
    switch(ext.toLowerCase()){
        case "gif":
            format = ImageFormat.IMAGE_FORMAT_GIF;
            break;
        case "jpeg":
        case "jpg":
            format = ImageFormat.IMAGE_FORMAT_JPEG;
            break;
        case "bmp":
            format = ImageFormat.IMAGE_FORMAT_BMP;
            break;
        case "tif":
        case "tiff":
            format = ImageFormat.IMAGE_FORMAT_TIFF;
            break;
    }
    return format;
}
 

public static ImageFormat toSanselanFormat(ImageInfo.Format format) {
	switch (format) {
	case BMP:
		return ImageFormat.IMAGE_FORMAT_BMP;
	case GIF: return ImageFormat.IMAGE_FORMAT_GIF;
	case ICO: return ImageFormat.IMAGE_FORMAT_ICO;
	case IFF: return null;
	case JPEG: return ImageFormat.IMAGE_FORMAT_JPEG;
	case PBM: return ImageFormat.IMAGE_FORMAT_PBM;
	case PPM: return ImageFormat.IMAGE_FORMAT_PPM;
	case PGM: return ImageFormat.IMAGE_FORMAT_PGM;
	case PCX: return null;
	case PNG: return ImageFormat.IMAGE_FORMAT_PNG;
	case PSD: return ImageFormat.IMAGE_FORMAT_PSD;
	case RAS: return null;
	case TIFF: return ImageFormat.IMAGE_FORMAT_TIFF;
	case WEBP: return null;
	default: return null;
	}
}
 

private HttpResponse getOptimizer(HttpResponse response, ImageFormat imageFormat,
    BufferedImage image) throws IOException {

  if (imageFormat == ImageFormat.IMAGE_FORMAT_GIF) {
    // Detecting the existence of the NETSCAPE2.0 extension by string comparison
    // is not exactly clean but is good enough to determine if a GIF is animated
    // Remove once Sanselan returns image count
    if (!response.getResponseAsString().contains("NETSCAPE2.0")) {
      response = new GIFOptimizer(config, response).rewrite(image);
    }
  } else if (imageFormat == ImageFormat.IMAGE_FORMAT_PNG) {
    response = new PNGOptimizer(config, response).rewrite(image);
  } else if (imageFormat == ImageFormat.IMAGE_FORMAT_JPEG) {
    response = new JPEGOptimizer(config, response).rewrite(image);
  } else if (imageFormat == ImageFormat.IMAGE_FORMAT_BMP) {
    response = new BMPOptimizer(config, response).rewrite(image);
  }
  return response;
}
 

protected BufferedImage readImage(ImageFormat imageFormat, HttpResponse response)
    throws ImageReadException, IOException{
  if (imageFormat == ImageFormat.IMAGE_FORMAT_GIF) {
    return readGif(response);
  } else if (imageFormat == ImageFormat.IMAGE_FORMAT_PNG) {
    return readPng(response);
  } else if (imageFormat == ImageFormat.IMAGE_FORMAT_JPEG) {
    return readJpeg(response);
  } else if (imageFormat == ImageFormat.IMAGE_FORMAT_BMP) {
    return readBmp(response);
  } else {
    throw new ImageReadException("Unsupported format " + imageFormat.name);
  }
}
 

protected ImageFormat[] getAcceptedTypes()
{
    return new ImageFormat[] { ImageFormat.IMAGE_FORMAT_BMP, //
    };
}
 

public ImageInfo getImageInfo(ByteSource byteSource, Map params)
        throws ImageReadException, IOException
{
    // make copy of params; we'll clear keys as we consume them.
    params = (params == null) ? new HashMap() : new HashMap(params);

    boolean verbose = ParamMap.getParamBoolean(params, PARAM_KEY_VERBOSE,
            false);

    if (params.containsKey(PARAM_KEY_VERBOSE))
        params.remove(PARAM_KEY_VERBOSE);

    if (params.size() > 0)
    {
        Object firstKey = params.keySet().iterator().next();
        throw new ImageReadException("Unknown parameter: " + firstKey);
    }

    ImageContents ic = readImageContents(byteSource.getInputStream(),
            FormatCompliance.getDefault(), verbose);

    if (ic == null)
        throw new ImageReadException("Couldn't read BMP Data");

    BmpHeaderInfo bhi = ic.bhi;
    byte colorTable[] = ic.colorTable;

    if (bhi == null)
        throw new ImageReadException("BMP: couldn't read header");

    int height = bhi.height;
    int width = bhi.width;

    ArrayList comments = new ArrayList();
    // TODO: comments...

    int bitsPerPixel = bhi.bitsPerPixel;
    ImageFormat format = ImageFormat.IMAGE_FORMAT_BMP;
    String name = "BMP Windows Bitmap";
    String mimeType = "image/x-ms-bmp";
    // we ought to count images, but don't yet.
    int numberOfImages = -1;
    // not accurate ... only reflects first
    boolean isProgressive = false;
    // boolean isProgressive = (fPNGChunkIHDR.InterlaceMethod != 0);
    //
    // pixels per meter
    int physicalWidthDpi = (int) (bhi.hResolution * 1000.0 / 2.54);
    float physicalWidthInch = (float) ((double) width / (double) physicalWidthDpi);
    // int physicalHeightDpi = 72;
    int physicalHeightDpi = (int) (bhi.vResolution * 1000.0 / 2.54);
    float physicalHeightInch = (float) ((double) height / (double) physicalHeightDpi);

    String formatDetails = "Bmp (" + (char) bhi.identifier1
            + (char) bhi.identifier2 + ": "
            + getBmpTypeDescription(bhi.identifier1, bhi.identifier2) + ")";

    boolean isTransparent = false;

    boolean usesPalette = colorTable != null;
    int colorType = ImageInfo.COLOR_TYPE_RGB;
    String compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_RLE;

    ImageInfo result = new ImageInfo(formatDetails, bitsPerPixel, comments,
            format, name, height, mimeType, numberOfImages,
            physicalHeightDpi, physicalHeightInch, physicalWidthDpi,
            physicalWidthInch, width, isProgressive, isTransparent,
            usesPalette, colorType, compressionAlgorithm);

    return result;
}