`
lzj0470
  • 浏览: 1277354 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

java 程序中如何分割图片和对图片其他操作

    博客分类：
  • java
JavaIISCC++C# 
阅读更多 
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);   
                        ImageUtils.pressText("水印",dir,"宋体",1,1,25,10,10);   
                    }      
                }      
            }      
        }      
        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");   
                        ImageUtils.pressText("水印", dir, "宋体", 1, 1, 25, 10, 10);   
                    }   
                }   
            }   
        } 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;   
    }   
}

 

分享到：
| 心中得笨笨
评论
1 楼 zuo_huai 2010-07-17  
能不能给出完整代码，那个ImageUtil 也给出来吧
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java 图片 切割 保存

    在Java编程语言中，图片处理是一项常见的任务，其中包括图片的切割和保存。在这个场景下，我们需要实现的功能包括根据指定的缩放比例对图片进行切割，并将切割后的图片保存到本地。下面将详细介绍如何使用Java来完成...

    java 水印 图像处理 图片分割 裁剪 缩放

    Java图像处理技术是Java开发中的一个重要领域，涵盖了多种操作，如添加水印、图像分割、裁剪和缩放。在本项目中，这些功能被整合到一个完整的程序中，并通过单元测试进行了验证，确保了各个功能的正确性。此外，程序...

    图片缩放、压缩技术java实现

    在IT行业中，图片处理是一项非常常见的任务，尤其是在网站开发、移动应用、数据分析等领域。...在实际操作中，你还可以探索更多高级功能，如色彩空间转换、滤波和增强等，以进一步优化你的图片处理流程。

    Java动画程序，图片分割成小块再汇聚

    这个项目名为"Java动画程序，图片分割成小块再汇聚"，它涉及到多个关键的Java编程概念和技术，包括图像处理、多线程以及动画原理。 1. **图像处理**： 在这个项目中，一张图片被分割成多个小块。这通常是通过读取...

    生日祝福java程序代码

    这个名为"生日祝福java程序代码"的压缩包显然包含了多个功能模块，旨在为生日庆祝活动增添乐趣。以下是该程序可能包含的关键知识点和组件的详细说明： 1. **Java编程基础**：首先，整个项目基于Java语言编写，这...

    java源码包---java 源码 大量 实例

    　util实现Java图片水印添加功能，有添加图片水印和文字水印，可以设置水印位置，透明度、设置对线段锯齿状边缘处理、水印图片的路径，水印一般格式是gif，png,这种图片可以设置透明度、水印旋转等，可以参考代码...

    java版的随机点名程序（可以加图片的）

    2. **字符串处理**：读取的姓名通常是以文本形式存在，因此需要对字符串进行分割和处理，以便将每个姓名独立出来。 3. **数据结构**：为了存储和操作这些姓名，开发者可能会选择使用ArrayList、LinkedList或者其他...

    拼图游戏Java程序所写

    【标题】：“拼图游戏Java程序所写” 这个标题揭示了我们的讨论焦点是一个用Java编程语言编写的拼图游戏。拼图游戏是一种智力挑战活动，通常涉及到将一幅图像分割成多个部分，然后重新排列这些部分以恢复原始图像。...

    200多个自己编的java程序

    标题中的“200多个自己编的java程序”揭示了这是一个包含了大量个人编写的Java程序的集合，适合初学者学习和参考。这些程序涵盖了各种不同的功能和应用，可以帮助初学者了解Java编程的基础以及如何实现实际的功能。 ...

    Java 拼图 自由拖动拼图片 随机形状

    可能使用了分治法或者矩阵操作来处理图像切割，同时可能还需要一种有效的数据结构（如链表或数组）来存储和操作拼图块的位置信息。 总的来说，这个Java拼图应用融合了图像处理、GUI设计、事件驱动编程、音频播放和...

    java编写的拼图程序

    1. 图像处理：在这个Java程序中，原始图片被分割成多个小块，这可能使用了Java的`BufferedImage`类和图像处理库，如Java Advanced Imaging (JAI) 或 Apache Commons Imaging。开发者可能通过计算图像的宽度和高度来...

    java抠图程序

    在IT行业中，图像处理是...通过学习和实践，你可以创建自己的Java抠图程序，将任何白色背景的图片无缝地融合到各种背景之中。如果你对这个主题有进一步的兴趣，建议深入研究上述提到的库以及相关的图像处理理论和算法。

    完整的java拼图程序

    它使用JVM（Java虚拟机）来运行，这使得Java程序能在任何支持JVM的设备上运行，实现了“一次编写，到处运行”的理念。 拼图游戏是一种常见的益智游戏，通常涉及将一个图像分割成多个部分，然后玩家需要通过旋转和...

    java PrinterJob 操作打印机

    在Java程序中，我们可以通过`PrinterJob`类来实现图片的打印、打印预览以及多页打印等操作。下面将详细阐述这些知识点。 ### 图片的打印 在Java中，打印图片通常涉及到`Graphics2D`接口，`Image`类以及`PrinterJob...

    java程序编辑实现的拼图游戏

    APPLET是Java早期版本中用于在Web浏览器中运行的小型Java程序。它嵌入在HTML页面中，允许用户与网页进行交互。然而，由于安全性和性能限制，APPLET在现代Web开发中已不再使用，已被JApplet和Java Web Start等技术...

    java线程图片切割与处理

    - 在Java程序中，可以先下载完整图像，然后将其分割成多个单元格，例如5行4列，总共20个单元。其中，第20个单元可以设为空白，便于用户交互拼图。 - 使用`Cell`类存储每个图像单元，包含图像对象`img`，以及起始...

    java源码包3

    　util实现Java图片水印添加功能，有添加图片水印和文字水印，可以设置水印位置，透明度、设置对线段锯齿状边缘处理、水印图片的路径，水印一般格式是gif，png,这种图片可以设置透明度、水印旋转等，可以参考代码...

    百度地图瓦片工具(JAVA完整工程)

    在GIS（地理信息系统）领域，地图瓦片是一种将大尺寸地图分割成小块图片的技术，通常用于提高网络地图服务的加载速度和显示效率。这个JAVA工程提供了一整套解决方案，可以帮助用户生成、裁剪、管理和使用百度地图的...

    java源码包2

    　util实现Java图片水印添加功能，有添加图片水印和文字水印，可以设置水印位置，透明度、设置对线段锯齿状边缘处理、水印图片的路径，水印一般格式是gif，png,这种图片可以设置透明度、水印旋转等，可以参考代码...

    JAVA拼图游戏+智能寻步+N*N可调N+图片自由切换

    2. **图像处理**：游戏的核心部分是对图片的处理，包括将完整图片分割成N²个等大小的小方格，并能进行打乱操作。这需要对图像的裁剪和复用有所了解，可能是通过BufferedImage类来实现的。 3. **智能寻步**：游戏...

Magicbox
Global site tag (gtag.js) - Google Analytics