opencv微信二维码引擎的使用(for java)

最新推荐文章于 2024-04-26 11:07:27 发布
最新推荐文章于 2024-04-26 11:07:27 发布
阅读量7.1k 收藏 4
点赞数 3
分类专栏： opencv 文章标签： java opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VQB01799/article/details/118928239
版权

前面讲了windows系统下opencv+opencv的编译方法，编译方法和编译好的文件如下：

Windows下联合编译opencv+opencv_contrib微信二维码引擎

OpenCV4.5.2（windows for java）

这次讲下微信二维码引擎的使用方法，为了方便使用，不需要手动添加dll等，对jar、dll、微信配置文件做了集成，重新编译了jar。这个是windows下的，如果要在linux下使用，需要在config下加入对应的so。重新编译的jar如下：

含微信二维码引擎的重编译opencv-452.jar

具体新增如下：
在这里插入图片描述                 在这里插入图片描述
1.把jar添加到项目后，调用Config.load();自动加载dll和微信配置文件。
2.img2mat和mat2img是封装好的图片和Mat转换方法，默认图片格式img为BufferedImage.TYPE_3BYTE_BGR（imgType），mat为CvType.CV_8UC3（matType），通过setType(int imgType, int matType)可进行修改，每调用一次转换方法type值会重置为默认值。

下面以具体例子讲解下使用方法：

package vqb;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;

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

import org.opencv.config.Config;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;
import org.opencv.utils.Converters;
import org.opencv.videoio.VideoCapture;
import org.opencv.wechat_qrcode.WeChatQRCode;

public class Test {
	private static JFrame frame = new JFrame("camera");
	private static JPanel panel = new JPanel();
	private static int width = 900;
	private static int height = 600;
	
	static {
		//加载opencv库
		Config.load();
	}
	
	public static void main(String... args) {
		open();
	}
	
	public static void open() {
		frame.setSize(width,height);
		frame.setLocationRelativeTo(null);
		frame.setResizable(false);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setContentPane(panel);
		//openCamera();
		openPic();
	}
	
	private static void openCamera() {
		VideoCapture camera = new VideoCapture(0);
		if(!camera.isOpened()){
			System.out.println("Camera Error");
			return;
		}
		Mat img = new Mat();
		while(true){
			camera.read(img);
			deCode(img);
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			panel.repaint();
		}
	}
	
	private static void openPic() {
		String base64 = "data:image/jpg;base64,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";
		Mat img = Converters.img2mat(base64);
		System.out.println(img.width());
		deCode(img);
	}
	
	private static void deCode(Mat img) {
		//微信二维码对象，要返回二维码坐标前2个参数必传；后2个在二维码小或不清晰时必传。
		WeChatQRCode we = new WeChatQRCode(Config.detector_prototxt_path,Config.detector_caffe_model_path,Config.super_resolution_prototxt_path,Config.super_resolution_caffe_model_path);
		List<Mat> points = new ArrayList<Mat>();
		//微信二维码引擎解码，返回的valList中存放的是解码后的数据，points中Mat存放的是二维码4个角的坐标
		List<String> valList = we.detectAndDecode(img, points);
		for(int i = 0; i < valList.size(); i++) {
			//根据坐标画矩形，就是二维码上的那个框
			Imgproc.rectangle(img,new Point(points.get(i).get(0, 0)[0],points.get(i).get(0, 1)[0]),new Point(points.get(i).get(2, 0)[0],points.get(i).get(2, 1)[0]),new Scalar(0, 0, 255),2);
			//opencv的Imgproc.putText方法中文会乱码，如果是英文可以直接使用。
			//Imgproc.putText(img, valList.get(i), new Point(points.get(i).get(0, 0)[0],points.get(i).get(0, 1)[0] - 10), 18, 1, new Scalar(0, 0, 255), 2);
		}
		BufferedImage image = Converters.mat2img(img);
		//因为opencv的Imgproc.putText方法中文会乱码，所以自己写了一个添加文本的方法。
		putText(image, valList, points);
		int w = image.getWidth() > panel.getWidth() ? panel.getWidth() : image.getWidth();
		int h = image.getHeight() > panel.getHeight() ? panel.getHeight() : image.getHeight();
		panel.getGraphics().drawImage(image, (panel.getWidth()-w)/2, (panel.getHeight()-h)/2, w, h, panel);
	}
	//根据坐标为图片添加文字
	private static void putText(BufferedImage img, List<String> textList, List<Mat> points) {
		Graphics2D g = img.createGraphics();
		Font font = new Font("宋体", Font.BOLD, 18);
		g.setColor(Color.red);
		g.setFont(font);
		for(int i = 0; i < textList.size(); i++) {
			g.drawString(textList.get(i), (float)points.get(i).get(0, 0)[0], (float)points.get(i).get(0, 1)[0] - 10);
		}
		g.dispose();
	}
	
}

电脑上没有摄像头，只测试了二维码图片的扫码，调用摄像头扫码方法虽然没有进行测试，应该没有太大问题。如果发现有什么问题可以留言给我。

VQB01799
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 18
    评论
专栏目录
Python Scrapy中yield Request的理解
u014689510的博客
06-07 13万+
最近在看《learn scrapy》中的关于爬虫的部分，对于parse中的yield Request用法不是很理解，现在总结下。 def parse(self, response): # Get the next index URLs and yield Requests next_selector = response.xpath('//*[contains(@class,' '
B78XH:B78XH是Microsoft Flight Simulator中的默认波音787-10的开源和免费修改
04-04
B78XH（B787-10重型） 关于 B78XH是Microsoft Flight Simulator中的默认波音787-10的开源和免费修改。 普通版与WO版 WO发行版与普通发行版相同，但该发行版不包含管理器。 （有效负载和SimRate管理器） 功能概述 调频 净资产值 CLB速度限制 CLB选定速度 CLB选定的速度可以通过ECON提示删除 CLB可设定的过渡高度 CLB FMC命令的速度以洋红色突出显示 CLB页面标题取决于命令的速度（ACT / MOD ECON CLB，ACT / MOD xxxKT CLB，...） CRZ可设定的选定速度 CRZ FMC命令的速度以洋红色突出显示 CRZ选定的速度可以通过ECON提示删除 CRZ页面标题取决于命令的速度（ACT / MOD ECON CRZ，ACT / MOD xxxKT CRZ，...） 巡航爬升 巡航下降 提前下降
android颜色大全
xhxxxxhx的博客
11-20 1万+
#FFFFFF      　　#FFFFF0      　　#FFFFE0      　　#FFFF00      　　#FFFAFA      　　#FFFAF0      　　#FFFACD      　　#FFF8DC      　　#FFF5EE      　　#FFF0F5      　　#FFEFD5      　　#FFEBCD     
【OpenCV】（一）wechat_qrcode检测二维码
最新发布
wave789的博客
04-26 665
opencv-4.8.0之前的版本wechat_qrcode检测二维码是矩形检测；opencv-4.8.0+的版本wechat_qrcode检测二维码是关键点检测；
linux ssh 登陆后欢迎界面 banner 设置操作
蜀山下努力奔跑的老菜鸡
04-02 1万+
效果图： 哈哈，枯燥的工作中，每天链接本地服务器都弹出一个可爱的小鸡，心情都会变好纳~ 实现： linux 系统中 /etc/motd 文件用来存储欢迎信息 用vi编辑输入 .=""=. / _ _ \ | d b | \ /\ / ,/’-=/=-’, / / \ \ | / \ | / \ / / ‘. .’ |~~| /|\ /|\ 之后保存即可生效，最后附上更多图案选项 banner大全 如下： /** .,:,
ZCMU--1925: hx & xh‘s game(C语言)
小小小Why的博客
07-21 4242
xh和hx玩一个游戏，过程如下首先，hx给xh等差数列A，告诉xh首项a和公差d，让xh求出数列A前n项和。于是xh将结果求出，并得到一个新的数列B，他也让hx求数列B前n项和。hx也按xh的要求做了，结果又得到一个数列C，他再次让xh求数列C前n项和。xh又将结果求出，得到数列D，他不想再为难hx了，现在让你求数列D的第i项。该题含有多组测试数据，每组一行，包含三个正整数a(0≤a≤100)，d(0≤d≤100)，i(1≤i≤100000000)。由于数据过大，输出结果mod2017...。...
当vector中存储的类型为指针时，vector.clear()的执行结果
cyd_shuihan的博客
05-28 4万+
#include #include using namespace std; class A { private : int nId; public: A(int n) { nId = n; cout << nId << " contructor" << endl; } ~A( ) {cout << nId << " destructor" << endl; } };
opencv + 微信二维码识别
04-12
标题“opencv + 微信二维码识别”揭示了一个技术项目，该项目使用OpenCV库与微信二维码识别功能相结合，创建了一个Java编程的应用程序。OpenCV是一个强大的计算机视觉库，广泛用于图像处理和计算机视觉任务，如图像...
opencv4.5.5带微信二维码识别的编译好的库，c++直接调用。
05-04
在标题和描述中提到的是OpenCV 4.5.5版本，这是一个已经预编译并且集成了微信二维码识别功能的版本，使得开发者可以直接在C++项目中调用相关接口进行二维码识别，无需额外配置或编写识别代码。 OpenCV 4.5.5的更新...
含微信二维码引擎的重编译opencv-452.jar
07-20
重新编译的jar，集成了dll和微信扫码模块的各项配置文件，扩展了Converters类。 具体可参考：https://blog.csdn.net/VQB01799/article/details/118928239
基于OpenCV开源的微信二维码引擎.zip
03-23
【标题】基于OpenCV开源的微信二维码引擎 在IT领域，二维码已经成为数据交换的重要载体，尤其是在移动设备上，如微信的广泛应用。OpenCV（Open Source Computer Vision Library）是一个跨平台的计算机视觉库，广泛...
基于OpenCV开源的微信二维码引擎移植的二维码扫码识别库.zip
04-05
多语言支持：尽管OpenCV主要使用C++编写，但它提供了丰富的API绑定，支持包括C、Python、Java、MATLAB、JavaScript等多种编程语言，方便不同领域的开发者使用。 开源与免费：OpenCV遵循BSD开源许可证发布，用户...
00001[我的第一个BASE64,博客留念]
logohoo的博客
01-18 1万+
ACDN
ERROR 2002 (HY000): Can’t connect to local MySQL server through socket ‘/var mysql 启动不了
码农老斑鸠的专栏
09-15 1万+
ps -A | grep -i mysql kill 列出来的进程 service mysql start 我的问题就解决了 ---------------------------------------------- Fedora8启动mysql 报错： ERROR 2002 (HY000): Can’t connect to local MySQL server through s
java学习1-初识java编程
05-04 2427
需要安装的软件 1、java jre 2、java JDK EE版本 3、UltraEdit 网站：http://www.oracle.com/technetwork/java/javase/downloads/index.html 本人安装java目录为C:\Java\jdk1.8.0_05\bin。 javac----编译器 java----字节码解释器 jar---jar包压
数据应用流水线-数据应用
loki的博客
09-29 969
软件系统主要包括：算法与数据。 一切的根源都来源于数据，抛开业务流程，软件全生命周期只考虑一件事--数据存储于应用。 上图就是一个数据应用的全流程结构图。 数据源：代表着底层的数据存储。 数据接入：数据总线，支持对底层各类数据源的读写。 数据计算：支持数据的分布式批量加工计算。 数据服务：支持对数据加工后的数据提供API接口服务。 数据消费：实现数据的应用。 ...
opencv学习笔记（五）-将图片写成视频
孤旅人。。。的博客
09-04 3570
这次我要用opencv把一堆图片合成一个avi的视频，图片素材可以自己用KMPlayer制作，程序如下： +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#include "cv.h" #include "highgui.h"int main() { CvS
pythonsvd内存不足_[已解决]VBS能否读写大于系统内存大小的二进制文件？
weixin_39632693的博客
12-21 7632
'************************************************************************'名称：解决云文件被禁 HexTool-XoR_By_Yu2n.vbs'功能：简单加密/解密文件'说明：不要用来操作重要文件，本人不对任何结果负责。'环境：Windows XP 以上 ？'效率：加密/解密一个 16G 大小的文件，耗时不到 1 秒。'使用...
android在线浏览
热门推荐
Melinda_meng的博客
07-02 35万+
MainActivity。java package com.example.internetimageview; import java.io.IOException; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.MalformedURLException; import java.
opencvsharp 微信二维码引擎 demo
10-14
OpenCvSharp微信二维码引擎Demo是一个基于OpenCvSharp库开发的针对微信二维码识别的示例程序。微信二维码引擎是指能够识别微信扫一扫功能中的二维码的引擎。下面我将对这个Demo进行简要介绍。 首先，这个Demo使用了OpenCvSharp库，该库是OpenCV的C#封装，能够方便地在C#中使用OpenCV的功能。由于微信二维码引擎是基于图像识别的，OpenCV提供了强大的图像处理和计算机视觉功能，因此选择OpenCvSharp作为开发工具十分合适。 这个Demo主要实现了微信二维码的识别功能。在使用之前，首先需要安装OpenCvSharp库，并完成相关的配置。然后，我们可以通过该Demo将微信二维码图片加载进来，使用OpenCvSharp库提供的图像处理方法进行处理和分析。 在识别过程中，Demo会利用OpenCvSharp库中的二维码识别算法来检测和解码图像中的二维码。通过对二维码的解码，我们可以获取到其中存储的信息，比如链接、文本等。 最后，Demo会将识别出的二维码信息以文本的形式输出，方便用户查看和使用。此外，我们还可以根据需要进行二维码的进一步处理，比如裁剪、旋转等。 总之，OpenCvSharp微信二维码引擎Demo是一个基于OpenCvSharp库开发的示例程序，能够实现微信二维码的识别功能。通过使用这个Demo，我们可以了解和学习如何使用OpenCvSharp库进行微信二维码的识别，从而为后续的二维码应用开发提供了基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值