package com.langhua.cutFile;
import java.io.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.Graphics;
import java.awt.color.ColorSpace;
import javax.imageio.ImageIO;
import com.langhua.ImageUtils.ImageUtils;
public class ChangeImageSize
{
/** *//**
* 缩放图像
* @param srcImageFile 源图像文件地址
* @param result 缩放后的图像地址
* @param scale 缩放比例
* @param flag 缩放选择:true 放大; false 缩小;
*/
public static void scale(String srcImageFile, String result, int scale, boolean flag)
{
try
{
BufferedImage src = ImageIO.read(new File(srcImageFile)); // 读入文件
int width = src.getWidth(); // 得到源图宽
int height = src.getHeight(); // 得到源图长
if (flag)
{
// 放大
width = width * scale;
height = height * scale;
}
else
{
// 缩小
width = width / scale;
height = height / scale;
}
Image image = src.getScaledInstance(width, height, Image.SCALE_DEFAULT);
BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics g = tag.getGraphics();
g.drawImage(image, 0, 0, null); // 绘制缩小后的图
g.dispose();
ImageIO.write(tag, "JPEG", new File(result));// 输出到文件流
}
catch (IOException e)
{
e.printStackTrace();
}
}
/**
* 图像切割
* @param srcImageFile 源图像地址
* @param descDir 切片目标文件夹
* @param destWidth 目标切片宽度
* @param destHeight 目标切片高度
*/
public static void cut(String srcImageFile, String descDir, int destWidth, int destHeight)
{
try
{
Image img;
ImageFilter cropFilter;
String dir = null;
// 读取源图像
BufferedImage bi = ImageIO.read(new File(srcImageFile));
int srcWidth = bi.getHeight(); // 源图宽度
int srcHeight = bi.getWidth(); // 源图高度
System.out.println("srcWidth:"+srcWidth);
System.out.println("srcHeight:"+srcHeight);
if (srcWidth > destWidth && srcHeight > destHeight)
{
Image image = bi.getScaledInstance(srcWidth, srcHeight, Image.SCALE_DEFAULT);
destWidth = 300; // 切片宽度
destHeight = 300; // 切片高度
int cols = 0; // 切片横向数量
int rows = 0; // 切片纵向数量
// 计算切片的横向和纵向数量
if (srcWidth % destWidth == 0)
{
cols = srcWidth / destWidth;
}
else
{
cols = (int) Math.floor(srcWidth / destWidth) + 1;
}
if (srcHeight % destHeight == 0)
{
rows = srcHeight / destHeight;
}
else
{
rows = (int) Math.floor(srcHeight / destHeight) + 1;
}
// 循环建立切片
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
// 四个参数分别为图像起点坐标和宽高
// 即: CropImageFilter(int x,int y,int width,int height)
cropFilter = new CropImageFilter(j * 300, i * 300, destWidth, destHeight);
img = Toolkit.getDefaultToolkit().createImage(
new FilteredImageSource(image.getSource(), cropFilter));
BufferedImage tag = new BufferedImage(destWidth, destHeight, BufferedImage.TYPE_INT_RGB);
Graphics g = tag.getGraphics();
g.drawImage(img, 0, 0, null); // 绘制缩小后的图
g.dispose();
// 输出为文件
dir = descDir + "cut_image_" + i + "_" + j + ".jpg";
File f = new File(dir);
ImageIO.write(tag, "JPEG",f);
System.out.println(dir);
}
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
/**
* 图像类型转换 GIF->JPG GIF->PNG PNG->JPG PNG->GIF(X)
*/
public static void convert(String source, String result)
{
try
{
File f = new File(source);
f.canRead();
f.canWrite();
BufferedImage src = ImageIO.read(f);
ImageIO.write(src, "JPG", new File(result));
}
catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 彩色转为黑白
* @param source
* @param result
*/
public static void gray(String source, String result)
{
try
{
BufferedImage src = ImageIO.read(new File(source));
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);
ColorConvertOp op = new ColorConvertOp(cs, null);
src = op.filter(src, null);
ImageIO.write(src, "JPEG", new File(result));
}
catch (IOException e)
{
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args)
{
//scale("c:\\test\\456.jpg","C:\\test\\image1.jpg",2,false);
//cut("c:\\1.jpg","C:\\2.jpg",64,64);
//gray("c:\\test\\456.jpg","C:\\test\\image4.jpg");
}
}
优化处理后
package com.langhua.cutFile;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Iterator;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;
import com.langhua.ImageUtils.ImageUtils;
public class CutImage {
// 源图片路径名称如:c:\1.jpg
private String srcpath;
// 剪切图片存放路径名称.如:c:\2.jpg
private String subpath;
// 剪切点x坐标
private int x;
private int y;
// 剪切点宽度
private int width;
private int height;
public CutImage() {
}
public CutImage(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
/**
* 对图片裁剪，并把裁剪完蛋新图片保存 。
*/
public void cut() throws IOException {
FileInputStream is = null;
ImageInputStream iis = null;
try {
// 读取图片文件
is = new FileInputStream(srcpath);
/**
* 返回包含所有当前已注册 ImageReader 的 Iterator，这些 ImageReader 声称能够解码指定格式。
* 参数：formatName - 包含非正式格式名称 . （例如 "jpeg" 或 "tiff"）等 。
*/
Iterator<ImageReader> it = ImageIO
.getImageReadersByFormatName("jpg");
ImageReader reader = it.next();
// 获取图片流
iis = ImageIO.createImageInputStream(is);
/**
* iis:读取源.true:只向前搜索.将它标记为 ‘只向前搜索’。 此设置意味着包含在输入源中的图像将只按顺序读取，可能允许
* reader 避免缓存包含与以前已经读取的图像关联的数据的那些输入部分。
*/
reader.setInput(iis, true);
/**
* <p>
* 描述如何对流进行解码的类
* <p>
* .用于指定如何在输入时从 Java Image I/O 框架的上下文中的流转换一幅图像或一组图像。用于特定图像格式的插件 将从其
* ImageReader 实现的 getDefaultReadParam 方法中返回 ImageReadParam 的实例。
*/
ImageReadParam param = reader.getDefaultReadParam();
/**
* 图片裁剪区域。Rectangle 指定了坐标空间中的一个区域，通过 Rectangle 对象
* 的左上顶点的坐标（x，y）、宽度和高度可以定义这个区域。
*/
Rectangle rect = new Rectangle(x, y, width, height);
// 提供一个 BufferedImage，将其用作解码像素数据的目标。
param.setSourceRegion(rect);
/**
* 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象，并将 它作为一个完整的
* BufferedImage 返回。
*/
BufferedImage bi = reader.read(0, param);
// 保存新图片
ImageIO.write(bi, "jpg", new File(subpath));
} finally {
if (is != null)
is.close();
if (iis != null)
iis.close();
}
}
/**
* 图像切割
*
* @param srcImageFile
* 源图像地址
* @param descDir
* 切片目标文件夹
* @param destWidth
* 目标切片宽度
* @param destHeight
* 目标切片高度 返回一个List,保存九张图片的图片名
*/
public static java.util.List<String> cutImg(String srcImageFile,
String descDir, int destWidth, int destHeight) {
java.util.List<String> list = new java.util.ArrayList<String>(9);
try {
String dir = null;
// 读取源图像
BufferedImage bi = ImageIO.read(new File(srcImageFile));
int srcWidth = bi.getHeight(); // 源图宽度
int srcHeight = bi.getWidth(); // 源图高度
if (srcWidth > destWidth && srcHeight > destHeight) {
destWidth = 300; // 切片宽度
destHeight = 300; // 切片高度
int cols = 0; // 切片横向数量
int rows = 0; // 切片纵向数量
// 计算切片的横向和纵向数量
if (srcWidth % destWidth == 0) {
cols = srcWidth / destWidth;
} else {
cols = (int) Math.floor(srcWidth / destWidth) + 1;
}
if (srcHeight % destHeight == 0) {
rows = srcHeight / destHeight;
} else {
rows = (int) Math.floor(srcHeight / destHeight) + 1;
}
// 循环建立切片
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
CutImage cutImage = new CutImage(j * 300, i * 300, 300,
300);
cutImage.setSrcpath(srcImageFile);
dir = descDir + "cut_image_" + i + "_" + j + ".jpg";
cutImage.setSubpath(dir);
cutImage.cut();
list.add("cut_image_" + i + "_" + j + ".jpg");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public String getSrcpath() {
return srcpath;
}
public void setSrcpath(String srcpath) {
this.srcpath = srcpath;
}
public String getSubpath() {
return subpath;
}
public void setSubpath(String subpath) {
this.subpath = subpath;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
相关推荐
3. **图片分割**：在图像处理中，图片分割是将图像分成多个有意义的区域或对象的过程。这可能涉及到阈值分割、边缘检测（如Canny算法）或区域生长算法。Java库如OpenCV提供了这些功能，使得开发者能够进行复杂的图像...
本项目是基于Java实现的图像分割算法，涉及到的知识点广泛，包括全局阈值分割、Roberts边缘检测以及灰度图像处理和直方图分析。 1. **全局阈值分割**： 全局阈值分割是一种简单的二值化方法，它通过设定一个全局...
3. **切割图片** 使用`getSubimage()`方法从原始图片中获取子图像。假设我们有一个缩放因子，我们可能需要先按比例缩小图片，然后切割。 ```java int scaledWidth = (int) (image.getWidth() * scaleFactor); ...
**Java图片切割** Java作为一个强大的后端开发语言，其丰富的库资源使得图片处理变得非常方便。核心的Java API提供了对图像处理的基本支持，如`java.awt.image.BufferedImage`类可以用于读取、创建和操作图像。在...
在Java编程语言中，处理图片上传并进行剪切是一项常见的任务，尤其在Web应用或图形处理软件中。本文将深入探讨如何使用Java实现这个功能，包括图片上传、预览以及剪切的完整流程。 首先，我们需要理解图片上传的...
综上所述，实现Java OCR图片解析涉及多个步骤，从图像处理到字符识别，再到结果后处理，都需要深入理解相关技术和工具。通过不断优化，我们可以构建出高效、准确的OCR系统，满足各种应用场景的需求。
开发者可以利用`drawImage()`方法和`clip()`函数，设置裁剪区域，然后绘制到新的画布上，从而达到切割图片的效果。同时，Jquery的API使得这些操作更加便捷，减少了代码量，提高了开发效率。 其次，滤镜功能是指在...
### Java 图片处理工具类详解 #### 一、概述 在Java开发中，对图片进行处理是一项常见的需求，比如在Web应用中，我们可能需要对用户上传的图片进行压缩、裁剪、添加水印等操作。`ImageUtils`类正是为了解决这类...
在Java编程语言中，处理图像任务，如截图和切割图片，是常见的需求，尤其是在开发Web应用或社交平台时，例如用户头像的处理。本文将详细介绍如何使用Java进行头像截图和图片切割。 首先，Java提供了`java.awt.image...
Java线程图片切割与处理涉及Java图像处理技术，利用Java的多线程功能来实现图像的并发操作。在Java中，图像处理主要依赖于`java.awt`包中的`Image`类，这是一个抽象类，提供了处理图像的基本方法。通过`Applet`类或`...
通过以上几个示例，我们可以看到 Java 提供了丰富的 API 来处理各种图片操作，包括缩放、切割、格式转换以及彩色转黑白等。这些功能不仅能够满足基本的需求，还提供了很多扩展的可能性，使得 Java 成为了处理图像的...
Java 图片处理解决方案中，ImageMagick 是一个免费的创建、编辑、合成图片的软件，可以实现图片切割、颜色替换、图片缩略图、图片水印等各种效果。ImageMagick 是免费开源软件，支持大多数操作系统，包括 Linux、...
在本项目中，我们主要探讨的是一个基于Java语言的图像处理技术，用于实现对国内车牌号码的自动识别系统。这个源码库提供了完整的程序代码，旨在帮助开发者理解并实现车牌识别的核心算法。以下是对该技术及其相关知识...
Java提供了多种库来处理图片压缩，如Apache Commons Imaging（旧称Sanselan）和ImageMagick的Java绑定。其中，Java Advanced Imaging (JAI) 是Java标准扩展的一部分，它提供了丰富的图像处理功能，包括压缩。 使用...
Java作为一种跨平台的编程语言，提供了丰富的库和工具来支持数字图像处理。本项目聚焦于利用Java实现一系列基本的图像操作，如装载图像、处理灰度图像、提取像素、对数变换、梯度锐化、图像翻转以及直方图均衡化。...
在Java编程中，实现图片上传并添加水印效果是一项常见的任务，这通常涉及到图像处理、图形用户界面（GUI）和文件I/O等多个方面。在这个项目中，我们将关注以下几个关键知识点： 1. **Java图像处理库**：Java标准库...
在Java编程环境中，将多张JPEG格式的图片转换为动态GIF格式是一项常见的图像处理任务。这个Demo展示了如何使用Java的图像处理库来完成这一过程。以下是对这个过程的详细解释： 首先，我们需要一个能够处理GIF格式的...
JavaCV 是一个强大的 Java 库，它为 Java 和 Android ...总之，JavaCV 结合 OpenCV 和 Tesseract 可以帮助我们高效地完成图片中文字的提取和定位，通过优化图像处理和识别流程，可以显著提高 OCR 系统的速度和准确性。
开发者可能编写了算法将图片分割成不同大小的块，根据难度设置调整块的数量和形状，这涉及到图像的切割、保存和随机排列。 4. **算法实现** - 在拼图游戏中，可能存在一些算法来辅助游戏逻辑，如判断拼图是否完成...
本篇文章将围绕"JAVA实现图片二值化"这一主题展开，探讨如何使用Java语言进行图像的二值化处理。 首先，我们需要了解二值化的原理。在图像处理中，每个像素通常由RGB（红绿蓝）三个通道组成，每个通道的值范围在0到...