Java IM4JavaException类代码示例

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
@Test
public void test_2() throws IOException, InterruptedException, IM4JavaException {

	ConvertCmd cvcmd = new ConvertCmd(GM);

	Operation op = new Operation();
	op.addImage(PIC_PATH);
	op.addRawArgs("-sample", "600x600^");
	op.addRawArgs("-gravity", "center");
	op.addRawArgs("-extent", "600x600");
	op.addRawArgs("-quality", "100");
	op.addImage(NEW_PIC_PATH);

	cvcmd.run(op);

}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public byte[] convertWithOptions(InputStream image, String options) {
    String[] optionStrings = options.split(" ");
     
    IMOperation iMOperation = new IMOperation();
    iMOperation.addImage("-");
    iMOperation.addRawArgs(optionStrings);
    iMOperation.addImage(":-");
    
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    
    Pipe pipeIn  = new Pipe(image, null);
    Pipe pipeOut = new Pipe(null, byteArrayOutputStream);
    
    ConvertCmd convertCmd = new ConvertCmd();
    convertCmd.setInputProvider(pipeIn);
    convertCmd.setOutputConsumer(pipeOut);
    
    try {
        convertCmd.run(iMOperation);
    } catch (IOException | InterruptedException | IM4JavaException exception) {
        System.err.println(exception.getMessage());
    }
    
    return byteArrayOutputStream.toByteArray();
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public static byte[] convert2ImageFormat(InputStream image, String format) throws IOException, InterruptedException, IM4JavaException {
    IMOperation iMOperation = new IMOperation();
    iMOperation.addImage("-");
    iMOperation.addImage( format + ":-");
    
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    
    Pipe pipeIn  = new Pipe(image, null);
    Pipe pipeOut = new Pipe(null, byteArrayOutputStream);
    
    ConvertCmd convertCmd = new ConvertCmd();
    convertCmd.setInputProvider(pipeIn);
    convertCmd.setOutputConsumer(pipeOut);
    convertCmd.run(iMOperation);
    
    return byteArrayOutputStream.toByteArray();
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
protected static byte[] resize(InputStream image, Integer maxWidth, Integer maxHeight, String format, boolean keepAspectRatio) throws IOException, InterruptedException, IM4JavaException {
    IMOperation iMOperation = new IMOperation();
    iMOperation.addImage("-");
    
    if(!keepAspectRatio) {
        iMOperation.resize(maxWidth, maxHeight, '!');
    } else {
        iMOperation.resize(maxWidth, maxHeight);
    }
    iMOperation.addImage(format +  ":-");
    
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    
    Pipe pipeIn  = new Pipe(image, null);
    Pipe pipeOut = new Pipe(null, byteArrayOutputStream);
    
    ConvertCmd convertCmd = new ConvertCmd();
    convertCmd.setInputProvider(pipeIn);
    convertCmd.setOutputConsumer(pipeOut);
    convertCmd.run(iMOperation);

    return byteArrayOutputStream.toByteArray();
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
static byte[] crop(InputStream image, int width, int height, int offsetX, int offsetY, String format, int rwidth, int rheight) throws IOException, InterruptedException, IM4JavaException {
    IMOperation iMOperation = new IMOperation();
    iMOperation.addImage("-");
    
    iMOperation.crop(width, height, offsetX, offsetY);
    iMOperation.repage(rwidth, rheight);
    
    iMOperation.addImage(format +  ":-");
    
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    
    Pipe pipeIn  = new Pipe(image, null);
    Pipe pipeOut = new Pipe(null, byteArrayOutputStream);
    
    ConvertCmd convertCmd = new ConvertCmd();
    convertCmd.setInputProvider(pipeIn);
    convertCmd.setOutputConsumer(pipeOut);
    convertCmd.run(iMOperation);
    
    return byteArrayOutputStream.toByteArray();
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
static byte[] rotate(InputStream image, double degrees, String format) throws IOException, InterruptedException, IM4JavaException {
    IMOperation iMOperation = new IMOperation();
    iMOperation.addImage("-");
    iMOperation.rotate(degrees);
    iMOperation.addImage(format +  ":-");
    
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    
    Pipe pipeIn  = new Pipe(image, null);
    Pipe pipeOut = new Pipe(null, byteArrayOutputStream);
    
    ConvertCmd convertCmd = new ConvertCmd();
    convertCmd.setInputProvider(pipeIn);
    convertCmd.setOutputConsumer(pipeOut);
    convertCmd.run(iMOperation);

    return byteArrayOutputStream.toByteArray();
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
/**
 * 根据最大宽度图片压缩
 *
 * @param ori     原图位置
 * @param dest    目标位置
 * @param maxSize 指定压缩后最大边长
 * @return boolean
 * @throws IOException
 */
public static boolean scaleImageByWidth(String ori, String dest, int maxSize) throws IOException, IM4JavaException, InterruptedException {
    String imageProcessor = appContext.getConfig().get("image_processor");
    if (imageProcessor != null && "Thumbnailator".equals(imageProcessor)) {
        ImageUtils.scaleImageByWidth(ori, dest, maxSize);
    }else {
        GMagickUtils.scaleImageByWidth(ori, dest, maxSize);
    }
    return true;
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public static void scale(String ori, String dest, int width, int height) throws IOException, IM4JavaException, InterruptedException {
    String imageProcessor = appContext.getConfig().get("image_processor");
    if (imageProcessor != null && "Thumbnailator".equals(imageProcessor)) {
        ImageUtils.scale(ori, dest, width, height);
    } else{
        GMagickUtils.scale(ori, dest, width,height);
    }
    Thumbnails.of(ori).size(width, height).toFile(dest);
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
/**
 * 图片压缩,各个边按比例压缩
 *
 * @param ori     原图位置
 * @param dest    目标位置
 * @param maxSize 指定压缩后最大边长
 * @return boolean
 * @throws IOException
 */
public static boolean scaleImage(String ori, String dest, int maxSize) throws IOException, IM4JavaException, InterruptedException {
    String imageProcessor = appContext.getConfig().get("image_processor");
    if (imageProcessor != null && "Thumbnailator".equals(imageProcessor)) {
        ImageUtils.scaleImage(ori, dest, maxSize);
    }else {
        GMagickUtils.scaleImage(ori, dest, maxSize);
    }
    return true;
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public static boolean truncateImage(String ori, String dest, int x, int y, int size) throws IOException, InterruptedException, IM4JavaException {
    String imageProcessor = appContext.getConfig().get("image_processor");
    if (imageProcessor != null && "Thumbnailator".equals(imageProcessor)) {
        return ImageUtils.truncateImage(ori, dest, x, y, size);
    }else {
        return GMagickUtils.truncateImage(ori, dest, x, y, size);
    }
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public static boolean truncateImage(String ori, String dest, int width, int height) throws IOException, InterruptedException, IM4JavaException {
    File oriFile = new File(ori);

    validate(oriFile, dest);

    BufferedImage src = ImageIO.read(oriFile); // 读入文件
    int w = src.getWidth();
    int h = src.getHeight();

    int min = Math.min(w, h);
    int side = Math.min(width, height);

    IMOperation op = new IMOperation();
    op.addImage(ori);

    if (w <= width && h <= height) {
        // Don't do anything
    } else if (min < side) {
        op.gravity("center").extent(width, height);
    } else {
        op.resize(width, height, '^').gravity("center").extent(width, height);
    }

    op.addImage(dest);
    ConvertCmd convert = new ConvertCmd(true);
    convert.run(op);
    return true;
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException, IOException, IM4JavaException {
    String ori = "F:\\data\\go\\ns10.jpg";
    ImageUtils.truncateImage(ori, "F:\\data\\go\\boot_640x960.jpg", 640, 960);
    ImageUtils.truncateImage(ori, "F:\\data\\go\\boot_640x1136.jpg", 640, 1136);
    ImageUtils.truncateImage(ori, "F:\\data\\go\\boot_750x1334.jpg", 750, 1334);
    ImageUtils.truncateImage(ori, "F:\\data\\go\\boot_1242x2208.jpg", 1242, 2208);
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
/**
 * The <code>getCompressedImage</code> method is used to compress passed image according to compression type LZW, quality 100 and
 * convert image to monochrome i.e., black and white w.r.t isColoredImage passed.
 * 
 * @param isColoredImage true for colored image and false otherwise
 * @param imageUrl image to be converted
 * @return url of converted image from passed image
 */
private String getCompressedImage(boolean isColoredImage, String imageUrl) {
	String newImageUrl = imageUrl;
	if (null != imageUrl && imageUrl.length() > 0) {
		IMOperation imOperation = new IMOperation();

		// Applying default image quality
		imOperation.quality((double) IMAGE_QUALITY);
		imOperation.type(OPERATION_TYPE);
		if (!isColoredImage) {
			imOperation.monochrome();
		}

		// Apply compression
		imOperation.compress(COMPRESSION_TYPE);
		imOperation.addImage(); // place holder for input file
		imOperation.addImage(); // place holder for output file

		// Converting image
		ConvertCmd convert = new ConvertCmd();
		newImageUrl = imageUrl.substring(0, imageUrl.lastIndexOf(DOTS)) + NEW + TIF_EXTENSION;

		try {
			convert.run(imOperation, new Object[] {imageUrl, newImageUrl});
		} catch (org.im4java.core.CommandException commandException) {
			LOGGER.error("IM4JAVA_TOOLPATH is not set for converting images using image magic: " + commandException.toString());
		} catch (IOException ioException) {
			LOGGER.error("Files not found for converting operation of image magic: " + ioException.toString());
		} catch (InterruptedException interruptedException) {
			LOGGER.error("Conversion operation of image magic interrupted in between: " + interruptedException.toString());
		} catch (IM4JavaException im4JavaException) {
			LOGGER.error("Error occurred while converting images using image magic: " + im4JavaException.toString());
		}
	}
	return newImageUrl;
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
/**
 * 图片水印
 * 
 * @param srcPath
 * @param imageMark
 * @param newPath
 * @throws IOException
 * @throws InterruptedException
 * @throws IM4JavaException
 *             下午2:02:51 Administrator void
 *
 */
public static void addImageWaterMark(String srcPath, String imageMark, String newPath) throws IOException, InterruptedException, IM4JavaException {
	IMOperation op = new IMOperation();

	op.addImage(srcPath);
	op.addImage(imageMark);
	op.gravity("southeast").dissolve(100);
	op.addImage(newPath);

	CompositeCmd cmd = new CompositeCmd(GM);

	cmd.run(op);
}
 

import org.im4java.core.IM4JavaException; //导入依赖的package包/类
public void wrapDeviceFrames(String deviceFrame, String deviceScreenToBeFramed,
                             String framedDeviceScreen)
        throws InterruptedException, IOException, IM4JavaException {
    IMOperation op = new IMOperation();
    op.addImage(deviceFrame);
    op.addImage(deviceScreenToBeFramed);
    op.gravity("center");
    op.composite();
    op.opaque("none");
    op.addImage(framedDeviceScreen);
    ConvertCmd cmd = new ConvertCmd();
    cmd.run(op);
}