java使用opencv库二值化图片

已于 2023-09-10 18:30:53 修改
阅读量347 收藏
点赞数
文章标签： java opencv python 图片二值化
于 2023-09-10 18:30:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44192389/article/details/132794140
版权

应用场景：
截取监控视频图片保存到本地后用作后期监控视频角度调整参考。
使用二值化后的图片并进行透明度降低进行监控矫正。

package img;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.IOException;

public class Canny {

	static int edge[][];
	static int find[][];
	static double vmax=0;
	static BufferedImage cannyImg;

	public Canny() {
		// TODO Auto-generated constructor stub
	}
	public static BufferedImage getCannyImg(BufferedImage image,double a,double b,double g) throws IOException {
		// TODO Auto-generated method stub
		// 灰度化
		BufferedImage grayImg=getGray(image);
		// 高斯滤波
		grayImg=filtering_Gaussian(grayImg, g);
		// 计算梯度幅度值和梯度方向
		double grad[][][]=getGradient(grayImg);
		// double nms[][]=NMS(grad);
		// 非极大值抑制处理(插值法)
		double nms[][]=NMS_2(grad);
		// 双阈值处理
		double thresh=vmax*a;
		double_threshold(nms, b*thresh, thresh);
		// 边界跟踪处理
		boundary_tracking();
		BufferedImage cannyImg=showCannyImg();
		return cannyImg;
	}
	private static BufferedImage getGray(BufferedImage image) {
		// TODO Auto-generated method stub
		int w = image.getWidth();
		int h = image.getHeight();

		BufferedImage grayImg= new BufferedImage(w,h,image.getType());

		for(int x=0;x<w;x++)
			for(int y=0;y<h;y++) {
				int pixel=image.getRGB(x, y);
				int r=(pixel & 0xff0000) >> 16;
				int g=(pixel & 0xff00) >> 8;
				int b=(pixel & 0xff);
				int gray = (int) (0.299 * r + 0.587 * g + 0.114 * b);
				grayImg.setRGB(x, y, new Color(gray,gray,gray).getRGB());
			}

		return grayImg;
	}
	private static int RGBTogray(int pixel) {
		// TODO Auto-generated method stub
		return pixel & 0xff;
	}
	private static BufferedImage filtering_Gaussian(BufferedImage image, double g) {
		// TODO Auto-generated method stub
		int w = image.getWidth();
		int h = image.getHeight();

		int length=5;
		int k=length/2;
		double sigma=Math.sqrt(g);

		double[][] gaussian=new double[length][length];
		double sum=0;
		for(int i=0;i<length;i++) {
			for(int j=0;j<length;j++) {
				gaussian[i][j]=Math.exp(-((i-k)*(i-k)+(j-k)*(j-k))/(2*sigma*sigma));
				gaussian[i][j]/=2*Math.PI*sigma*sigma;
				sum+=gaussian[i][j];
			}
		}
		for(int i=0;i<length;i++) {
			for(int j=0;j<length;j++) {
				gaussian[i][j]/=sum;
			}
		}

		BufferedImage GaussianImg= new BufferedImage(w,h,image.getType());

		for(int x=k;x<w-k;x++) {
			for(int y=k;y<h-k;y++) {
				int newpixel=0;
				for(int gx=0;gx<length;gx++) {
					for(int gy=0;gy<length;gy++) {
						int ix=x+gx-k;
						int iy=y+gy-k;
						if(ix<0||iy<0||ix>=w||iy>=h)
							continue;
						else {
							newpixel+=RGBTogray(image.getRGB(ix, iy))*gaussian[gx][gy];
						}
					}
				}
				newpixel=(int) Math.round(1.0*newpixel);
				GaussianImg.setRGB(x, y, new Color(newpixel,newpixel,newpixel).getRGB());
			}
		}
		return GaussianImg;
	}
	private static double[][][] getGradient(BufferedImage image){
		// TODO Auto-generated method stub
		int w = image.getWidth();
		int h = image.getHeight();
		int step=1;
		double[][][] grad = new double[w][h][2];
		for(int x=step;x<w-step;x++) {
			for(int y=step;y<h-step;y++) {
				int gx=-RGBTogray(image.getRGB(x-step, y-step))
						-RGBTogray(image.getRGB(x-step, y))*2
						-RGBTogray(image.getRGB(x-step, y+step))
						+RGBTogray(image.getRGB(x+step, y-step))
						+RGBTogray(image.getRGB(x+step, y))*2
						+RGBTogray(image.getRGB(x+step, y+step));
				int gy=RGBTogray(image.getRGB(x-step, y+step))
						+RGBTogray(image.getRGB(x, y+step))*2
						+RGBTogray(image.getRGB(x+step, y+step))
						-RGBTogray(image.getRGB(x-step, y-step))
						-RGBTogray(image.getRGB(x, y-step))*2
						-RGBTogray(image.getRGB(x+step, y-step));
				grad[x][y][0]=Math.sqrt(gx*gx+gy*gy);
				if(gx==0)
					grad[x][y][1]=90;
				else
					grad[x][y][1]=Math.toDegrees(Math.atan(1.0*gy/gx));
			}
		}

		return grad;
	}
	private static double[][] NMS(double[][][] grad){
		// TODO Auto-generated method stub
		int w=grad.length;
		int h=grad[0].length;
		double[][] nms=new double[w][h];
		for(int x=1;x<w-1;x++) {
			for(int y=1;y<h-1;y++) {
				nms[x][y]=grad[x][y][0];
				if(grad[x][y][0]==0)
					continue;
				int a=(int) Math.round(grad[x][y][1]/45);
				if(a==-2||a==2) {
					if(grad[x][y][0]<grad[x][y-1][0]||grad[x][y][0]<grad[x][y+1][0])
						nms[x][y]=0;
				}
				else if(a==-1) {
					if(grad[x][y][0]<grad[x-1][y-1][0]||grad[x][y][0]<grad[x+1][y+1][0])
						nms[x][y]=0;
				}
				else if(a==0) {
					if(grad[x][y][0]<grad[x-1][y][0]||grad[x][y][0]<grad[x+1][y][0])
						nms[x][y]=0;
				}
				else if(a==1) {
					if(grad[x][y][0]<grad[x+1][y-1][0]||grad[x][y][0]<grad[x-1][y+1][0])
						nms[x][y]=0;
				}
				if(nms[x][y]>vmax)vmax=nms[x][y];
			}
		}

		return nms;
	}
	private static double[][] NMS_2(double[][][] grad) {
		// TODO Auto-generated method stub
		int w=grad.length;
		int h=grad[0].length;
		double[][] nms=new double[w][h];
		for(int x=1;x<w-1;x++) {
			for(int y=1;y<h-1;y++) {
				nms[x][y]=grad[x][y][0];
				if(grad[x][y][0]==0)
					continue;
				int x1,y1,x2,y2;
				double weight=Math.tan(Math.toRadians(grad[x][y][1]));
				if(grad[x][y][1]>45) {
					x1=0;y1=1;x2=1;y2=1;
					weight=1.0/weight;
				}else if(grad[x][y][1]>0) {
					x1=1;y1=0;x2=1;y2=1;
					weight*=1;
				}else if(grad[x][y][1]>-45) {
					x1=1;y1=0;x2=1;y2=-1;
					weight*=-1;
				}else {
					x1=0;y1=-1;x2=1;y2=-1;
					weight=-1.0/weight;
				}
				double g1=grad[x+x1][y+y1][0];
				double g2=grad[x+x2][y+y2][0];
				double g3=grad[x-x1][y-y1][0];
				double g4=grad[x-x2][y-y2][0];
				double grad_count_1=g1*weight+g2*(1-weight);
				double grad_count_2=g3*weight+g4*(1-weight);
				if(grad[x][y][0]<grad_count_1||grad[x][y][0]<grad_count_2)
					nms[x][y]=0;
				if(nms[x][y]>vmax)vmax=nms[x][y];
			}
		}
		return nms;
	}
	private static void double_threshold(double[][] nms,double low_th,double high_th){
		// TODO Auto-generated method stub
		int w=nms.length;
		int h=nms[0].length;
		edge=new int[w][h];
		for(int x=0;x<w;x++) {
			for(int y=0;y<h;y++) {
				if(nms[x][y]>=high_th) {
					edge[x][y]=2;
				}else if(nms[x][y]>=low_th) {
					edge[x][y]=1;
				}
			}
		}
	}
	private static void dfs(int x,int y,int w,int h) {
		// TODO Auto-generated method stub
		if(x<0||x>=w||y<0||y>=h||find[x][y]==1)return ;
		find[x][y]=1;
		if(edge[x][y]>=1) {
			edge[x][y]=2;
			for(int i=-1;i<=1;i++) {
				for(int j=-1;j<=1;j++) {
					dfs(x+i,y+j,w,h);
				}
			}
		}
	}
	private static int[][] boundary_tracking(){
		// TODO Auto-generated method stub
		int w=edge.length;
		int h=edge[0].length;

		find=new int[w][h];

		for(int x=0;x<w;x++) {
			for(int y=0;y<h;y++) {
				if(find[x][y]==1)continue;
				if(edge[x][y]==2) {
					dfs(x,y,w,h);
				}else if(edge[x][y]==0) {
					find[x][y]=1;
				}
			}
		}
		return edge;
	}
	private static BufferedImage showCannyImg() throws IOException {
		// TODO Auto-generated method stub
		int w=edge.length;
		int h=edge[0].length;

		BufferedImage cannyImg= new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
		for(int x=0;x<w;x++) {
			for(int y=0;y<h;y++) {
				if(edge[x][y]==2) {
					cannyImg.setRGB(x, y, new Color(255,0,0).getRGB());
				}else {
					cannyImg.setRGB(x, y, new Color(0,0,0).getRGB());
				}
			}
		}
		return cannyImg;
	}
}
LazyHaokj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java图片阈值二值化_OpenCV3 Java图像阈值和图像生成（Imgproc.threshold）
weixin_32100383的博客
02-25 1208
OCR (Optical Character Recognition，光学字符识别)是指电子设备(例如扫描仪或数码相机)检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程；即，针对印刷体字符，采用光学的方式将纸质文档中的文字转换成为黑白点阵的图像文件，并通过识别软件将图像中的文字转换成文本格式，供文字处理软件进一步编辑加工的技术。如何除错或利用辅助信...
二值化图片_java代码
10-28
在这个场景中，我们将探讨如何使用Java来实现图片的二值化处理。 在Java中，我们可以使用Java Advanced Imaging (JAI) 库或者Java AWT/Swing中的`BufferedImage`类来处理图像。不过，由于提供的文件列表中包含了一...
opencv+java实现灰度化、二值化、轮廓描边、边缘检测源码有注释
05-07
opencv+java实现灰度化、二值化、轮廓描边、边缘检测源码有注释
图像二值化---java+javaCV
liyuqian199695的博客
12-29 4385
图像二值化---java+javaCV 1、新建java工程，名为ShowIMG_javaCV，新建一个类“ShowIMG_javaCV”。新建一个文件夹“Resources”,并将待处理图像拷贝进去。添加javaCV1.3库。 2、ShowIMG_javaCV.java代码 import static org.bytedeco.javacpp.opencv_core.*; impor
图像处理之常见二值化方法汇总
热门推荐
关注微信公众号【OpenCV学堂】
10-15 11万+
图像处理之常见二值化方法汇总 图像二值化是图像分析与处理中最常见最重要的处理手段，二值处理方法也非常多。越 精准的方法计算量也越大。本文主要介绍四种常见的二值处理方法，通常情况下可以满 足大多数图像处理的需要。主要本文讨论的方法仅针对RGB色彩空间。   方法一： 该方法非常简单，对RGB彩色图像灰度化以后，扫描图像的每个像素值，值小于127的 将像素值设为0(黑色)，值大于等于12
Java+opencv3.2.0之二值化
帅气的猫爪
07-28 3711
原理：简单来说是指将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的黑白效果。   Opencv3.2.0中提供了两种方法实现图像二值化： （1）      Imgproc.threshold(Mat src, Matdst, double thresh, double maxval, int type) 参数说明：    src：输入源图像    dst：输出目标
Opencv（九）图像二值化
最新发布
weixin_70029632的博客
09-07 713
图像二值化可以通过选择一个阈值来实现。对于每个像素，将其灰度值与阈值进行比较，如果大于阈值，则将像素值设置为255（白色），否则将像素值设置为0（黑色）。这样，图像中的像素要么为黑色，要么为白色，从而实现了二值化。图像二值化是将一幅图像的所有像素值转换为只有两个值之间的操作。通常情况下，这两个像素值是0和255，分别代表黑色和白色。通常使用threshold()函数来实现图像的二值化。1、threshold()函数。附：选择图像二值化方法的标志。
Java图像二值化，去白边实现紧包效果
05-27
本文将深入探讨如何在Java中实现图像二值化，并去除白边以实现紧包效果。 首先，我们需要理解二值化的原理。在灰度图像中，每个像素点的值介于0（黑色）到255（白色）之间。二值化就是设定一个阈值，小于阈值的像素...
b.rar_Halcon OCR_opencv 图像二值化
09-21
本项目“b.rar”中的内容是基于Halcon OCR（光学字符识别）与OpenCV库实现的图像二值化应用，尤其在Visual Studio 2008开发环境中。以下将详细介绍这两个关键词及其相关的知识点。 **Halcon OCR** Halcon是一种...
pic2Value.zip_opencv二值化_自动化
09-19
OpenCV是一个广泛应用的开源计算机视觉库，它提供了丰富的函数和工具来处理图像，包括二值化操作。"pic2Value.zip"这个压缩包中包含的就是使用OpenCV实现的自动化图像二值化的源代码。 一、OpenCV简介： OpenCV...
JAVA实现图片二值化
03-20
NULL 博文链接：https://mountain-king.iteye.com/blog/798438
基于java编写的数字图像处理代码（二值化，灰度处理，卷积滤镜）
04-02
基于java编写的数字图像处理代码。其中包括灰度处理，二值化处理，RGB色彩通道过滤以及卷积滤镜等多种算法的实现。
Java数字图像处理基础-------图像二值化处理
weixin_54963748的博客
02-11 4621
Java数字图像处理基础-------图像二值化处理 一：简介 二值化：是图像分割的一种最简单的方法。二值化可以把灰度图像转换成二值图像。把大于某个临界灰度值的像素灰度设为灰度极大值，把小于这个值的像素灰度设为灰度极小值，从而实现二值化。以下只是简单的随机定义一个灰度值的计算方法，不涉及算法，算法目前还不会； 二：代码演示 import javax.imageio.ImageIO; import javax.swing.*; import java.awt.*; import java.awt.image.
图像处理基础——（二值化）java实现
m0_70965903的博客
11-22 677
二值化的理解就是讲图片上超过某阈值的像素设为A，不超过的设为B。以至图片只存在俩种像素。
OpenCV图像处理----图像的二值化
bjsyc123456的博客
05-15 2万+
图像二值化（ Image Binarization）就是将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的黑白效果的过程。 二值化的原理 import cv2 img = cv2.imread('img/lena.jpg') # 转为灰度图 new_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) height, width = new_img.shape[0:2] # 设置阈值 thresh = 60 # 遍历每一个像素点 for row
【opencv-java】opencv简单的图片的读取、保存、彩色转灰度
gwcgwcjava的专栏
09-13 236
直接上代码 package com.xs.test.color2gray; import org.opencv.core.Core; import org.opencv.core.Mat; import org.opencv.highgui.HighGui; import org.opencv.imgcodecs.Imgcodecs; import org.opencv.imgproc.Imgproc; public class Color2Gray { public static void m
openCV 图像色彩空间转换
qq_40135848的博客
08-05 1331
openCV 图像色彩空间转换
javacv从入门到精通——第十一章深入理解JavaCV之JavaCV高级特性
ayou_llf的博客
05-03 1784
JavaCV提供了许多高级图像处理功能，包括图像滤波、边缘检测、形态学操作、图像分割和特征提取等。
[OpenCV学习日记-java]-10-Canny边缘检测
Timeless小帅的博客
01-23 713
Canny边缘检测 Canny边缘检测算法是一种对噪声比较敏感的边缘检测算法 所以通常使用Canny检测之前,收先对图像进行降噪 一个完整的Canny边缘检测有以下几个步骤组成 高斯模糊：完成噪声抑制 灰度转换：在灰度图像上计算梯度值 计算梯度：使用Sobel/Scharr 非最大信号抑制：在梯度图像上寻找局部最大轮廓 高低阈值连接：吧边缘像素连接为线段，形成完整边缘轮廓 Canny边缘检测是...
java+opencv二值化图片效果好的方法
04-07
您好，关于java opencv二值化图片效果好的方法，可以使用adaptiveThreshold函数进行自适应阈值处理，可以获得更好的二值化效果。您可以参考以下代码： Mat srcImage = Imgcodecs.imread("your_image_path"); Mat ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值