Numba最近邻插值（CPU+ GPU + Z轴切块 + XYZ轴切块 + 多线程）

news2024/12/26 23:36:20

文章目录

  • 最近邻插值（加速方法）
    • （1）scipy.ndimage.zoom
    • （2）Numba-CPU加速
    • （3）Numba-GPU加速
    • （4）Numba-CPU加速（Z轴切块）
    • （5）Numba-CPU加速（XYZ轴切块）
    • （6）Numba-CPU加速（XYZ轴切块）+ 多线程

在这里插入图片描述

输入数据插值倍数时耗
scipy.ndimage.zoom(1024, 1024, 512)4172.16s
Numba-CPU(1024, 1024, 512)456.58s
Numba-GPU(1024, 1024, 512)4122.51s
Numba-CPU（Z轴切块）(1024, 1024, 512)452.44
Numba-CPU（XYZ轴切块）(1024, 1024, 512)472.69s
Numba-CPU（XYZ轴切块）+ 多线程(1024, 1024, 512)450.20s

为什么使用 GPU 反而更慢了：

  • （1）数据传输开销：GPU 的计算速度快，但数据在 CPU 和 GPU 之间传输时会有较大的开销。
  • （2）任务并行性不高：GPU 适合大规模并行计算，如果任务的并行性不够高，比如 Z 轴切块后的任务处理，GPU 的潜力可能无法得到充分发挥。相比之下，CPU 在处理较小规模任务时可能表现得更有效率。
  • （3）专用 GPU 内存不足，自动转共享 GPU 内存（时耗增加）。

最近邻插值（加速方法）

（1）scipy.ndimage.zoom

from scipy.ndimage import zoom
import time
import numpy as np

if __name__ == "__main__":
    # （1）创建数组
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)
    input_data[50:600, 200:1000, 5:30] = 1

	# （2）插值计算
    start_time = time.time()
    #############################################################
    zoom_factor = [2, 2, 2]  # 指定插值因子   
    output_data = zoom(input_data, zoom_factor, order=0)
   	#############################################################
    print("计算时间:", time.time() - start_time)

    print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))
    print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))
    print("原始数据:", input_data.shape)
    print("插值结果:", output_data.shape)

"""
##### 插值两倍 #####
计算时间: 21.160449504852295
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 88000000
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)

##### 插值四倍 #####
计算时间: 172.16581082344055
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 704760200
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（2）Numba-CPU加速

import numba
import numpy as np


@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_data):
    """最近邻插值算法
    输入参数：3D图像 + 插值因子 + 预分配的输出数据
    """
    # 对目标数组中的每个点进行插值
    for z in range(output_data.shape[0]):
        zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)  # round四舍五入可能会超出数据边界的值
        for y in range(output_data.shape[1]):
            yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)  # round四舍五入可能会超出数据边界的值
            for x in range(output_data.shape[2]):
                # 计算在原始数据中的对应位置，并限制在原始数据范围内
                xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)  # round四舍五入可能会超出数据边界的值
                output_data[z, y, x] = input_data[zz, yy, xx]  # 最近邻插值
    return output_data


if __name__ == "__main__":
    # （1）创建数组
    input_data = np.zeros((1024, 1024, int(1024*0.5)), dtype=bool)  # 创建3D数组
    input_data[50:600, 200:1000, 5:30] = 1

    # （2）插值计算
    import time
    start_time = time.time()
	#############################################################
    # 计算目标形状并创建目标数组
    output_shape = np.round(np.array(input_data.shape) * np.array(scale_factors)).astype(int)
    output_data = np.zeros(output_shape, dtype=input_data.dtype)

    scale_factors = [4, 4, 4]  # 指定插值因子
    nearest_neighbor_interpolation(input_data, scale_factors, output_data)  # 执行3D最近邻插值
	#############################################################
    print("计算时间:", time.time() - start_time)

    print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))
    print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))
    print("原始数据:", input_data.shape)
    print("插值结果:", output_data.shape)

"""
##### 插值两倍 #####
计算时间: 7.694857835769653
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 86240000
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)

##### 插值四倍 #####
计算时间: 56.58441758155823
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 696960000
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（3）Numba-GPU加速

import numpy as np
from numba import cuda


@cuda.jit
def nearest_neighbor_interpolation_gpu(input_data, output_data, scale_factors):
    """
    最近邻插值的CUDA版本
    """
    z, y, x = cuda.grid(3)  # 获取3D网格中线程的位置 (z, y, x)

    if z < output_data.shape[0] and y < output_data.shape[1] and x < output_data.shape[2]:
        zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)
        yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)
        xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)

        output_data[z, y, x] = input_data[zz, yy, xx]


def gpu_nearest_neighbor_interpolation(input_data, scale_factors):
    # 创建目标数组的形状
    output_shape = np.round(input_data.shape * scale_factors).astype(int)
    output_data = np.zeros(output_shape, dtype=input_data.dtype)

    # 将输入数据从CPU上传到GPU
    input_data_gpu = cuda.to_device(input_data)
    output_data_gpu = cuda.to_device(output_data)
    #######################################################################
    # 定义线程和块的大小
    threads_per_block = (16, 16, 4)
    blocks_per_grid = ((output_shape[0] + threads_per_block[0] - 1) // threads_per_block[0],
                       (output_shape[1] + threads_per_block[1] - 1) // threads_per_block[1],
                       (output_shape[2] + threads_per_block[2] - 1) // threads_per_block[2])

    # 执行CUDA核函数
    nearest_neighbor_interpolation_gpu[blocks_per_grid, threads_per_block](input_data_gpu, output_data_gpu, scale_factors)
    #######################################################################
    # 将结果从GPU下载回CPU
    output_data = output_data_gpu.copy_to_host()

    return output_data


if __name__ == "__main__":
    # （1）创建3D数组
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)
    input_data[50:600, 200:1000, 5:30] = 1

    # （2）执行插值
    import time
    start_time = time.time()
    #######################################################################
    scale_factors = np.array([4, 4, 4])  # 指定插值因子
    output_data = gpu_nearest_neighbor_interpolation(input_data, scale_factors)
    #######################################################################
    print("计算时间:", time.time() - start_time)

    print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))
    print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))
    print("原始数据:", input_data.shape)
    print("插值结果:", output_data.shape)

"""
##### 插值两倍 #####
计算时间: 3.6601688861846924
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 86240000
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)

##### 插值四倍 #####
计算时间: 122.51327633857727
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 696960000
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（4）Numba-CPU加速（Z轴切块）

import numba
import numpy as np


@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_block):
    # 对目标数组中的每个点进行插值
    for z in range(output_block.shape[0]):
        zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)
        for y in range(output_block.shape[1]):
            yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)
            for x in range(output_block.shape[2]):
                # 计算在原始数据中的对应位置，并限制在原始数据范围内
                xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)
                output_block[z, y, x] = input_data[zz, yy, xx]  # 最近邻插值
    return output_block


def segment_blocks(input_data, block_size, scale_factors):
    num_blocks = int(np.ceil(input_data.shape[0] / block_size))
    print("切块数量 =", num_blocks)

    zoomed_blocks = []
    for i in range(num_blocks):
        start_idx = i * block_size
        end_idx = min((i + 1) * block_size, input_data.shape[0])
        block = input_data[start_idx:end_idx, :, :]
        ##########################################################################
        output_shape = np.round(np.array(block.shape) * scale_factors).astype(int)  # 计算目标形状
        output_block = np.zeros(output_shape, dtype=block.dtype)  # 创建目标形状的数组

        zoomed_block = nearest_neighbor_interpolation(block, scale_factors, output_block)
        # zoomed_block = scipy.ndimage.zoom(block, zoom_factor, order=1)
        ##########################################################################
        zoomed_blocks.append(zoomed_block)
    output_data = np.concatenate(zoomed_blocks, axis=0)  # 沿着第一个轴进行拼接得到合并结果

    return output_data


if __name__ == "__main__":
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)  # 创建一个示例的3D数组
    input_data[50:600, 200:1000, 5:30] = 1

    import time
    start_time = time.time()
    ###############################################################
    scale_factors = np.array([4, 4, 4])  # 指定插值因子

    block_size = 100  # 切割小块的Z轴尺度，会自动分配并处理越界问题（切块数量 = input_data[0] / block_size）
    output_data = segment_blocks(input_data, block_size, scale_factors)  # 分块插值
    ##########################################################################
    print("计算时间:", time.time() - start_time)

    print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))
    print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))
    print("原始数据:", input_data.shape)
    print("插值结果:", output_data.shape)

"""
##### 插值两倍 #####
切块数量 = 11
总共耗时: 6.803957223892212
Non-zero Count: 11000000
Non-zero Count: 86318400
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)

##### 插值四倍 #####
切块数量 = 11
计算时间: 52.44191575050354
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 697593600
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（5）Numba-CPU加速（XYZ轴切块）

import numba
import numpy as np


@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_block):
    for z in range(output_block.shape[0]):
        zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)
        for y in range(output_block.shape[1]):
            yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)
            for x in range(output_block.shape[2]):
                xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)
                output_block[z, y, x] = input_data[zz, yy, xx]
    return output_block


def segment_blocks(input_data, block_sizes, scale_factors):
    num_blocks_z = int(np.ceil(input_data.shape[0] / block_sizes[0]))
    num_blocks_y = int(np.ceil(input_data.shape[1] / block_sizes[1]))
    num_blocks_x = int(np.ceil(input_data.shape[2] / block_sizes[2]))

    zoomed_blocks_zz = []
    for z in range(num_blocks_z):
        start_z = z * block_sizes[0]
        end_z = min((z + 1) * block_sizes[0], input_data.shape[0])

        zoomed_blocks_yy = []
        for y in range(num_blocks_y):
            start_y = y * block_sizes[1]
            end_y = min((y + 1) * block_sizes[1], input_data.shape[1])

            zoomed_blocks_xx = []
            for x in range(num_blocks_x):
                start_x = x * block_sizes[2]
                end_x = min((x + 1) * block_sizes[2], input_data.shape[2])
                block = input_data[start_z:end_z, start_y:end_y, start_x:end_x]
                print(f"{num_blocks_z, num_blocks_y, num_blocks_x}/{z + 1, y + 1, x + 1}", "block.shape =", block.shape)
                ##########################################################################
                output_shape = np.round(block.shape * scale_factors).astype(int)
                output_block = np.zeros(output_shape, dtype=block.dtype)
                zoomed_block_x = nearest_neighbor_interpolation(block, scale_factors, output_block)
                ##########################################################################
                zoomed_blocks_xx.append(zoomed_block_x)
            zoomed_block_y = np.concatenate(zoomed_blocks_xx, axis=2)  # 沿着X轴拼接
            zoomed_blocks_yy.append(zoomed_block_y)
        zoomed_block_z = np.concatenate(zoomed_blocks_yy, axis=1)  # 沿着Y轴拼接
        zoomed_blocks_zz.append(zoomed_block_z)
    zoomed_block = np.concatenate(zoomed_blocks_zz, axis=0)  # 沿着Z轴拼接

    print("切块数量 =", num_blocks_z * num_blocks_y * num_blocks_x)
    return zoomed_block


if __name__ == "__main__":
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)
    input_data[50:600, 200:1000, 5:30] = 1

    import time
    start_time = time.time()
    ##########################################################################
    scale_factors = np.array([4, 4, 4])

    block_sizes = (100, 100, 100)  # 小块的尺度，沿着z轴、y轴、x轴
    zoomed_block = segment_blocks(input_data, block_sizes, scale_factors)
    ##########################################################################
    print("计算时间:", time.time() - start_time)

    print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))
    print("获取非零元素的数量（输出）:", np.count_nonzero(zoomed_block))
    print("原始数据:", input_data.shape)
    print("插值结果:", zoomed_block.shape)

"""
##### 插值两倍 #####
切块数量 = 726
计算时间: 9.834398746490479
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 86318400
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)

##### 插值四倍 #####
切块数量 = 726
计算时间: 72.6902551651001
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 697593600
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（6）Numba-CPU加速（XYZ轴切块）+ 多线程

import numba
import numpy as np
import concurrent.futures


@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_block):
    for z in range(output_block.shape[0]):
        zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)
        for y in range(output_block.shape[1]):
            yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)
            for x in range(output_block.shape[2]):
                xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)
                output_block[z, y, x] = input_data[zz, yy, xx]
    return output_block


def process_block(block, scale_factors):
    output_shape = np.round(block.shape * scale_factors).astype(int)
    output_block = np.zeros(output_shape, dtype=block.dtype)
    zoomed_block = nearest_neighbor_interpolation(block, scale_factors, output_block)
    return zoomed_block


def segment_blocks(input_data, block_sizes, scale_factors):
    num_blocks_z = int(np.ceil(input_data.shape[0] / block_sizes[0]))
    num_blocks_y = int(np.ceil(input_data.shape[1] / block_sizes[1]))
    num_blocks_x = int(np.ceil(input_data.shape[2] / block_sizes[2]))

    zoomed_blocks = []
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = []

        for z in range(num_blocks_z):
            start_z = z * block_sizes[0]
            end_z = min((z + 1) * block_sizes[0], input_data.shape[0])

            for y in range(num_blocks_y):
                start_y = y * block_sizes[1]
                end_y = min((y + 1) * block_sizes[1], input_data.shape[1])

                for x in range(num_blocks_x):
                    start_x = x * block_sizes[2]
                    end_x = min((x + 1) * block_sizes[2], input_data.shape[2])
                    ##########################################################################
                    block = input_data[start_z:end_z, start_y:end_y, start_x:end_x]
                    futures.append(executor.submit(process_block, block, scale_factors))
                    ##########################################################################

        # for future in concurrent.futures.as_completed(futures):
        #     zoomed_blocks.append(future.result())

    print("切块数量 =", num_blocks_z * num_blocks_y * num_blocks_x)
    return zoomed_blocks


if __name__ == "__main__":
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)
    input_data[50:600, 200:1000, 5:30] = 1

    import time
    start_time = time.time()
    ##########################################################################
    scale_factors = np.array([4, 4, 4])

    block_sizes = (100, 100, 100)  # 小块的尺度，沿着z轴、y轴、x轴
    output_data = segment_blocks(input_data, block_sizes, scale_factors)
    ##########################################################################
    print("计算时间:", time.time() - start_time)

    print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))
    # print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))
    print("原始数据:", input_data.shape)
    # print("插值结果:", output_data.shape)

"""
##### 插值两倍 #####
切块数量 = 726
计算时间: 6.778625011444092
获取非零元素的数量（输入）: 11000000
原始数据: (1024, 1024, 512)

##### 插值四倍 #####
切块数量 = 726
计算时间: 50.20111918449402
获取非零元素的数量（输入）: 11000000
原始数据: (1024, 1024, 512)
"""

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

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

相关文章

docker运行springboot项目

docker运行springboot项目

博客中若有侵权或者错误的地方&#xff0c;请及时告知&#xff0c;感谢。 1. 背景 在开发中使用k8s部署&#xff0c;日常也只是写个dockerFile, 没有想过整个部署流程是怎样的。今天我们自己部署docker镜像。 2.实战 2.1 建立springboot项目 (1) JAVA项目打包 (解决no mai…
阅读更多...
Minio笔记-Centos搭建Minio

Minio笔记-Centos搭建Minio

下载 Minio wget https://dl.min.io/server/minio/release/linux-amd64/minio 赋予执行权限 chmod x minio 创建存储目录 mkdir /data 运行 Minio ./minio server /data 默认端口为9000 访问 Minio 控制台&#xff1a;在浏览器中输入 http://your-server-ip:9000 默认…
阅读更多...
FPGA Prototyping vs Emulation

FPGA Prototyping vs Emulation

FPGA Prototyping vs. Emulation One way to visualize the difference between Prototyping and Emulation is with a “spider chart” (named for its resemblance to a spider’s web). The Prototyping vs. Emulation spider chart below highlights the differences bet…
阅读更多...
斐纳切数列考试题

斐纳切数列考试题

计算机二级考试有一道题 result [] a,b0,1 while a<100:print(a,end,) a, b b, ab # 0,1,1,2,3,5,8,13,21,34,55,89,
阅读更多...
LLM - 理解 多模态大语言模型 (MLLM) 的发展与相关技术 (二)

LLM - 理解 多模态大语言模型 (MLLM) 的发展与相关技术 (二)

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/142063880 免责声明&#xff1a;本文来源于个人知识与公开资料&#xff0c;仅用于学术交流&#xff0c;欢迎讨论&#xff0c;不支持转载。 多模态…
阅读更多...
idea 日志打印乱码

idea 日志打印乱码

在这里插入图片描述 配置中改为一致
阅读更多...
算法篇_RGB图像数据压缩与解压(单片机使用)

算法篇_RGB图像数据压缩与解压(单片机使用)

文章目录 一、前言二、算法选型2.1 Run-Length Encoding (RLE)2.2 Differential Pulse-Code Modulation (DPCM) 三、采用RLE算法实现图像压缩四、哈夫曼编码实现压缩和解压4.1 哈夫曼编码压缩自定义数据与还原4.2 哈夫曼编码压缩完成图像的压缩和还原 书接上回&#xff08;上一…
阅读更多...
Java重修笔记 第五十一天 泛型

Java重修笔记 第五十一天 泛型

泛型 1. 对加入集合的数据类型进行约束&#xff0c;提高了安全性 2. 不用做专门的数据类型转换&#xff0c;就可以直接使用从集合取出来的对象&#xff0c;效率高 在类定义中使用泛型 1. 在类名后面跟上 <泛型列表> 表示该类所使用的使用泛型&#xff0c;具体是什么…
阅读更多...
nginx 使用篇 配置

nginx 使用篇 配置

一、介绍 1.介绍 Nginx是一个高性能的HTTP和反向代理服务器&#xff0c;同时也是一个邮件代理服务器&#xff0c;它以稳定性、丰富的功能集、简单的配置文件和低系统资源消耗而闻名。 作为一个轻量级的服务器&#xff0c;Nginx在处理高并发连接方面表现出色&#xff0c;能够支…
阅读更多...
怎么修复松下相机死机视频只有0字节（0KB）的MDT文件【实测可修复】

怎么修复松下相机死机视频只有0字节（0KB）的MDT文件【实测可修复】

死机后视频文件大小仅为0字节 松下S5相机录像死机&#xff0c;关机重新开机后有一个视频文件变成MDT&#xff0c;大小为0KB&#xff0c;录了30多分钟&#xff0c;本应为MOV格式的视频。0字节文件可以修复吗&#xff1f;怎么修复0字节的MDT文件为视频&#xff1f; 数据提取与视…
阅读更多...
认知杂谈55

认知杂谈55

今天分享 有人说的一段争议性的话 I I I I 内容摘要 这篇内容主要有以下要点&#xff1a;首先&#xff0c;人际交往有难度&#xff0c;要让大家都喜欢很难&#xff0c;需学习沟通技巧&#xff0c;可通过看书、关注抖音博主、参加培训班及看罗翔视频片段来提升。其次&#xf…
阅读更多...
【C++11 ——— 类的新功能】

【C++11 ——— 类的新功能】

C11 ——— 类的新功能 类的新功能默认成员函数类成员变量初始化强制生成默认函数的关键字default禁止生成默认函数的关键字delete 类的新功能 默认成员函数 原来C类中&#xff0c;有6个默认成员函数&#xff1a; 构造函数析构函数拷贝构造函数拷贝赋值重载取地址重载const …
阅读更多...
代码随想录刷题day27丨455.分发饼干 ,376. 摆动序列 ,53. 最大子序和

代码随想录刷题day27丨455.分发饼干 ,376. 摆动序列 ,53. 最大子序和

代码随想录刷题day27丨455.分发饼干 ,376. 摆动序列 ,53. 最大子序和 1.贪心算法理论基础 贪心的本质是选择每一阶段的局部最优&#xff0c;从而达到全局最优。 这么说有点抽象&#xff0c;来举一个例子&#xff1a; 例如&#xff0c;有一堆钞票&#xff0c;你可以拿走十张&a…
阅读更多...
论文《Graph Neural Networks with convolutional ARMA filters》笔记

论文《Graph Neural Networks with convolutional ARMA filters》笔记

【ARMA 2021 PAMI】本文介绍了一种新型的基于**自回归移动平均&#xff08;Auto-Regression Moving Average&#xff0c;ARMA&#xff09;**滤波器的图卷积层。与多项式滤波器相比&#xff0c;ARMA滤波器提供了更灵活的频率响应&#xff0c;对噪声更鲁棒&#xff0c;能更好地捕…
阅读更多...
【每日一题】LeetCode 104.二叉树的最大深度（树、深度优先搜索、广度优先搜索、二叉树）

【每日一题】LeetCode 104.二叉树的最大深度（树、深度优先搜索、广度优先搜索、二叉树）

【每日一题】LeetCode 104.二叉树的最大深度&#xff08;树、深度优先搜索、广度优先搜索、二叉树&#xff09; 题目描述 给定一个二叉树 root&#xff0c;我们需要计算并返回该二叉树的最大深度。二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。 思路分…
阅读更多...
Uni-app 开发鸿蒙 App 全攻略

Uni-app 开发鸿蒙 App 全攻略

一、开发前的准备工作 开发鸿蒙 App 之前&#xff0c;我们需要做好充分的准备工作。首先是工具的安装与配置。 Node.js 的安装&#xff1a;推荐使用 LTS 版本的 Node.js。可以前往 Node.js 的官方网站下载适合自己操作系统的安装包&#xff0c;如 Windows 用户根据自己的系统版…
阅读更多...
OpenHarmony鸿蒙开发（ Beta5.0）智能风扇设备开发实践

OpenHarmony鸿蒙开发（ Beta5.0）智能风扇设备开发实践

样例简介 智能风扇设备不仅可以接收数字管家应用下发的指令来控制风扇开启的时间&#xff0c;调节风扇挡位&#xff0c;更改风扇定时时间&#xff0c;而且还可以加入到数字管家的日程管理中。通过日程可以设定风扇相关的任务&#xff0c;使其在特定的时间段内&#xff0c;风扇…
阅读更多...
【MySQL】MySQL表的操作

【MySQL】MySQL表的操作

目录 创建表的语法创建表的示例查看表的结构进入数据库查看自己在哪个数据库查看自己所在数据库都有哪些表查看表的详细信息查看创建表时的详细信息 修改表修改表名修改表的内容插入几个数据增加一列修改一列的所有属性删除某一列修改列的名称 删除表 创建表的语法 CREATE TAB…
阅读更多...
DFS算法专题(二)——穷举vs暴搜vs深搜vs回溯vs剪枝【OF】决策树

DFS算法专题(二)——穷举vs暴搜vs深搜vs回溯vs剪枝【OF】决策树

目录 1、决策树 2、算法实战应用【leetcode】 2.1 题一&#xff1a;全排列 2.2.1 算法原理 2.2.2 算法代码 2.2 题二&#xff1a;子集 2.2.1 算法原理【策略一】 2.2.2 算法代码【策略一】 2.2.3 算法原理【策略二&#xff0c;推荐】 2.2.4 算法代码【策略二&#x…
阅读更多...
图像去噪技术：传统中值滤波与改进中值滤波算法的比较

图像去噪技术：传统中值滤波与改进中值滤波算法的比较

在数字图像处理中&#xff0c;去噪是一个至关重要的步骤&#xff0c;尤其是在图像受到椒盐噪声影响时。本文将介绍一种改进的中值滤波算法&#xff0c;并与传统的中值滤波算法进行比较&#xff0c;以展示其在去除椒盐噪声方面的有效性。 实验环境 软件&#xff1a;MATLAB图像…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023