Java DIP - 快速指南

Java DIP - 简介

数字图像处理 (DIP) 涉及使用数字计算机处理数字图像。它是信号和系统的一个子领域，但特别关注图像。DIP 专注于开发能够对图像进行处理的计算机系统。这种系统的输入是数字图像。系统使用高效的算法处理图像，并给出图像作为输出。

Java 是一种在现代世界广泛使用的高级编程语言。它可以使用各种功能有效地支持和处理数字图像处理。

Java BufferedImage 类

JavaBufferedImage类是 Image 类的子类。它用于处理和操作图像数据。ABufferedImage由图像数据的ColorModel组成。所有BufferedImage对象的左上角坐标均为 (0, 0)。

构造函数

该类支持三种类型的构造函数。

第一个构造函数BufferedImage 使用指定的 ColorModel 和 Raster 构造一个新的。

BufferedImage(ColorModel cm, WritableRaster raster, 
boolean isRasterPremultiplied, Hashtable<?,?> properties)

第二个构造函数构造BufferedImage 预定义图像类型之一。

BufferedImage(int width, int height, int imageType)

第三个构造函数构造BufferedImage 预定义图像类型之一：TYPE_BYTE_BINARY 或 TYPE_BYTE_INDEXED。

BufferedImage(int width, int height, int imageType, IndexColorModel cm)

先生编号	方法及说明
1	复制数据（WritableRaster outRaster）它计算的任意矩形区域`BufferedImage` 并将其复制到指定的 WritableRaster 中。
2	获取颜色模型() 它返回图像的 ColorModel 类的对象。
3	获取数据() 它将图像作为一个大图块返回。
4	获取数据（矩形矩形）它计算并返回的任意区域`BufferedImage`。
5	获取图形() 该方法返回一个Graphics2D，保留向后兼容性。
6	获取高度() 它返回的高度`BufferedImage`。
7	获取MinX() 它返回 this 的最小 x 坐标`BufferedImage`。
8	getMinY() 它返回 this 的最小 y 坐标`BufferedImage`。
9	getRGB(int x, int y) 它返回默认 RGB 颜色模型 (TYPE_INT_ARGB) 和默认 sRGB 颜色空间中的整数像素。
10	获取类型() 它返回图像类型。

例子

以下示例演示了如何使用 javaBufferedImage 类，使用 Graphics 对象在屏幕上绘制一些文本 -

import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test extends JPanel {

   public void paint(Graphics g) {
      Image img = createImageWithText();
      g.drawImage(img, 20,20,this);
   }

   private Image createImageWithText() {
      BufferedImage bufferedImage = new BufferedImage(200,200,BufferedImage.TYPE_INT_RGB);
      Graphics g = bufferedImage.getGraphics();

      g.drawString("www.tutorialspoint.com", 20,20);
      g.drawString("www.tutorialspoint.com", 20,40);
      g.drawString("www.tutorialspoint.com", 20,60);
      g.drawString("www.tutorialspoint.com", 20,80);
      g.drawString("www.tutorialspoint.com", 20,100);
      
      return bufferedImage;
   }
   
   public static void main(String[] args) {
      JFrame frame = new JFrame();
      frame.getContentPane().add(new Test());

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(200, 200);
      frame.setVisible(true);
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

下载和上传图像

在本章中，我们将了解如何从互联网下载图像，对图像执行一些图像处理技术，然后再次将处理后的图像上传到服务器。

下载图像

为了从网站下载图像，我们使用名为URL的 java 类，该类可以在java.net包下找到。其语法如下 -

String website = "http://tutorialspoint.com";
URL url = new URL(website);

除了上述方法之外，URL 类中还有其他方法可用，简要描述如下：

先生。	方法及说明
1	公共字符串 getPath() 它返回 URL 的路径。
2	公共字符串 getQuery() 它返回 URL 的查询部分。
3	公共字符串 getAuthority() 它返回 URL 的权限。
4	公共 int getPort() 它返回 URL 的端口。
5	公共 int getDefaultPort() 它返回 URL 协议的默认端口。
6	公共字符串 getProtocol() 它返回 URL 的协议。
7	公共字符串 getHost() 它返回 URL 的主机。

例子

以下示例演示了使用 java URL 类从互联网下载图像 -

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import java.net.URL;

public class Download {

   public static void main(String[] args) throws Exception {
   
      try{
         String fileName = "digital_image_processing.jpg";
         String website = "http://tutorialspoint.com/java_dip/images/"+fileName;
         
         System.out.println("Downloading File From: " + website);
         
         URL url = new URL(website);
         InputStream inputStream = url.openStream();
         OutputStream outputStream = new FileOutputStream(fileName);
         byte[] buffer = new byte[2048];
         
         int length = 0;
         
         while ((length = inputStream.read(buffer)) != -1) {
            System.out.println("Buffer Read of length: " + length);
            outputStream.write(buffer, 0, length);
         }
         
         inputStream.close();
         outputStream.close();
         
      } catch(Exception e) {
         System.out.println("Exception: " + e.getMessage());
      }
   }
}

输出

当您执行上面的命令时，会看到以下输出。

它将从服务器下载以下图像。

上传图片

让我们看看如何将图像上传到网络服务器。我们将 BufferedImage 转换为字节数组，以便将其发送到服务器。

我们使用 Java 类ByteArrayOutputStream ，它可以在java.io包下找到。其语法如下 -

ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(image, "jpg", baos);

为了将图像转换为字节数组，我们使用ByteArrayOutputStream类的toByteArray()方法。其语法如下 -

byte[] bytes = baos.toByteArray();

除了上述方法之外，ByteArrayOutputStream 类中还有其他方法可用，简要描述如下：

先生。	方法及说明
1	公共无效重置（）该方法将字节数组输出流的有效字节数重置为零，从而丢弃流中所有累积的输出。
2	公共字节[] toByteArray() 此方法创建一个新分配的字节数组。它的大小将是输出流的当前大小，并且缓冲区的内容将被复制到其中。它将输出流的当前内容作为字节数组返回。
3	公共字符串 toString() 将缓冲区内容转换为字符串。翻译将根据默认的字符编码进行。它返回从缓冲区内容转换而来的字符串。
4	公共无效写入（int w）它将指定的数组写入输出流。
5	公共无效写入（字节[]b，int of，int len）它将从偏移量 off 开始的 len 个字节写入流中。
6	公共无效writeTo（输出流outSt）它将该 Stream 的全部内容写入指定的流参数。

例子

以下示例演示了 ByteArrayOutputStream 将图像上传到服务器 -

客户端代码

import javax.swing.*;  
import java.net.*; 
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class Client{
   public static void main(String args[]) throws Exception{
   
      Socket soc;
      BufferedImage img = null;
      soc=new Socket("localhost",4000);
      System.out.println("Client is running. ");
      
      try {
         System.out.println("Reading image from disk. ");
         img = ImageIO.read(new File("digital_image_processing.jpg"));
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         
         ImageIO.write(img, "jpg", baos);
         baos.flush();
         
         byte[] bytes = baos.toByteArray();
         baos.close();
         
         System.out.println("Sending image to server. ");
         
         OutputStream out = soc.getOutputStream(); 
         DataOutputStream dos = new DataOutputStream(out);
         
         dos.writeInt(bytes.length);
         dos.write(bytes, 0, bytes.length);
         
         System.out.println("Image sent to server. ");

         dos.close();
         out.close();
         
      } catch (Exception e) {
         System.out.println("Exception: " + e.getMessage());
         soc.close();
      }
      soc.close();
   }
}

服务器代码

import java.net.*;
import java.io.*;
import java.awt.image.*;

import javax.imageio.*; 
import javax.swing.*; 

class Server {
   public static void main(String  args[]) throws Exception{
      ServerSocket server=null;
      Socket socket;
      server = new ServerSocket(4000);
      System.out.println("Server Waiting for image");

      socket = server.accept();
      System.out.println("Client connected.");
      
      InputStream in = socket.getInputStream();
      DataInputStream dis = new DataInputStream(in);

      int len = dis.readInt();
      System.out.println("Image Size: " + len/1024 + "KB");
      
      byte[] data = new byte[len];
      dis.readFully(data);
      dis.close();
      in.close();

      InputStream ian = new ByteArrayInputStream(data);
      BufferedImage bImage = ImageIO.read(ian);
 
      JFrame f = new JFrame("Server");
      ImageIcon icon = new ImageIcon(bImage);
      JLabel l = new JLabel();
      
      l.setIcon(icon);
      f.add(l);
      f.pack();
      f.setVisible(true);
   }
}

输出

客户端输出

当您执行客户端代码时，客户端会出现以下输出 -

服务器端输出

当您执行服务器代码时，服务器端会出现以下输出 -

收到图像后，服务器显示图像，如下所示 -

Java DIP - 图像像素

图像包含二维像素阵列。它实际上是构成图像的那些像素的值。通常图像可以是彩色或灰度的。

在Java中，BufferedImage类用于处理图像。您需要调用BufferedImage类的getRGB()方法来获取像素的值。

获取像素值

可以使用以下语法接收像素值 -

Color c = new Color(image.getRGB(j, i));

获取 RGB 值

getRGB()方法将行索引和列索引作为参数并返回适当的像素。对于彩色图像，它返回三个值（红、绿、蓝）。它们可以得到如下 -

c.getRed();
c.getGreen();
c.getBlue();

获取图像的宽度和高度

图像的高度和宽度可以通过调用BufferedImage类的getWidth()和getHeight()方法来获取。它的语法如下：

int width = image.getWidth();
int height = image.getHeight();

除了这些方法之外，BufferedImage 类还支持其他方法。它们被简要描述-

先生。	方法及说明
1	复制数据（WritableRaster outRaster）它计算 BufferedImage 的任意矩形区域并将其复制到指定的 WritableRaster 中。
2	获取颜色模型() 它返回图像的 ColorModel。
3	获取数据() 它将图像作为一个大图块返回。
4	获取数据（矩形矩形）它计算并返回 BufferedImage 的任意区域。
5	获取图形() 此方法返回 Graphics2D，但此处是为了向后兼容。
6	获取高度() 它返回 BufferedImage 的高度。
7	获取MinX() 它返回此 BufferedImage 的最小 x 坐标。
8	getMinY() 它返回此 BufferedImage 的最小 y 坐标。
9	getRGB(int x, int y) 它返回默认 RGB 颜色模型 (TYPE_INT_ARGB) 和默认 sRGB 颜色空间中的整数像素。
10	获取类型() 它返回图像类型。

例子

以下示例演示了使用 java BufferedImage 类显示大小为 (100 x 100) 的图像的像素 -

import java.awt.*;
import java.awt.image.BufferedImage;

import java.io.*;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

class Pixel {
   BufferedImage image;
   int width;
   int height;
   
   public Pixel() {
      try {
         File input = new File("blackandwhite.jpg");
         image = ImageIO.read(input);
         width = image.getWidth();
         height = image.getHeight();
         
         int count = 0;
         
         for(int i=0; i<height; i++) {
         
            for(int j=0; j<width; j++) {
            
               count++;
               Color c = new Color(image.getRGB(j, i));
               System.out.println("S.No: " + count + " Red: " + c.getRed() +"  Green: " + c.getGreen() + " Blue: " + c.getBlue());
            }
         }

      } catch (Exception e) {}
   }
   
   static public void main(String args[]) throws Exception {
      Pixel obj = new Pixel();
   }
}

输出

当您执行上面的示例时，它将打印以下图像的像素 -

原始图像

像素输出

如果向下滚动输出，则会看到以下模式 -

Java DIP - 灰度转换

为了将彩色图像转换为灰度图像，您需要使用File和ImageIO对象读取图像的像素或数据，并将图像存储在BufferedImage对象中。其语法如下 -

File input = new File("digital_image_processing.jpg");
BufferedImage image = ImageIO.read(input);

此外，使用getRGB()方法获取像素值并对其执行 GrayScale() 方法。getRGB() 方法将行和列索引作为参数。

Color c = new Color(image.getRGB(j, i));
int red = (c.getRed() * 0.299);
int green =(c.getGreen() * 0.587);
int blue = (c.getBlue() *0.114);

除了这三种方法之外，Color 类中还有其他可用的方法，如简要所述 -

先生。	方法及说明
1	更亮（）它创建了一种新颜色，该颜色是该颜色的更亮版本。
2	较暗（）它创建了一种新颜色，该颜色是该颜色的较暗版本。
3	获取阿尔法() 它返回 0-255 范围内的 alpha 分量。
4	getHSBColor(浮点数 h, 浮点数 s, 浮点数 b) 它根据 HSB 颜色模型的指定值创建一个 Color 对象。
5	HSBtoRGB（浮动色调、浮动饱和度、浮动亮度）它将 HSB 模型指定的颜色分量转换为默认 RGB 模型的等效值集。
6	toString() 它返回此颜色的字符串表示形式。

最后一步是将这三个值全部相加并再次设置为相应的像素值。其语法如下 -

int sum = red+green+blue;
Color newColor = new Color(sum,sum,sum);
image.setRGB(j,i,newColor.getRGB());

例子

以下示例演示了如何使用 Java BufferedImage 类将图像转换为灰度 -

import java.awt.*;
import java.awt.image.BufferedImage;

import java.io.*;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class GrayScale {

   BufferedImage  image;
   int width;
   int height;
   
   public GrayScale() {
   
      try {
         File input = new File("digital_image_processing.jpg");
         image = ImageIO.read(input);
         width = image.getWidth();
         height = image.getHeight();
         
         for(int i=0; i<height; i++) {
         
            for(int j=0; j<width; j++) {
            
               Color c = new Color(image.getRGB(j, i));
               int red = (int)(c.getRed() * 0.299);
               int green = (int)(c.getGreen() * 0.587);
               int blue = (int)(c.getBlue() *0.114);
               Color newColor = new Color(red+green+blue,
               
               red+green+blue,red+green+blue);
               
               image.setRGB(j,i,newColor.getRGB());
            }
         }
         
         File ouptut = new File("grayscale.jpg");
         ImageIO.write(image, "jpg", ouptut);
         
      } catch (Exception e) {}
   }
   
   static public void main(String args[]) throws Exception {
      GrayScale obj = new GrayScale();
   }
}

输出

当您执行给定的示例时，它将图像digital_image_processing.jpg转换为其等效的灰度图像，并将其以名称Grayscale.jpg写入硬盘。

原始图像

灰度图像

Java DIP - 增强图像对比度

在本章中，学习如何使用直方图均衡化来增强图像的对比度。

我们使用OpenCV函数equalizeHist()方法。它可以在Imgproc包下找到。其语法如下 -

Imgproc.equalizeHist(source, destination);

参数描述如下 -

先生。	参数及说明
1	来源它是8位单通道源图像。
2	目的地这是目标图像。

先生。

参数及说明

来源

它是8位单通道源图像。

目的地

这是目标图像。

除了 equalizeHist() 方法之外，Imgproc 类还提供了其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int d深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6	积分(Mat src, Mat sum) 它计算图像的积分。

例子

以下示例演示了如何使用 Imgproc 类来增强图像的对比度 -

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class Main {

   static int width;
   static int height;
   static double alpha = 2;
   static double beta = 50;
   
   public static void main( String[] args ) {
   
      try {
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("grayscale.jpg", 
         Highgui.CV_LOAD_IMAGE_GRAYSCALE);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         
         Imgproc.equalizeHist(source, destination);
         Highgui.imwrite("contrast.jpg", destination);
         
      } catch (Exception e) {
         System.out.println("error: " + e.getMessage());
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

增强对比度图像

Java DIP - 增强图像亮度

在本章中，我们通过将图像的每个像素乘以一个 alpha 值并添加另一个 beta 值来增强图像的亮度。

我们的OpenCV函数convertTo会自动完成上述操作。它可以在Mat包下找到。其语法如下 -

int alpha = 2;
int beta = 50;
sourceImage.convertTo(destination, rtype , alpha, beta);

参数描述如下 -

先生。	参数及说明
1	目的地这是目的地图像。
2	类型这是所需的输出矩阵类型，或者更确切地说是深度，因为通道数与输入相同。如果 rtype 为负，则输出矩阵将具有与输入相同的类型。
3	α 它是可选的比例因子。
4	贝塔它是添加到缩放值的可选增量。

除了convertTo方法之外，Mat类还提供了其他方法。它们被简要描述 -

先生。	方法及说明
1	调整ROI（int dtop，int dbottom，int dleft，int dright）它调整子矩阵的大小和在父矩阵中的位置。
2	复制到（Mat m）它将矩阵复制到另一个矩阵。
3	诊断（）它从矩阵中提取对角线，或创建对角矩阵。
4	点(垫米) 它计算两个向量的点积。
5	重塑(int cn) 它可以更改 2D 矩阵的形状和/或通道数，而无需复制数据。
6	submat(范围 rowRange, 范围 colRange) 它提取一个矩形子矩阵。

例子

以下示例演示了如何使用 Mat 类来增强图像的亮度 -

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.highgui.Highgui;

public class Main {
   static int width;
   static int height;
   static double alpha = 2;
   static double beta = 50;
   
   public static void main( String[] args ) {
   
      try{
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source =  Highgui.imread("digital_image_processing.jpg",Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),
         
         source.type());
         source.convertTo(destination, -1, alpha, beta);
         Highgui.imwrite("brightWithAlpha2Beta50.jpg", destination);
         
      } catch (Exception e) {
         System.out.println("error:" + e.getMessage());
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

增强的明亮图像（Alpha=1 & Beta=50）

增强的明亮图像（Alpha=2 & Beta=50）

Java DIP - 增强图像清晰度

在本章中，我们学习使用高斯滤波器来提高图像的清晰度。

首先我们使用OpenCV函数GaussianBlur。它可以在Imgproc包下找到。其语法如下 -

Imgproc.GaussianBlur(source, destination, new Size(0,0), sigmaX);

参数简要描述 -

先生。	参数及说明
1	来源这是源图像。
2	目的地这是目的地图像。
3	尺寸它是高斯核大小。
4	西格玛X 它是X方向上的高斯核标准差。

此外，我们使用OpenCV函数addWeighted将图像水印应用于图像。它可以在Core包下找到。其语法如下 -

Core.addWeighted(InputArray src1, alpha, src2, beta, gamma, OutputArray dst);

该函数的参数描述如下 -

先生。	参数及说明
1	源1 它是第一个输入数组。
2	α 它是第一个数组元素的权重。
3	源2 它是与 src1 具有相同大小和通道号的第二个输入数组。
4	贝塔它是第二个数组元素的权重。
5	伽玛它是添加到每个总和中的标量。
6	目的地它是与输入数组具有相同大小和通道数的输出数组。

除了 GaussianBlur 方法之外，Imgproc 类还提供了其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6	积分(Mat src, Mat sum) 它计算图像的积分。

例子

以下示例演示了如何使用 Imgproc 和 Core 类对图像应用锐化 -

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class Main {
   public static void main( String[] args ) {
      try{
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",
         Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         Imgproc.GaussianBlur(source, destination, new Size(0,0), 10);
         Core.addWeighted(source, 1.5, destination, -0.5, 0, destination);
         Highgui.imwrite("sharp.jpg", destination);
      } catch (Exception e) {
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

锐化图像

Java DIP - 图像压缩技术

通过Java可以轻松地压缩和存储图像。图像压缩涉及将图像转换为 jpg 并存储。

为了压缩图像，我们读取图像并转换为 BufferedImage 对象。

此外，我们从ImageIO 类中的getImageWritersByFormatName()方法获取 ImageWriter 。从此 ImageWriter 创建一个ImageWriteParam对象。其语法如下 -

Iterator<ImageWriter> list = ImageIO.getImageWritersByFormatName("jpg");
ImageWriteParam obj = writer_From_List.getDefaultWriteParam();

从此 ImageWriteParam 对象中，您可以通过调用setCompressionMode()和setCompressionQuality()这两个方法来设置压缩。它们的语法如下所示 -

obj.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
obj.setCompressionQuality(0.05f);

setCompressionMode() 方法以Mode_EXPLICIT 作为参数。简要描述了其他一些模式 -

先生。	模式
1	模式默认它是一个常量值，可以传递到方法中以便为将来的写入启用该功能。
2	模式_禁用它是一个常量值，可以传递到方法中以禁用该功能以便将来写入。
3	模式_显式它是一个常量值，可以传递到方法中以便为将来的写入启用该功能。

先生。

模式

模式默认

它是一个常量值，可以传递到方法中以便为将来的写入启用该功能。

模式_禁用

它是一个常量值，可以传递到方法中以禁用该功能以便将来写入。

模式_显式

它是一个常量值，可以传递到方法中以便为将来的写入启用该功能。

除了压缩方法之外，ImageWriteParam 类还提供其他方法。它们被简要描述 -

先生。	方法及说明
1	canOffsetTiles() 如果写入器在写入时可以使用非零网格偏移执行平铺，则返回 true。
2	getBitRate（浮点质量）它返回一个浮点值，指示给定质量级别下输入图像数据每一位的输出数据位数的估计值。
3	获取语言环境() 它返回当前设置的区域设置，如果仅支持默认区域设置，则返回 null。
4	isCompressionLossless() 如果当前压缩类型提供无损压缩，则返回 true。
5	取消设置压缩() 它会删除任何以前的压缩类型和质量设置。
6	取消设置平铺() 它会删除之前通过调用 setTiling 指定的所有图块网格参数。

例子

以下示例演示了如何使用 ImageWriteParam 类来压缩图像 -

import java.io.*;
import java.util.*;
import java.awt.image.*;

import javax.imageio.*;
import javax.imageio.stream.ImageOutputStream;

class Compression {

   public static void main(String[] args) throws IOException {
   
      File input = new File("digital_image_processing.jpg");
      BufferedImage image = ImageIO.read(input);

      File compressedImageFile = new File("compress.jpg");
      OutputStream os =new FileOutputStream(compressedImageFile);

      Iterator<ImageWriter>writers =  ImageIO.getImageWritersByFormatName("jpg");
      ImageWriter writer = (ImageWriter) writers.next();

      ImageOutputStream ios = ImageIO.createImageOutputStream(os);
      writer.setOutput(ios);

      ImageWriteParam param = writer.getDefaultWriteParam();
      
      param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
      param.setCompressionQuality(0.05f);
      writer.write(null, new IIOImage(image, null, null), param);
      
      os.close();
      ios.close();
      writer.dispose();
   }
}

输出

当您执行给定的代码时，它将图像digital_image_processing.jpg压缩为其等效的压缩图像，并将其写入硬盘上，名称为compress.jpg。

原始图像

压缩图像 - 质量因数 − 0.05

压缩图像 - 质量因数 − 0.5

Java DIP - 添加边框

在本章中，我们学习向图像添加不同类型的边框。

我们使用OpenCV函数copyMakeBorder。它可以在Imgproc包下找到。其语法如下 -

Imgproc.copyMakeBorder(source,destination,top,bottom,left,right,borderType);

参数描述如下 -

先生。	参数及说明
1	来源这是源图像。
2	目的地这是目的地图像。
3	顶部它是图像顶部边框的长度（以像素为单位）。
4	底部图像底部边框的长度（以像素为单位）。
5	左边它是图像左侧边框的长度（以像素为单位）。
6	正确的它是图像右侧边框的长度（以像素为单位）。
7	边框类型它定义了边框的类型。可能的边框有 BORDER_REPLICATE、BORDER_REFLECT、BORDER_WRAP、BORDER_CONSTANT 等。

除了 copyMakeBorder() 方法之外，Imgproc 类还提供其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6	积分(Mat src, Mat sum) 它计算图像的积分。

例子

以下示例演示了如何使用 Imgproc 类向图像添加边框 -

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class main {
   public static void main( String[] args ) {
   
      try {
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",
         
         Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         
         int top, bottom, left, right;
         int borderType;

         /// Initialize arguments for the filter
         top = (int) (0.05*source.rows()); 
         bottom = (int) (0.05*source.rows());
         left = (int) (0.05*source.cols()); 
         right = (int) (0.05*source.cols());

         destination = source;
         Imgproc.copyMakeBorder(source, destination, top, bottom, left, right, Imgproc.BORDER_WRAP);
         Highgui.imwrite("borderWrap.jpg", destination);
         
      } catch (Exception e) {
         System.out.println("error: " + e.getMessage());
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

孤立的边框图像

环绕边框图像

反射边框图像

Java DIP - 图像Pyramid

图像Pyramid只不过是一种显示多分辨率图像的方法。最下层是图像的最高分辨率版本，最上层是图像的最低分辨率版本。图像Pyramid用于处理不同尺度的图像。

在本章中，我们对图像执行一些下采样和上采样。

我们使用OpenCV函数pyrUp和pyrDown。它们可以在Imgproc包下找到。其语法如下 -

Imgproc.pyrUp(source, destination, destinationSize);
Imgproc.pyrDown(source, destination,destinationSize);

参数描述如下 -

先生。

参数及说明

来源

这是源图像。

目的地

这是目标图像。

目的地大小

它是输出图像的大小。默认情况下，其计算方式为 Size((src.cols*2), (src.rows*2))。

除了pyrUp 和pyrDown 方法之外，Imgproc 类还提供其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6	积分(Mat src, Mat sum) 它计算图像的积分。

例子

以下示例演示了如何使用 Imgproc 类对图像执行上采样和下采样。

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Size;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class main {
   public static void main( String[] args ) {
   
      try{
      
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",
         Highgui.CV_LOAD_IMAGE_COLOR);
         
         Mat destination1 = new Mat(source.rows()*2, source.cols()*2,source.type());
         destination1 = source;
         
         Imgproc.pyrUp(source, destination1, new  Size(source.cols()*2   source.rows()*2));
         Highgui.imwrite("pyrUp.jpg", destination1);
         
         source = Highgui.imread("digital_image_processing.jpg", 
         Highgui.CV_LOAD_IMAGE_COLOR);
         
         Mat destination = new Mat(source.rows()/2,source.cols()/2, source.type());
         destination = source;
         Imgproc.pyrDown(source, destination, new Size(source.cols()/2,  source.rows()/2));
         Highgui.imwrite("pyrDown.jpg", destination);
         
      } catch (Exception e) { 
         System.out.println("error: " + e.getMessage());
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

对原始图像进行pyrUp（上采样）和pyrDown（下采样）。采样后的输出如下所示 -

PyrUP 图像

pyDown 图像

Java DIP - 基本阈值

阈值处理能够以最简单的方式实现图像分割。图像分割是指将完整的图像划分为一组像素，使得每组中的像素具有一些共同的特征。图像分割对于定义对象及其边界非常有用。

在本章中，我们对图像执行一些基本的阈值操作。

我们使用OpenCV函数阈值。它可以在Imgproc包下找到。其语法如下 -

Imgproc.threshold(source, destination, thresh , maxval , type);

参数描述如下 -

先生。	参数及说明
1	来源这是源图像。
2	目的地这是目的地图像。
3	脱粒是阈值。
4	最大值它是与 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型一起使用的最大值。
5	类型可能的类型有 THRESH_BINARY、THRESH_BINARY_INV、THRESH_TRUNC 和 THRESH_TOZERO。

除了这些阈值方法之外，Imgproc 类还提供其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int d深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6	积分(Mat src, Mat sum) 它计算图像的积分。

例子

以下示例演示了如何使用 Imgproc 类对图像执行阈值操作 -

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class main {
   public static void main( String[] args ) {
   
      try{

         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         Mat source = Highgui.imread("digital_image_processing.jpg",  Highgui.CV_LOAD_IMAGE_COLOR);
         Mat destination = new Mat(source.rows(),source.cols(),source.type());

         destination = source;
         Imgproc.threshold(source,destination,127,255,Imgproc.THRESH_TOZERO);
         Highgui.imwrite("ThreshZero.jpg", destination);
         
      } catch (Exception e) {
         System.out.println("error: " + e.getMessage());
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

在上面的原始图像上，执行了一些阈值操作，如下面的输出所示 -

锤石二进制

阈值二进制反转

零锤子

Java DIP - 图像形状转换

使用 OpenCV 可以轻松更改图像的形状。图像可以在四个方向中的任何一个方向上翻转、缩放或旋转。

为了改变图像的形状，我们读取图像并转换为Mat对象。其语法如下 -

File input = new File("digital_image_processing.jpg");
BufferedImage image = ImageIO.read(input);
//convert Buffered Image to Mat.

翻转图像

OpenCV 允许三种类型的翻转代码，如下所述 -

先生。	翻转代码和说明
1	0 0 表示绕 x 轴翻转。
2	1 1 表示绕 y 轴翻转。
3	-1 -1 表示绕两个轴翻转。

先生。

翻转代码和说明

0 表示绕 x 轴翻转。

1 表示绕 y 轴翻转。

-1

-1 表示绕两个轴翻转。

我们将适当的翻转代码传递到Core类中的方法Flip()中。其语法如下 -

Core.flip(source mat, destination mat1, flip_code);

Flip()方法采用三个参数 - 源图像矩阵、目标图像矩阵和翻转代码。

除了flip方法之外，Core类还提供了其他方法。它们被简要描述 -

先生。	方法及说明
1	添加（垫 src1，垫 src2，垫 dst）它计算两个数组或一个数组和一个标量的每个元素的总和。
2	bitwise_and(Mat src1, Mat src2, Mat dst) 它计算两个数组或一个数组和一个标量的每个元素的按位连接。
3	bitwise_not(Mat src, Mat dst) 它反转数组的每一位。
4	圆（Mat img，点中心，整数半径，标量颜色）它画了一个圆圈。
5	sumElems(Mat src) 它使用高斯滤波器模糊图像。
6	减去（Mat src1，标量 src2，Mat dst，Mat mask）它计算两个数组或数组与标量之间每个元素的差异。

例子

以下示例演示了如何使用 Core 类来翻转图像 -

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;

import java.io.File;
import javax.imageio.ImageIO;

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

import org.opencv.imgproc.Imgproc;

public class Main {
   public static void main( String[] args ) {
   
      try {
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         File input = new File("digital_image_processing.jpg");
         BufferedImage image = ImageIO.read(input);	

         byte[] data = ((DataBufferByte) image.getRaster().  getDataBuffer()).getData();
         Mat mat = new Mat(image.getHeight(),image.getWidth(),CvType.CV_8UC3);
         mat.put(0, 0, data);

         Mat mat1 = new Mat(image.getHeight(),image.getWidth(),CvType.CV_8UC3);
         Core.flip(mat, mat1, -1);

         byte[] data1 = new byte[mat1.rows()*mat1.cols()*(int)(mat1.elemSize())];
         mat1.get(0, 0, data1);
         BufferedImage image1 = new BufferedImage(mat1.cols(), mat1.rows(), 5);
         image1.getRaster().setDataElements(0,0,mat1.cols(),mat1.rows(),data1);

         File ouptut = new File("hsv.jpg");
         ImageIO.write(image1, "jpg", ouptut);
         
      } catch (Exception e) {
         System.out.println("Error: " + e.getMessage());
      }
   }
}

输出

当您运行上面的示例时，它会将名称为digital_image_processing.jpg 的图像翻转为其等效的 HSV 颜色空间图像，并将其写入名为Flip.jpg 的硬盘上。

原始图像

翻转图像

Java DIP - 应用高斯滤波器

在本章中，我们将高斯滤波器应用于模糊图像的图像。我们将使用 OpenCV 函数 GaussianBlur 对图像应用高斯滤波器。它可以在 Imgproc 包下找到。其语法如下 -

Imgproc.GaussianBlur(source, destination,Size,SigmaX);

函数参数描述如下 -

先生。	论点和描述
1	来源这是源图像。
2	目的地这是目的地图像。
3	尺寸它是高斯核大小。
4	西格玛X 它是X方向上的高斯核标准差。

除了 GaussianBlur 方法之外，Imgproc 类还提供了其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6	积分(Mat src, Mat sum) 它计算图像的积分。

例子

以下示例演示了如何使用 Imgproc 类将高斯滤波器应用于图像。

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Size;

import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;


public class Main {
   public static void main( String[] args ) {
   
      try {
         System.loadLibrary( Core.NATIVE_LIBRARY_NAME );
         
         Mat source = Highgui.imread("digital_image_processing.jpg",
         Highgui.CV_LOAD_IMAGE_COLOR);
         
         Mat destination = new Mat(source.rows(),source.cols(),source.type());
         Imgproc.GaussianBlur(source, destination,new Size(45,45), 0);
         Highgui.imwrite("Gaussian45.jpg", destination);
      
      } catch (Exception e) {
         System.out.println("Error:" + e.getMessage());
      }
   }
}

输出

当您执行给定的代码时，会看到以下输出 -

原始图像

当该原始图像与大小为 11 和 45 的高斯滤波器进行卷积时，可以看到以下输出。

尺寸为 11 的高斯滤波器

尺寸为 45 的高斯滤波器

Java DIP - 应用盒式过滤器

我们应用 Box 滤镜来模糊图像。盒式过滤器的尺寸可以是 3x3、5x5、9x9 等。

我们使用OpenCV函数filter2D将 Box 滤波器应用于图像。它可以在Imgproc包下找到。其语法如下 -

filter2D(src, dst, depth , kernel, anchor, delta, BORDER_DEFAULT );

函数参数描述如下 -

先生。	论点和描述
1	源代码这是源图像。
2	目的地这是目的地图像。
3	深度它是 dst 的深度。负值（例如-1）表示深度与源相同。
4	核心就是通过图像来扫描的内核。
5	锚它是锚点相对于其内核的位置。位置点（-1，-1）默认表示中心。
6	三角洲它是在卷积过程中添加到每个像素的值。默认为 0。
7	BORDER_DEFAULT 我们默认这个值。

除了filter2D()方法之外，Imgproc类还提供了其他方法。它们被简要描述 -

先生。	方法及说明
1	cvtColor（Mat src，Mat dst，int代码，int dstCn）它将图像从一种颜色空间转换为另一种颜色空间。
2	膨胀（Mat src，Mat dst，Mat 内核）它通过使用特定的结构元素来扩大图像。
3	equalizeHist(Mat src, Mat dst) 它均衡灰度图像的直方图。
4	filter2D（Mat src，Mat dst，int深度，Mat内核，点锚点，双增量）它将图像与内核进行卷积。
5	GaussianBlur(Mat src, Mat dst, 大小 ksize, 双 sigmaX) 它使用高斯滤波器模糊图像。
6