[置顶] 图片搜索算法

最新推荐文章于 2024-08-16 22:05:05 发布
最新推荐文章于 2024-08-16 22:05:05 发布
阅读量97 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java
原文链接：http://www.cnblogs.com/dyllove98/p/3196545.html 
package com.metarnet.util;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;
import com.sun.image.codec.jpeg.ImageFormatException;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageDecoder;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

/**
 * 图片工具类，主要针对图片水印处理
 * @author  yanfan
 */
public class ImageHelper {
	/**
	 * 生成缩略图 <br/>
	 * 保存:ImageIO.write(BufferedImage, imgType[jpg/png/...], File);
	 * @param source 原图片
	 * @param width 缩略图宽
	 * @param height 缩略图高
	 * @param b 是否等比缩放
	 * */
	public static BufferedImage thumb(BufferedImage source, int width,int height, boolean b) {
		// targetW，targetH分别表示目标长和宽
		int type = source.getType();
		BufferedImage target = null;
		double sx = (double) width / source.getWidth();
		double sy = (double) height / source.getHeight();
		if (b) {
			if (sx > sy) {
				sx = sy;
				width = (int) (sx * source.getWidth());
			} else {
				sy = sx;
				height = (int) (sy * source.getHeight());
			}
		}
		if (type == BufferedImage.TYPE_CUSTOM) { // handmade
			ColorModel cm = source.getColorModel();
			WritableRaster raster = cm.createCompatibleWritableRaster(width,height);
			boolean alphaPremultiplied = cm.isAlphaPremultiplied();
			target = new BufferedImage(cm, raster, alphaPremultiplied, null);
		} else
		{
			target = new BufferedImage(width, height, type);
		}
		Graphics2D g = target.createGraphics();
		g.setRenderingHint(RenderingHints.KEY_RENDERING,RenderingHints.VALUE_RENDER_QUALITY);
		g.drawRenderedImage(source, AffineTransform.getScaleInstance(sx, sy));
		g.dispose();
		return target;
	}
	/**
	 * 图片水印
	 * @param imgPath 待处理图片
	 * @param markPath 水印图片
	 * @param savePath 文件保存位置
	 * @param x 水印位于图片左上角的 x 坐标值
	 * @param y 水印位于图片左上角的 y 坐标值
	 * @param alpha 水印透明度 0.1f ~ 1.0f
	 * @throws IOException 
	 * */
	public static void waterMark(String imgPath, String markPath,String savePath, int x, int y,float alpha) throws IOException
	{
		BufferedImage img = waterMark(ImageIO.read(new File(imgPath)),ImageIO.read(new File(markPath)), x, y, alpha);
		FileOutputStream out = new FileOutputStream(savePath);
		JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
		encoder.encode(img);
		out.close();
	}
	/**
	 * 图片水印
	 * @param imgPath 待处理图片
	 * @param markPath 水印图片
	 * @param x 水印位于图片左上角的 x 坐标值
	 * @param y 水印位于图片左上角的 y 坐标值
	 * @param alpha 水印透明度 0.1f ~ 1.0f
	 * @throws IOException 
	 * */
	public static BufferedImage waterMark(String imgPath, String markPath, int x, int y,float alpha) throws IOException
	{
		return waterMark(ImageIO.read(new File(imgPath)),ImageIO.read(new File(markPath)), x, y, alpha);
	}
	/**
	 * 图片水印
	 * @param img 待处理图片
	 * @param srcImg 水印图片
	 * @param x 水印位于图片左上角的 x 坐标值
	 * @param y 水印位于图片左上角的 y 坐标值
	 * @param alpha 水印透明度 0.1f ~ 1.0f
	 * @throws IOException 
	 * */
	public static BufferedImage waterMark(Image img, Image srcImg, int x, int y,float alpha){
		// 加载待处理图片文件
		BufferedImage image = new BufferedImage(img.getWidth(null),img.getHeight(null), BufferedImage.TYPE_INT_RGB);
		Graphics2D g = image.createGraphics();
		g.drawImage(img, 0, 0, null);
		g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,alpha));
		g.drawImage(srcImg, x, y, null);
		g.dispose();
		return image;
	}
	/**
	 * 文字水印
	 * 
	 * @param imgPath 待处理图片
	 * @param savePath 文件保存位置
	 * @param text 水印文字
	 * @param font 水印字体信息
	 * @param color 水印字体颜色
	 * @param x 水印位于图片左上角的 x 坐标值
	 * @param y 水印位于图片左上角的 y 坐标值
	 * @param alpha 水印透明度 0.1f ~ 1.0f
	 */
	public static void textMark(String imgPath,String savePath, String text, Font font,Color color, int x, int y, float alpha) throws IOException
	{
		BufferedImage img = textMark(ImageIO.read(new File(imgPath)), text, font, color, x, y, alpha);
		FileOutputStream out = new FileOutputStream(savePath);
		JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
		encoder.encode(img);
		out.close();
	}
	/**
	 * 文字水印
	 * 
	 * @param imgPath 待处理图片
	 * @param text 水印文字
	 * @param font 水印字体信息
	 * @param color 水印字体颜色
	 * @param x 水印位于图片左上角的 x 坐标值
	 * @param y 水印位于图片左上角的 y 坐标值
	 * @param alpha 水印透明度 0.1f ~ 1.0f
	 */
	public static BufferedImage textMark(String imgPath, String text, Font font,Color color, int x, int y, float alpha) throws IOException
	{
		return textMark(ImageIO.read(new File(imgPath)), text, font, color, x, y, alpha);
	}
	/**
	 * 文字水印
	 * 
	 * @param img 待处理图片
	 * @param text 水印文字
	 * @param font 水印字体信息
	 * @param color 水印字体颜色
	 * @param x 水印位于图片左上角的 x 坐标值
	 * @param y 水印位于图片左上角的 y 坐标值
	 * @param alpha 水印透明度 0.1f ~ 1.0f
	 */
	public static BufferedImage textMark(Image img, String text, Font font,Color color, int x, int y, float alpha) {
		Font Dfont = (font == null) ? new Font("宋体", 20, 13) : font;
		BufferedImage image = new BufferedImage(img.getWidth(null),img.getHeight(null), BufferedImage.TYPE_INT_RGB);
		Graphics2D g = image.createGraphics();
		g.drawImage(img, 0, 0, null);
		g.setColor(color);
		g.setFont(Dfont);
		g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,alpha));
		g.drawString(text, x, y);
		g.dispose();
		return image;
	}
	
	/**
	 * 读取JPEG图片
	 * @param filename 文件名
	 * @return BufferedImage 图片对象
	 */
	public static BufferedImage readJPEGImage(String filename) throws ImageFormatException, IOException
	{
		InputStream imageIn = new FileInputStream(new File(filename));
		JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(imageIn);
		BufferedImage sourceImage = decoder.decodeAsBufferedImage();
		return sourceImage;
	}
	
	/**
	 * 读取JPEG图片
	 * @param filename 文件名
	 * @return BufferedImage 图片对象
	 */
	public static BufferedImage readPNGImage(String filename) throws IOException
	{
		File inputFile = new File(filename);  
        BufferedImage sourceImage = ImageIO.read(inputFile);
		return sourceImage;
	}
	
	/**
	 * 灰度值计算
	 * @param pixels 像素
	 * @return int 灰度值
	 */
	public static int rgbToGray(int pixels) {
		int _red = (pixels >> 16) & 0xFF;
		int _green = (pixels >> 8) & 0xFF;
		int _blue = (pixels) & 0xFF;
		return (int) (0.3 * _red + 0.59 * _green + 0.11 * _blue);
	}
	
	/**
	 * 计算数组的平均值
	 * @param pixels 数组
	 * @return int 平均值
	 */
	public static int average(int[] pixels) {
		float m = 0;
		for (int i = 0; i < pixels.length; ++i) {
			m += pixels[i];
		}
		m = m / pixels.length;
		return (int) m;
	}
	/**
	 * 计算图片指纹
	 * @param filename 文件名
	 * @return 图片指纹
	 * @throws IOException 
	 */
	public static String produceFingerPrint(String filename) throws IOException
	{
		return produceFingerPrint(ImageIO.read(new File(filename)),8);
	}
	/**
	 * 计算图片指纹
	 * @param filename 文件名
	 * @return 图片指纹
	 */
	public static String produceFingerPrint(BufferedImage source)
	{
		return produceFingerPrint(source,8);
	}
	/**
	 * 计算图片指纹
	 * @param filename 文件名
	 * width 
	 * @return 图片指纹
	 */
	public static String produceFingerPrint(BufferedImage source,int lever) {
		// 第一步，缩小尺寸。
		// 将图片缩小到width*height个像素。这一步的作用是去除图片的细节，只保留结构、明暗等基本信息，摒弃不同尺寸、比例带来的图片差异。
		BufferedImage thumb = ImageHelper.thumb(source, lever, lever, false);
		// 第二步，简化色彩。
		// 将缩小后的图片，转为64级灰度。也就是说，所有像素点总共只有64种颜色。
		int[] pixels = new int[lever * lever];
		for (int i = 0; i < lever; i++) {
			for (int j = 0; j < lever; j++) {
				pixels[i * lever + j] = ImageHelper.rgbToGray(thumb.getRGB(i, j));
			}
		}
		// 第三步，计算平均值。
		// 计算所有像素的灰度平均值。
		int avgPixel = ImageHelper.average(pixels);
		// 第四步，比较像素的灰度。
		// 将每个像素的灰度，与平均值进行比较。大于或等于平均值，记为1；小于平均值，记为0。
		int[] comps = new int[lever * lever];
		for (int i = 0; i < comps.length; i++) {
			if (pixels[i] >= avgPixel) {
				comps[i] = 1;
			} else {
				comps[i] = 0;
			}
		}
		// 第五步，计算哈希值。
		// 将上一步的比较结果，组合在一起，就构成了一个64位的整数，这就是这张图片的指纹。组合的次序并不重要，只要保证所有图片都采用同样次序就行了。
		StringBuffer hashCode = new StringBuffer();
		for (int i = 0; i < comps.length; i+= 4) {
			int result = comps[i] * (int) Math.pow(2, 3) + comps[i + 1] * (int) Math.pow(2, 2) + comps[i + 2] * (int) Math.pow(2, 1) + comps[i + 2];
			hashCode.append(binaryToHex(result));
		}
		// 得到指纹以后，就可以对比不同的图片，看看64位中有多少位是不一样的。
		return hashCode.toString();
	}
	/**
	 * 计算图片指纹
	 * @param filename 文件名
	 * width 
	 * @return 图片指纹
	 */
	public static String produceFingerPrint(BufferedImage source,int width,int height) {
		// 第一步，缩小尺寸。
		// 将图片缩小到width*height个像素。这一步的作用是去除图片的细节，只保留结构、明暗等基本信息，摒弃不同尺寸、比例带来的图片差异。
		BufferedImage thumb = ImageHelper.thumb(source, width, height, false);
		// 第二步，简化色彩。
		// 将缩小后的图片，转为64级灰度。也就是说，所有像素点总共只有64种颜色。
		int[] pixels = new int[width * height];
		for (int i = 0; i < width; i++) {
			for (int j = 0; j < height; j++) {
				pixels[i * height + j] = ImageHelper.rgbToGray(thumb.getRGB(i, j));
			}
		}
		// 第三步，计算平均值。
		// 计算所有像素的灰度平均值。
		int avgPixel = ImageHelper.average(pixels);
		// 第四步，比较像素的灰度。
		// 将每个像素的灰度，与平均值进行比较。大于或等于平均值，记为1；小于平均值，记为0。
		int[] comps = new int[width * height];
		for (int i = 0; i < comps.length; i++) {
			if (pixels[i] >= avgPixel) {
				comps[i] = 1;
			} else {
				comps[i] = 0;
			}
		}
		// 第五步，计算哈希值。
		// 将上一步的比较结果，组合在一起，就构成了一个64位的整数，这就是这张图片的指纹。组合的次序并不重要，只要保证所有图片都采用同样次序就行了。
		StringBuffer hashCode = new StringBuffer();
		for (int i = 0; i < comps.length; i+= 4) {
			int result = comps[i] * (int) Math.pow(2, 3) + comps[i + 1] * (int) Math.pow(2, 2) + comps[i + 2] * (int) Math.pow(2, 1) + comps[i + 2];
			hashCode.append(binaryToHex(result));
		}
		// 得到指纹以后，就可以对比不同的图片，看看64位中有多少位是不一样的。
		return hashCode.toString();
	}
	/**
	 * 计算"汉明距离"（Hamming distance）。
	 * 如果不相同的数据位不超过5，就说明两张图片很相似；如果大于10，就说明这是两张不同的图片。
	 * @param sourceHashCode 源hashCode
	 * @param hashCode 与之比较的hashCode
	 */
	public static int hammingDistance(String sourceHashCode, String hashCode) {
		int difference = 0;
		int len = sourceHashCode.length();
		for (int i = 0; i < len; i++) {
			if (sourceHashCode.charAt(i) != hashCode.charAt(i)) {
				difference ++;
			}
		}
		return difference;
	}
	/**
	 * 计算"汉明距离"（Hamming distance）的相似度
	 */
	public static double hammingCompare(String sourceHashCode, String hashCode)
	{
		double difference = 0;
		if(sourceHashCode.length() == hashCode.length() && sourceHashCode.length()!=0)
		{
			
			int len = 0;
			for (int i = 0; i < sourceHashCode.length(); i++) {
				if (sourceHashCode.charAt(i) == hashCode.charAt(i)) {
					len ++;
				}
			}
			difference = (double)len/sourceHashCode.length();
		}
		return difference;
	}
	/**
	 * 二进制转为十六进制
	 * @param int binary
	 * @return char hex
	 */
	private static char binaryToHex(int binary) {
		char ch = ' ';
		switch (binary)
		{
		case 0:
			ch = '0';
			break;
		case 1:
			ch = '1';
			break;
		case 2:
			ch = '2';
			break;
		case 3:
			ch = '3';
			break;
		case 4:
			ch = '4';
			break;
		case 5:
			ch = '5';
			break;
		case 6:
			ch = '6';
			break;
		case 7:
			ch = '7';
			break;
		case 8:
			ch = '8';
			break;
		case 9:
			ch = '9';
			break;
		case 10:
			ch = 'a';
			break;
		case 11:
			ch = 'b';
			break;
		case 12:
			ch = 'c';
			break;
		case 13:
			ch = 'd';
			break;
		case 14:
			ch = 'e';
			break;
		case 15:
			ch = 'f';
			break;
		default:
			ch = ' ';
		}
		return ch;
	}
}

#################################测试代码#########################################

 

package com.metarnet.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class SimilarImageSearch {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		List<String> hashCodes = new ArrayList<String>();
	    String filename = System.getProperty("user.dir") + "\\images\\";
	    String hashCode = null;
	    String sourceHashCode = ImageHelper.produceFingerPrint(filename + "source.jpg");
		System.out.println("原图片"+filename + "source.jpg指纹："+sourceHashCode);
	    for (int i = 0; i < 7; i++)
        {
	    	String filePath = filename + "example" + (i + 1) + ".jpg";
		    hashCode = ImageHelper.produceFingerPrint(filePath);
		    hashCodes.add(hashCode);
		    System.out.println("图片："+filePath+"的指纹："+hashCode);
        }
		for (int i = 0; i < hashCodes.size(); i++)
        {
			double difference = ImageHelper.hammingCompare(sourceHashCode, hashCodes.get(i));
		    System.out.print("汉明距离:"+difference+"     ");
		    System.out.println("source.jpg图片跟example"+(i+1)+".jpg相似度："+difference*100+"%");
        }
		
	}
}


 

 

转载于:https://www.cnblogs.com/dyllove98/p/3196545.html

图片搜索算法
代码狂
07-17 2015
package com.metarnet.util; import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import java.awt.Image; import java.awt.RenderingHints; import java.
【毕业设计】图像检索算法（以图搜图）
caxiou的博客
11-18 4446
🔥 Hi，大家好，这里是丹成学长的毕设系列文章！🔥 对毕设有任何疑问都可以问学长哦!这两年开始，各个学校对毕设的要求越来越高，难度也越来越大… 毕业设计耗费时间，耗费精力，甚至有些题目即使是专业的老师或者硕士生也需要很长时间，所以一旦发现问题，一定要提前准备，避免到后面措手不及，草草了事。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的新项目是🚩图像检索🥇学长这里给一个题目综合评分(每项满分5分)难度系数：4分工作量：4分创新点：3分🧿。
图搜索的通用算法
11-12
图搜索的通用算法
图像检索算法 TODO
weixin_41521681的博客
12-15 1484
图像检索算法 TODO 图像检索：是从一堆图片中找到与待匹配的图像相似的图片，就是以图找图。 看了两篇文章： Large-Scale Image Retrieval with Attentive Deep Local Features https://arxiv.org/pdf/1612.06321v4.pdf Aggregated Deep Local Features for Remote SensingImage Retrieval https://arxiv.org/pdf/1903.0946
图搜索算法详解
专注于人工智能领域的小何尚
04-21 2642
图搜索算法是指在图结构中寻找从起点到终点的路径的算法。图结构是一种非线性数据结构，由节点和边组成，其中节点表示数据实体，边表示节点之间的关系。图搜索算法的目的是找到从起点到终点的最优路径，使得搜索过程更加高效、准确。
图像检索算法
weixin_30532837的博客
03-25 437
图像检索：是从一堆图片中找到与待匹配的图像相似的图片，就是以图找图。 看了两篇文章： Large-Scale Image Retrieval with Attentive Deep Local Features https://arxiv.org/pdf/1612.06321v4.pdf Aggregated Deep Local Features for Remote SensingI...
计算机视觉——BOF图像检索算法
qq_42678341的博客
05-24 2513
Bag of Feature 是一种图像特征提取方法，它借鉴了文本分类的思路（Bag of Words），从图像抽象出很多具有代表性的「关键词」，形成一个字典，再统计每张图片中出现的「关键词」数量，得到图片的特征向量。 Bag of Words 模型 要了解「Bag of Feature」，首先要知道「Bag of Words」。「Bag of Words」 是文本分类中一种通俗易懂的策略。一般来讲，如果我们要了解一段文本的主要内容，最行之有效的策略是抓取文本中的关键词，根据关键词出现的频率确定这段文本的中
相似图片搜索算法介绍
热门推荐
roguesir的博客
08-21 1万+
相似图片搜索算法介绍
【智能算法】图搜索算法
最新发布
大雨的博客
08-16 2954
图搜索算法的应用范围极为广泛，它在我们日常生活的方方面面都扮演着至关重要的角色。在互联网技术飞速发展的今天，图搜索算法成为了网络路由不可或缺的一部分，它负责在错综复杂的网络结构中，为数据包找到一条从源头到目的地的高效路径，确保信息能够以最快的速度传递。
图片搜索（java实现）
11-25
这是一个用pHash算法实现的图像搜索实例，供大家相互学习参考。
图像检索：几种基于纹理特征的图像检索算法
dianyimo9099的博客
11-21 1667
本文节选自《基于纹理的图像检索算法研究》。描述了几种基于纹理特征的图像检索算法。 第 3 章基于纹理特征的图像检索 3.2 基于灰度共生矩阵的纹理分析法 灰度共生矩阵是分析纹理特征的一种有效方法，该方法研究了图像纹理中灰度级的空间依赖关系。它对灰度的分布特性是通过对灰度值不同的像素的分布来表示的，同时这些像素对空间位置关系和分布特性也得到了体现。主要过程是，以像...
Bag of Features (BOF)图像检索算法
彼岸花
04-13 6705
Bag of features（Bof）一种是用于图像和视频检索的算法。此算法对于不同角度，光照的图像，基本都能在图像库中正确检索。 检索就要进行比对。两幅不同的图像如何比对，比对什么，这就需要提炼出每幅图像中精练的东西出来进行比较。正如超市中的条形码，就能很好的反映出一件商品的所有特征。因此概括的来说，bof就是生成每幅图像的“条形码”来进行检索。实验中，我们有一个包含100幅图像的小型图
Bag of features算法--图像检索
qq_52364666的博客
06-06 539
目录 一、Bag of features算法 1、算法原理 2、算法步骤 3、补充：K-means算法 二、实验分析 1、收集图片 2、实验源码 2、运行结果 3、实验小结 一、Bag of features算法 1、算法原理 Bag of features算法一种是用于图像和视频检索的算法，该算法对于不同角度、光照的图像，基本都能在图像库中正确检索。 2、算法步骤 （1）收集图片，用sift算法生成图像库中没附图的特征及描述符。 （2）用K-means算法对图像库中的特.
图像检索Image Retrieval相关算法汇总
Puremelo
09-26 9715
乘积量化PQ（Product Quantization）： PQ算法将D维空间切分为M个D/M维的子空间：假设现得到每张图片特征向量维度为128维，共256张图片。为了加速距离运算，现将128维向量切分成8段，如下图所示。 分别在每一段所表示的子空间中进行K-means聚类，之后在每一段中用距离该段内距离最近的聚类中心的编号来作为索引值，即每一个128维向量被压缩为8个索引值表示的向量。...
基本图算法之图的搜索
Mr.wei的小站
07-26 1022
介绍完图的存储结构以及如何从外部读取txt文件来创建一个图的内容，我们开始介绍关于图的入门的一个算法——图的搜索，也就是我们常说的图的遍历，与（二叉）树的遍历方式（先序遍历、中序遍历、后序遍历、层次遍历）类似，首先图的遍历有两种方式 广度优先遍历（BFS）、深度优先遍历（DFS）。 　关于基本的[DFS](https://en.wikipedia.org/wiki/Depth-first_searc
chatGPT教你算法(3)——常用的图搜索算法
刘炫320的博客
12-08 4787
这一次我们将会介绍常用的图搜索算法，分别BFS广度优先搜索和DFS深度优先搜索。常用的图搜索算法包括广度优先搜索（BFS）和深度优先搜索（DFS）。广度优先搜索（BFS）是一种有序搜索算法，它从图的起点开始，按照图的宽度（即按照节点之间的距离）进行搜索。BFS会把起点与它相邻的所有节点都搜索一遍，然后再搜索与这些节点相邻的节点，以此类推，直到搜索完整张图。BFS可以用来找出两个节点之间的最短路径。 上述代码样例中，首先定义了一张带权无向图，然后定义了一个访问标记数组用来记录每个节点是否被访问过。接着，定义了
java实现图片搜索_图-图的表示、搜索算法及其Java实现
weixin_39938855的博客
02-13 266
1 importjava.util.ArrayList;2 importjava.util.Iterator;3 importjava.util.LinkedList;4 importjava.util.Queue;56 classGraph{7 ArrayList vertexs=new ArrayList();8 ArrayList edges=new ArrayList();...
图-图的表示、搜索算法及其Java实现
weixin_30649859的博客
04-20 516
1.图的表示方法 图：G=(V,E)，V代表节点，E代表边。 图有两种表示方法：邻接链表和邻接矩阵 邻接链表因为在表示稀疏图（边的条数|E|远远小于|V|²的图）时非常紧凑而成为通常的选择。 如果需要快速判断任意两个节点之间是否有边相连，可能也需要使用邻接矩阵表示法。 邻接链表表示法的鲁棒性很高，可以对其进行简单修改来支持许多其他的图变种。 邻接链表的一个潜在缺陷是无法快速判断一条...
图片中的汉字数字自动提取算法介绍
7. 图片置顶与桌面中央放置：资源中提到的将图片放置在桌面中央，很可能是为了便于算法更高效地识别图片中的信息。这可能意味着算法实现需要在特定的图像位置搜索和定位文字。 8. 修改对应目录名的需求：资源中提到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值