python实现误差扩散、Floyd-Steinberg 抖动、有序抖动、Riemersma 抖动算法

news2024/11/26 0:55:06

误差扩散、Floyd-Steinberg 抖动、有序抖动、Riemersma 抖动算法

      • 1.误差扩散算法详解
        • 算法步骤
        • Floyd-Steinberg 算法
        • 公式
        • Python 实现
        • 详细解释
        • 优缺点
      • 2.有序抖动算法详解
        • 算法步骤
        • Bayer矩阵
        • 公式
        • Python 实现
        • 详细解释
        • 优缺点
      • 3.Riemersma 抖动算法详解
        • 算法步骤
        • 公式
        • Python 实现
        • 详细解释
        • 优缺点

1.误差扩散算法详解

误差扩散算法（Error Diffusion Algorithm）是一种用于图像抖动（Dithering）和半色调（Halftoning）的技术。它通过将像素的量化误差扩散到邻近像素，从而在整体上保持图像的灰度特性。这种方法通常用于图像打印和显示，特别是将灰度图像转换为二值图像时。

算法步骤
  1. 遍历图像：逐像素处理图像，从左到右，从上到下。
  2. 量化像素：将当前像素的灰度值量化为目标值（通常是0或255）。
  3. 计算误差：计算当前像素的量化误差。
  4. 扩散误差：将误差分配给邻近像素。

常见的误差扩散算法有：

  • Floyd-Steinberg算法
  • Jarvis, Judice, and Ninke算法
  • Stucki算法
Floyd-Steinberg 算法

Floyd-Steinberg 算法是最常用的误差扩散算法之一。其扩散矩阵如下：

在这里插入图片描述

这里，* 表示当前处理的像素，其他值表示扩散给邻近像素的误差比例。

公式

在这里插入图片描述

Python 实现

以下是Floyd-Steinberg误差扩散算法的Python实现代码：

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

def floyd_steinberg_dithering(image):
    """
    Floyd-Steinberg 误差扩散算法实现

    参数:
    image (PIL.Image): 灰度图像

    返回:
    PIL.Image: 二值化后的图像
    """
    # 将图像转换为灰度图像
    grayscale_image = image.convert("L")
    image_array = np.array(grayscale_image, dtype=float)
    
    # 获取图像的行和列
    rows, cols = image_array.shape
    
    # 遍历图像
    for y in range(rows):
        for x in range(cols):
            old_pixel = image_array[y, x]
            new_pixel = 0 if old_pixel < 128 else 255
            image_array[y, x] = new_pixel
            quant_error = old_pixel - new_pixel
            
            if x + 1 < cols:
                image_array[y, x + 1] += quant_error * 7 / 16
            if x - 1 >= 0 and y + 1 < rows:
                image_array[y + 1, x - 1] += quant_error * 3 / 16
            if y + 1 < rows:
                image_array[y + 1, x] += quant_error * 5 / 16
            if x + 1 < cols and y + 1 < rows:
                image_array[y + 1, x + 1] += quant_error * 1 / 16
    
    # 将处理后的数组转换为图像
    dithered_image = Image.fromarray(np.clip(image_array, 0, 255).astype(np.uint8))
    
    return dithered_image

# 示例用法
if __name__ == "__main__":
    image = Image.open('example.jpg')  # 打开原始图像
    dithered_image = floyd_steinberg_dithering(image)  # 调用Floyd-Steinberg误差扩散算法
    dithered_image.show()  # 显示二值化后的图像
    dithered_image.save('dithered_example.jpg')  # 保存二值化后的图像

    # 显示原始图像和二值化后的图像
    plt.figure(figsize=(12, 6))
    plt.subplot(1, 2, 1)
    plt.title('Original Image')
    plt.imshow(image.convert("L"), cmap='gray')
    plt.axis('off')
    
    plt.subplot(1, 2, 2)
    plt.title('Dithered Image')
    plt.imshow(dithered_image, cmap='gray')
    plt.axis('off')
    plt.show()
详细解释

  1. 读取图像和转换为灰度图像：

    image = Image.open('example.jpg')
grayscale_image = image.convert("L")

  2. 将灰度图像转换为NumPy数组：

    image_array = np.array(grayscale_image, dtype=float)

  3. 遍历图像并进行量化和误差扩散：

    for y in range(rows):
    for x in range(cols):
        old_pixel = image_array[y, x]
        new_pixel = 0 if old_pixel < 128 else 255
        image_array[y, x] = new_pixel
        quant_error = old_pixel - new_pixel
        
        if x + 1 < cols:
            image_array[y, x + 1] += quant_error * 7 / 16
        if x - 1 >= 0 and y + 1 < rows:
            image_array[y + 1, x - 1] += quant_error * 3 / 16
        if y + 1 < rows:
            image_array[y + 1, x] += quant_error * 5 / 16
        if x + 1 < cols and y + 1 < rows:
            image_array[y + 1, x + 1] += quant_error * 1 / 16

  4. 将处理后的数组转换为图像：

    dithered_image = Image.fromarray(np.clip(image_array, 0, 255).astype(np.uint8))

  5. 显示和保存二值化后的图像：

    dithered_image.show()
dithered_image.save('dithered_example.jpg')

  6. 显示原始图像和二值化后的图像：

    plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image.convert("L"), cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Dithered Image')
plt.imshow(dithered_image, cmap='gray')
plt.axis('off')
plt.show()
优缺点

优点：

  • 高效：误差扩散算法在保留图像细节和灰度特性方面非常有效。
  • 实现简单：算法逻辑简单，易于实现和理解。

缺点：

  • 可能引入噪声：在某些图像中，可能会引入明显的噪声或伪影。
  • 计算复杂度高：对大图像的处理可能较慢，特别是在高分辨率图像中。

误差扩散算法在图像抖动和半色调处理中非常有用，特别适用于需要将灰度图像转换为二值图像的应用场景，如打印和显示设备。

2.有序抖动算法详解

有序抖动算法（Ordered Dithering）是一种用于图像抖动和半色调的技术。它通过使用预先定义的抖动矩阵（dithering matrix）来量化图像像素，从而在保持图像灰度特性的同时，产生视觉上更平滑的二值图像。有序抖动算法简单且计算效率高，广泛应用于图像显示和打印。

算法步骤
  1. 生成抖动矩阵：创建一个预定义的抖动矩阵。
  2. 遍历图像：逐像素处理图像，根据抖动矩阵对每个像素进行量化。
  3. 更新像素值：将量化后的像素值更新到输出图像中。

常见的抖动矩阵有：

  • Bayer矩阵
  • Halftone矩阵
Bayer矩阵

Bayer矩阵是一种常见的抖动矩阵，可以递归生成。基本的 2 × 2 2 \times 2 2×2 Bayer矩阵如下：
在这里插入图片描述

通过递归扩展可以生成更大的矩阵，例如 4 × 4 4 \times 4 4×4 Bayer矩阵：
在这里插入图片描述

公式

在这里插入图片描述

Python 实现

以下是有序抖动算法的Python实现代码：

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

def generate_bayer_matrix(n):
    if n == 2:
        return np.array([
            [0, 2],
            [3, 1]
        ])
    else:
        smaller_matrix = generate_bayer_matrix(n // 2)
        return np.block([
            [4 * smaller_matrix + 0, 4 * smaller_matrix + 2],
            [4 * smaller_matrix + 3, 4 * smaller_matrix + 1]
        ])

def ordered_dithering(image, bayer_matrix):
    """
    有序抖动算法实现

    参数:
    image (PIL.Image): 灰度图像
    bayer_matrix (numpy.ndarray): 抖动矩阵

    返回:
    PIL.Image: 二值化后的图像
    """
    # 将图像转换为灰度图像
    grayscale_image = image.convert("L")
    image_array = np.array(grayscale_image, dtype=float)
    
    # 获取图像的行和列
    rows, cols = image_array.shape
    n = bayer_matrix.shape[0]
    
    # 遍历图像
    for y in range(rows):
        for x in range(cols):
            threshold = (bayer_matrix[y % n, x % n] + 0.5) / (n * n)
            image_array[y, x] = 255 if (image_array[y, x] / 255.0) >= threshold else 0
    
    # 将处理后的数组转换为图像
    dithered_image = Image.fromarray(image_array.astype(np.uint8))
    
    return dithered_image

# 示例用法
if __name__ == "__main__":
    image = Image.open('example.jpg')  # 打开原始图像
    bayer_matrix = generate_bayer_matrix(4)  # 生成 4x4 Bayer 矩阵
    dithered_image = ordered_dithering(image, bayer_matrix)  # 调用有序抖动算法
    dithered_image.show()  # 显示二值化后的图像
    dithered_image.save('dithered_example.jpg')  # 保存二值化后的图像

    # 显示原始图像和二值化后的图像
    plt.figure(figsize=(12, 6))
    plt.subplot(1, 2, 1)
    plt.title('Original Image')
    plt.imshow(image.convert("L"), cmap='gray')
    plt.axis('off')
    
    plt.subplot(1, 2, 2)
    plt.title('Dithered Image')
    plt.imshow(dithered_image, cmap='gray')
    plt.axis('off')
    plt.show()
详细解释

  1. 生成Bayer矩阵：

    def generate_bayer_matrix(n):
    if n == 2:
        return np.array([
            [0, 2],
            [3, 1]
        ])
    else:
        smaller_matrix = generate_bayer_matrix(n // 2)
        return np.block([
            [4 * smaller_matrix + 0, 4 * smaller_matrix + 2],
            [4 * smaller_matrix + 3, 4 * smaller_matrix + 1]
        ])

  2. 读取图像并转换为灰度图像：

    image = Image.open('example.jpg')
grayscale_image = image.convert("L")

  3. 将灰度图像转换为NumPy数组：

    image_array = np.array(grayscale_image, dtype=float)

  4. 遍历图像并根据抖动矩阵进行量化：

    rows, cols = image_array.shape
n = bayer_matrix.shape[0]

for y in range(rows):
    for x in range(cols):
        threshold = (bayer_matrix[y % n, x % n] + 0.5) / (n * n)
        image_array[y, x] = 255 if (image_array[y, x] / 255.0) >= threshold else 0

  5. 将处理后的数组转换为图像：

    dithered_image = Image.fromarray(image_array.astype(np.uint8))

  6. 显示和保存二值化后的图像：

    dithered_image.show()
dithered_image.save('dithered_example.jpg')

  7. 显示原始图像和二值化后的图像：

    plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image.convert("L"), cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Dithered Image')
plt.imshow(dithered_image, cmap='gray')
plt.axis('off')
plt.show()
优缺点

优点：

  • 高效：有序抖动算法的计算效率高，适合实时应用。
  • 简单易实现：算法逻辑简单，易于实现和理解。
  • 可控性好：通过选择不同的抖动矩阵，可以控制抖动效果。

缺点：

  • 视觉伪影：可能会产生明显的图案或伪影，尤其是在大面积平坦区域。
  • 对高频细节敏感：可能无法很好地保留图像中的高频细节。

有序抖动算法在图像抖动和半色调处理中非常有用，特别适用于需要快速处理和生成二值图像的应用场景，如打印和显示设备。通过选择合适的抖动矩阵，可以在不同应用场景中获得理想的抖动效果。

3.Riemersma 抖动算法详解

Riemersma 抖动算法是一种用于图像抖动的技术，通过遍历图像并根据给定的阈值矩阵进行量化。该算法采用一种类似于有序抖动的方法，但它使用更复杂的路径来遍历像素，从而减少图案和伪影。

Riemersma 抖动算法的核心思想是通过使用希尔伯特曲线（Hilbert curve）或其他空间填充曲线来遍历图像像素。这种遍历方式可以保持像素的空间局部性，从而在抖动过程中产生更自然的视觉效果。

算法步骤
  1. 生成希尔伯特曲线：生成图像尺寸的希尔伯特曲线索引。
  2. 生成抖动矩阵：创建一个预定义的抖动矩阵。
  3. 遍历图像：按照希尔伯特曲线的顺序逐像素处理图像，根据抖动矩阵对每个像素进行量化。
  4. 更新像素值：将量化后的像素值更新到输出图像中。
公式

Python 实现

以下是Riemersma抖动算法的Python实现代码：

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

def hilbert_curve(n):
    """生成n阶希尔伯特曲线的索引"""
    if n == 1:
        return np.array([[0, 1], [3, 2]])
    
    t = hilbert_curve(n // 2)
    size = t.size
    t = np.rot90(t, 2)
    
    t1 = t
    t2 = t + size
    t3 = t + 2 * size
    t4 = t + 3 * size
    
    t1 = np.rot90(t1, 3)
    t3 = np.rot90(t3, 1)
    return np.block([[t1, t2], [t4, t3]])

def generate_bayer_matrix(n):
    if n == 2:
        return np.array([
            [0, 2],
            [3, 1]
        ])
    else:
        smaller_matrix = generate_bayer_matrix(n // 2)
        return np.block([
            [4 * smaller_matrix + 0, 4 * smaller_matrix + 2],
            [4 * smaller_matrix + 3, 4 * smaller_matrix + 1]
        ])

def riemersma_dithering(image, bayer_matrix, hilbert_indices):
    """
    Riemersma 抖动算法实现

    参数:
    image (PIL.Image): 灰度图像
    bayer_matrix (numpy.ndarray): 抖动矩阵
    hilbert_indices (numpy.ndarray): 希尔伯特曲线索引

    返回:
    PIL.Image: 二值化后的图像
    """
    # 将图像转换为灰度图像
    grayscale_image = image.convert("L")
    image_array = np.array(grayscale_image, dtype=float)
    
    # 获取图像的行和列
    rows, cols = image_array.shape
    n = bayer_matrix.shape[0]
    
    # 遍历图像
    for index in hilbert_indices.flatten():
    	if index < rows:
	        y, x = divmod(index, cols)
	        threshold = (bayer_matrix[y % n, x % n] + 0.5) / (n * n)
	        image_array[y, x] = 255 if (image_array[y, x] / 255.0) >= threshold else 0
    
    # 将处理后的数组转换为图像
    dithered_image = Image.fromarray(image_array.astype(np.uint8))
    
    return dithered_image

# 示例用法
if __name__ == "__main__":
    image = Image.open('example.jpg')  # 打开原始图像
    bayer_matrix = generate_bayer_matrix(4)  # 生成 4x4 Bayer 矩阵
    hilbert_indices = hilbert_curve(max(image.size))  # 生成希尔伯特曲线索引
    dithered_image = riemersma_dithering(image, bayer_matrix, hilbert_indices)  # 调用Riemersma抖动算法
    dithered_image.show()  # 显示二值化后的图像
    dithered_image.save('riemersma_dithered_example.jpg')  # 保存二值化后的图像

    # 显示原始图像和二值化后的图像
    plt.figure(figsize=(12, 6))
    plt.subplot(1, 2, 1)
    plt.title('Original Image')
    plt.imshow(image.convert("L"), cmap='gray')
    plt.axis('off')
    
    plt.subplot(1, 2, 2)
    plt.title('Dithered Image')
    plt.imshow(dithered_image, cmap='gray')
    plt.axis('off')
    plt.show()
详细解释

  1. 生成希尔伯特曲线索引：

    def hilbert_curve(n):
    if n == 1:
        return np.array([[0, 1], [3, 2]])
    
    t = hilbert_curve(n // 2)
    size = t.size
    t = np.rot90(t, 2)
    
    t1 = t
    t2 = t + size
    t3 = t + 2 * size
    t4 = t + 3 * size
    
    t1 = np.rot90(t1, 3)
    t3 = np.rot90(t3, 1)
    return np.block([[t1, t2], [t4, t3]])

  2. 生成Bayer矩阵：

    def generate_bayer_matrix(n):
    if n == 2:
        return np.array([
            [0, 2],
            [3, 1]
        ])
    else:
        smaller_matrix = generate_bayer_matrix(n // 2)
        return np.block([
            [4 * smaller_matrix + 0, 4 * smaller_matrix + 2],
            [4 * smaller_matrix + 3, 4 * smaller_matrix + 1]
        ])

  3. 读取图像并转换为灰度图像：

    image = Image.open('example.jpg')
grayscale_image = image.convert("L")

  4. 将灰度图像转换为NumPy数组：

    image_array = np.array(grayscale_image, dtype=float)

  5. 遍历图像并根据抖动矩阵和希尔伯特曲线索引进行量化：

    rows, cols = image_array.shape
n = bayer_matrix.shape[0]

for index in hilbert_indices.flatten():
    y, x = divmod(index, cols)
    threshold = (bayer_matrix[y % n, x % n] + 0.5) / (n * n)
    image_array[y, x] = 255 if (image_array[y, x] / 255.0) >= threshold else 0

  6. 将处理后的数组转换为图像：

    dithered_image = Image.fromarray(image_array.astype(np.uint8))

  7. 显示和保存二值化后的图像：

    dithered_image.show()
dithered_image.save('riemersma_dithered_example.jpg')

  8. 显示原始图像和二值化后的图像：

    plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image.convert("L"), cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Dithered Image')
plt.imshow(dithered_image, cmap='gray')
plt.axis('off')
plt.show()
优缺点

优点：

  • 减少图案和伪影：使用希尔伯特曲线遍历像素，能更好地保持图像细节和减少伪影。
  • 高效：计算效率高，适合实时应用。

缺点：

  • 实现复杂：相比其他抖动算法，Riemersma抖动算法实现较为复杂。
  • 依赖抖动矩阵：效果受抖动矩阵的选择影响较大。

Riemersma 抖动算法通过引入希尔伯特曲线来改进传统的有序抖动算法，使其在保留图像细节和减少视觉伪影方面表现更佳。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1938697.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

网络编程中的TCP和UDP

网络编程中的TCP和UDP

什么是TCP协议 TCP( Transmission control protocol )即传输控制协议&#xff0c;是一种面向连接、可靠的数据传输协议&#xff0c;它是为了在不可靠的互联网上提供可靠的端到端字节流而专门设计的一个传输协议。 面向连接 &#xff1a;数据传输之前客户端和服务器端必须建立连…
阅读更多...
人工智能与语音识别：技术进步与应用前景

人工智能与语音识别：技术进步与应用前景

引言 人工智能&#xff08;AI&#xff09;作为当今科技进步的核心驱动力&#xff0c;正在各个领域展现其变革力量。其中&#xff0c;语音识别技术作为人工智能的重要应用之一&#xff0c;已经深入到我们的日常生活和工作中。从智能助手如Siri、Google Assistant&#xff0c;到智…
阅读更多...
最新版kubeadm搭建k8s（已成功搭建）

最新版kubeadm搭建k8s（已成功搭建）

kubeadm搭建k8s&#xff08;已成功搭建&#xff09; 环境配置 主节点 k8s-master&#xff1a;4核8G、40GB硬盘、CentOS7.9&#xff08;内网IP&#xff1a;10.16.64.67&#xff09; 从节点 k8s-node1&#xff1a; 4核8G、40GB硬盘、CentOS7.9&#xff08;内网IP&#xff1a;10…
阅读更多...
n5.Nginx 常见模块

n5.Nginx 常见模块

Nginx 常见模块 4.1 Nginx 四层访问控制4.2 Nginx 账户认证功能4.3 自定义错误页面4.4 自定义错误日志4.5 检测文件是否存在4.6 长连接配置4.7 作为下载服务器配置4.8 作为上传服务器4.9 限流限速4.10 Nginx 状态页 4.1 Nginx 四层访问控制 访问控制基于模块ngx_http_access_m…
阅读更多...
【一刷《剑指Offer》】面试题 37：两个链表的第一个公共结点

【一刷《剑指Offer》】面试题 37：两个链表的第一个公共结点

力扣对应题目链接&#xff1a;160. 相交链表 - 力扣&#xff08;LeetCode&#xff09; 牛客对应题目链接&#xff1a;两个链表的第一个公共结点_牛客题霸_牛客网 (nowcoder.com) 核心考点 &#xff1a;单链表理解&#xff0c;临界条件判定。 一、《剑指Offer》对应内容 二、分…
阅读更多...
Python酷库之旅-第三方库Pandas(036)

Python酷库之旅-第三方库Pandas(036)

目录 一、用法精讲 111、pandas.Series.item方法 111-1、语法 111-2、参数 111-3、功能 111-4、返回值 111-5、说明 111-6、用法 111-6-1、数据准备 111-6-2、代码示例 111-6-3、结果输出 112、pandas.Series.xs方法 112-1、语法 112-2、参数 112-3、功能 112-…
阅读更多...
快速了解死锁及如何解决死锁问题

快速了解死锁及如何解决死锁问题

目录 什么是死锁&#xff1f; 死锁代码示例 产生死锁的条件&#xff1a; 死锁的危害&#xff1a; 如何解决死锁问题&#xff1f; 1、预防死锁&#xff08;破坏上述4个产生死锁的条件&#xff09;&#xff1a; 2、银行家算法 3、死锁的检测、解除 4、采用超时机制 什么…
阅读更多...
C语言 ——— 写一个函数，调整 整型数组 中 奇数偶数的顺序

C语言 ——— 写一个函数，调整 整型数组 中 奇数偶数的顺序

目录 题目要求 代码实现 题目要求 创建一个整型数组 自定义函数实现&#xff1a;调整该数组中数字的顺序&#xff0c;使得数组中所有的奇数位于数组的前半部分&#xff0c;数组中所有的偶数位于数组的后半部分 举例&#xff1a; 输入的整型数组为&#xff1a;[234,24,45,…
阅读更多...
计算机网络知识点面试总结3

计算机网络知识点面试总结3

#来自ウルトラマンゼロ&#xff08;赛罗&#xff09; 1 数据链路层功能 数据链路层在物理层提供的服务的基础上向网络层提供服务&#xff0c;其最基本的服务是将源自网络层来的数据可靠地传输到相邻节点的目标机网络层&#xff0c;其主要作用是加强物理层传输原始比特流的功能。…
阅读更多...
嵌入式面试总结

嵌入式面试总结

C语言中struct和union的区别 struct和union都是常见的复合结构。 结构体和联合体虽然都是由多个不同的数据类型成员组成的&#xff0c;但不同之处在于联合体中所有成员共用一块地址空间&#xff0c;即联合体只存放了一个被选中的成员&#xff0c;结构体中所有成员占用空间是累…
阅读更多...
nginx基本原理

nginx基本原理

进程模型 当nginx启动之后&#xff0c;会有一个master进程和多个worker进程。默认是一个worker进程。 master进程的作用&#xff1a;接收来自外界信号&#xff0c;向各worker进程发送信号&#xff0c;监控worker进程的运行状态&#xff0c;当worker进程在异常情况下退出后&am…
阅读更多...
Golang | Leetcode Golang题解之第242题有效的字母异位词

Golang | Leetcode Golang题解之第242题有效的字母异位词

题目&#xff1a; 题解&#xff1a; func isAnagram(s, t string) bool {if len(s) ! len(t) {return false}cnt : map[rune]int{}for _, ch : range s {cnt[ch]}for _, ch : range t {cnt[ch]--if cnt[ch] < 0 {return false}}return true }
阅读更多...
系统架构设计师教程 第3章 信息系统基础知识-3.6 办公自动化系统（OAS）-解读

系统架构设计师教程 第3章 信息系统基础知识-3.6 办公自动化系统（OAS）-解读

系统架构设计师教程 第3章 信息系统基础知识-3.6 办公自动化系统&#xff08;OAS&#xff09; 3.6.1 办公自动化系统的概念3.6.1.1 办公活动3.6.1.1 办公自动化的概念 3.6.2 办公自动化系统的功能3.6.2.1 事务处理3.6.2.1.1 单机系统3.6.2.1.2 多机系统 3.6.2.2 信息管理3.6.2.…
阅读更多...
科研绘图系列：R语言雨云图（Raincloud plot）

科研绘图系列：R语言雨云图（Raincloud plot）

介绍 雨云图（Raincloud plot）是一种数据可视化工具，它结合了多种数据展示方式，旨在提供对数据集的全面了解。雨云图通常包括以下几个部分： 密度图（Density plot）：表示数据的分布情况，密度图的曲线可以展示数据在不同数值区间的密度。箱线图（Box plot）：显示数据的中…
阅读更多...
大模型实战—大模型赋能网络爬虫

大模型实战—大模型赋能网络爬虫

大模型赋能网络爬虫 简单来说，网页抓取就是从网站抓取数据和内容，然后将这些数据保存为XML、Excel或SQL格式。除了用于生成潜在客户、监控竞争对手和市场研究外，网页抓取工具还可以用于自动化你的数据收集过程。 借助AI网页抓取工具，可以解决手动或纯基于代码的抓取工具的…
阅读更多...
配置kali 的apt命令在线安装包的源为国内源

配置kali 的apt命令在线安装包的源为国内源

目录 一、安装VMware Tools 二、配置apt国内源 一、安装VMware Tools 点击安装 VMware Tools 后&#xff0c;会加载一个虚拟光驱&#xff0c;里面包含 VMware Tools 的安装包 鼠标右键单击 VMware Tools 的安装包&#xff0c;点击复制到 点击 主目录&#xff0c;再点击选择…
阅读更多...
XILINX芯片解密FPGA/CPLD芯片解密

XILINX芯片解密FPGA/CPLD芯片解密

Xilinx与其技术和制造合作伙伴(TSMC)为FPGA开发了一种高介电层金属闸(HKMG)、高性能、低功耗的28nm工艺技术。这一全新28nm工艺技术是在40nmFPGA工艺技术开发成果的基础上构建的&#xff0c;它推出了新的HKMG技术&#xff0c;可通过较低的功耗来最大程度地发挥可用系统性能。 …
阅读更多...
一文彻底搞懂虚拟地址空间

一文彻底搞懂虚拟地址空间

虚拟地址空间&#xff1a;传统的进程管理每个进程都占连续的物理内存空间&#xff0c;如果内存爆满需要将很久没用的但还在内存中的整个进程拷贝到硬盘中&#xff0c;等需要用时重新加载回内存。现代计算机使用虚拟地址空间&#xff0c;虚拟地址空间每个进程的4g并不是真的有&a…
阅读更多...
【ROS2】高级:安全-检查网络流量

【ROS2】高级:安全-检查网络流量

目标&#xff1a;捕获和检查原始 ROS 2 网络流量。 教程级别&#xff1a;高级 时间&#xff1a;20 分钟 内容 概述 先决条件 运行演示 安装 tcpdump启动说话者和听者显示未加密的发现数据包显示未加密的数据包 启用加密显示加密的发现数据包显示加密数据包 概述 ROS 2 通信安全…
阅读更多...
【Unity】Android Failed to transform Error while dexing.

【Unity】Android Failed to transform Error while dexing.

文章目录 一、背景二、问题描述三、原因和解决方法 一、背景 1、Unity 2021.3.33f1 2、Firebase 11.7.0 3、升级至API-34 二、问题描述 错误信息 Failed to transform play-services-measurement-api-21.5.0.aar (com.google.android.gms:play-services-measurement-api:21.5.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023