Automatic Exposure Correction of Consumer Photographs 分析

news2024/11/24 6:35:55

文章目录

Automatic Exposure Correction of Consumer Photographs

1. 图像分割

原图：
在这里插入图片描述

图分割算法：
分为129块， 129个颜色表示每一块
在这里插入图片描述

129块分别用 灰度0，1，2，3… 128表示
在这里插入图片描述

原理参考： code

主函数如下可以得到上面的两张图。

import cv2
import imageio
from scipy import ndimage
import matplotlib.pyplot as plt
from filter import *
from segment_graph import *
import time


# --------------------------------------------------------------------------------
# Segment an image:
# Returns a color image representing the segmentation.
#
# Inputs:
#           in_image: image to segment.
#           sigma: to smooth the image.
#           k: constant for threshold function.
#           min_size: minimum component size (enforced by post-processing stage).
#
# Returns:
#           num_ccs: number of connected components in the segmentation.
# --------------------------------------------------------------------------------
def segment(in_image, sigma, k, min_size):
    start_time = time.time()
    height, width, band = in_image.shape
    print("Height:  " + str(height))
    print("Width:   " + str(width))
    smooth_red_band = smooth(in_image[:, :, 0], sigma)
    smooth_green_band = smooth(in_image[:, :, 1], sigma)
    smooth_blue_band = smooth(in_image[:, :, 2], sigma)

    # build graph
    edges_size = width * height * 4
    edges = np.zeros(shape=(edges_size, 3), dtype=object)
    num = 0
    for y in range(height):
        for x in range(width):
            if x < width - 1:
                edges[num, 0] = int(y * width + x)
                edges[num, 1] = int(y * width + (x + 1))
                edges[num, 2] = diff(smooth_red_band, smooth_green_band, smooth_blue_band, x, y, x + 1, y)
                num += 1
            if y < height - 1:
                edges[num, 0] = int(y * width + x)
                edges[num, 1] = int((y + 1) * width + x)
                edges[num, 2] = diff(smooth_red_band, smooth_green_band, smooth_blue_band, x, y, x, y + 1)
                num += 1

            if (x < width - 1) and (y < height - 2):
                edges[num, 0] = int(y * width + x)
                edges[num, 1] = int((y + 1) * width + (x + 1))
                edges[num, 2] = diff(smooth_red_band, smooth_green_band, smooth_blue_band, x, y, x + 1, y + 1)
                num += 1

            if (x < width - 1) and (y > 0):
                edges[num, 0] = int(y * width + x)
                edges[num, 1] = int((y - 1) * width + (x + 1))
                edges[num, 2] = diff(smooth_red_band, smooth_green_band, smooth_blue_band, x, y, x + 1, y - 1)
                num += 1
    # Segment
    u = segment_graph(width * height, num, edges, k)

    # post process small components
    for i in range(num):
        a = u.find(edges[i, 0])
        b = u.find(edges[i, 1])
        if (a != b) and ((u.size(a) < min_size) or (u.size(b) < min_size)):
            u.join(a, b)

    num_cc = u.num_sets()
    output = np.zeros(shape=(height, width, 3), dtype=np.uint8)
    output2 = np.zeros(shape=(height, width, 3), dtype=np.uint8)
    # pick random colors for each component
    colors = np.zeros(shape=(height * width, 3))
    for i in range(height * width):
        colors[i, :] = random_rgb()

    comps = {}
    index = 0
    for y in range(height):
        for x in range(width):
            comp = u.find(y * width + x)
            output[y, x, :] = colors[comp, :]

            if comp not in comps:
                comps[comp] = index
                index += 1
            output2[y, x, :] = comps[comp]
    print(index)
    elapsed_time = time.time() - start_time
    print(
        "Execution time: " + str(int(elapsed_time / 60)) + " minute(s) and " + str(
            int(elapsed_time % 60)) + " seconds")
    print(output.dtype, output.max())


    # displaying the result
    fig = plt.figure()
    a = fig.add_subplot(2, 2, 1)
    plt.imshow(in_image)
    a.set_title('Original Image')
    a = fig.add_subplot(2, 2, 2)
    plt.imshow(output)
    a.set_title('Segmented Image')

    a = fig.add_subplot(2, 2, 3)
    plt.imshow(output2)
    a.set_title('Segmented Image index')
    plt.show()

    return output, output2, index

if __name__ == "__main__":
    sigma = 0.2
    k = 100
    min = 50
    input_path = "data/aecc.png"

    # Loading the image
    input_image = imageio.imread(input_path)
    print(input_image[:10, :10, 1])
    print("Loading is done.")
    print("processing...")
    output, output2, index = segment(input_image, sigma, k, min)

    cv2.imwrite(input_path[:-4] + 'seg.png', output)
    cv2.imwrite(input_path[:-4] + f'seg{index}.png', output2)

2. 按灰度区域合并

区域分割后129个region, 然后将其归类为10个gray zone.
灰度值范围[0, 1]
zone 0: [0,0.1]
zone 1: [0.1,0.2]
zone 2: [0.2,0.3]
zone 3: [0.3,0.4]
zone 4: [0.4,0.5]
zone 5: [0.5,0.6]
zone 6: [0.6,0.7]
zone 7: [0.7,0.8]
zone 8: [0.8,0.9]
zone 9: [0.9,1]

归为10类后，10个灰块，每个灰块用其zone范围的平均值表示，得到下图
在这里插入图片描述

或者每个region属于第i个gray zone，就标记为i
这样图像的值是0-9，接近黑色的。

在这里插入图片描述

计算 gamma 后的 细节：首先进行gamma操作，然后canny边缘检测，然后统计边的数量，来表示细节的多少。

在这里插入图片描述

代码如下：

import cv2
import matplotlib.pyplot as plt
import numpy as np

if __name__ == "__main__":
    file1 = r'D:\code\aec-awb\pegbis-master\data\aecc.png'
    index = 129
    file2 = r'D:\code\aec-awb\pegbis-master\data\aeccseg129.png'
    im1 = cv2.imread(file1)
    im2 = cv2.imread(file2, 0)

    im1_gray = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY) / 255

    im_out = np.zeros_like(im1_gray, dtype=np.float32)
    im_out2 = np.zeros_like(im1_gray, dtype=np.uint8)
    for i in range(index):
        z = im1_gray[im2 == i]
        m = np.mean(z)

        d = np.floor(m / 0.1).astype(np.uint8)

        im_out[im2 == i] = d / 10 + 0.5
        im_out2[im2 == i] = d
    im_out = np.clip(im_out * 255, 0, 255).astype(np.uint8)

    cv2.imwrite(file1[:-4] + 'zone.png', im_out)
    cv2.imwrite(file1[:-4] + 'zone_index.png', im_out2)

    im_gamma1 = (im1 / 255) ** 2.2
    im_gamma2 = (im1 / 255) ** (1 / 2.2)
    im_gamma1 = np.clip(im_gamma1 * 255, 0, 255).astype(np.uint8)
    im_gamma2 = np.clip(im_gamma2 * 255, 0, 255).astype(np.uint8)
    im_canny1 = cv2.Canny(im_gamma1, 60, 210)
    im_canny2 = cv2.Canny(im_gamma2, 60, 210)
    im_canny = cv2.Canny(im1, 60, 210)

    im_canny_all = im_canny1 + im_canny2 + im_canny
    print(im_canny1.shape, im_canny.dtype, im_canny2.max(), im_canny1[:20, :20])

    plt.figure()
    plt.subplot(231)
    plt.imshow(im_gamma1[..., ::-1])

    plt.subplot(232)
    plt.imshow(im_gamma2[..., ::-1])

    plt.subplot(233)
    plt.imshow(im1[..., ::-1])

    plt.subplot(234)
    plt.imshow(im_canny1, 'gray')
    plt.subplot(235)
    plt.imshow(im_canny2, 'gray')
    plt.subplot(236)
    plt.imshow(im_canny, 'gray')

    plt.show()

    im_canny2[im_canny1 > 0] = 0
    im_canny1[im_canny2 > 0] = 0
    im_canny2[im_out2 >= 5] = 0
    im_canny1[im_out2 < 5] = 0
    print(im_canny1.dtype, im_canny1.shape)

    plt.figure()
    plt.subplot(221)
    plt.imshow(im_canny2, 'gray')
    plt.subplot(222)
    plt.imshow(im_canny1, 'gray')
    plt.subplot(223)
    plt.imshow(im_canny_all, 'gray')
    plt.show()

    v_s = np.count_nonzero(im_canny2)
    v_h = np.count_nonzero(im_canny1)
    v_all = np.count_nonzero(im_canny_all)
    print(v_s, v_h, v_all)


    vv = []
    cc = []

    for i in range(10):
        if i < 5:
            vv.append(np.count_nonzero(im_canny2[im_out2 == i]) / v_all)
        else:
            vv.append(np.count_nonzero(im_canny1[im_out2 == i]) / v_all)
        cc.append(np.count_nonzero(im_out2 == i) / (im_out2.shape[0] * im_out2.shape[1]))
    print(vv, cc)

3. 根据细节多少和各zone相对对比度约束，求解每个zone对应的 最优zone.

这部分感觉没有描述特别清楚。

4. 每个zone以及对应的最有zone找到之后，可以求解多项式curve的 ϕ s \phi_s ϕs​ 和 ϕ h \phi_h ϕh​

这部分也暂略。

5. 关于curve

5.1 f Δ ( x ) f_{\Delta}(x) fΔ​(x) 和 f Δ ( 1 − x ) f_{\Delta}(1-x) fΔ​(1−x)

论文中图像如下：
在这里插入图片描述

复现图像如下 f Δ ( x ) f_{\Delta}(x) fΔ​(x) 和 f Δ ( 1 − x ) f_{\Delta}(1-x) fΔ​(1−x)

在这里插入图片描述

5.2 f ( x ) f(x) f(x)

公式
在这里插入图片描述

复现的曲线图

在这里插入图片描述

复现代码，并返回多个lut曲线。

def generate_lut():
    k1 = 5
    k2 = 14
    k3 = 1.6

    # x = np.arange(0, 1.0001, 1/255)
    x = np.arange(0, 256, 1) / 255
    f_delta = k1 * x * np.exp(-k2 * x ** k3)

    f_delta_m = k1 * (1 - x) * np.exp(-k2 * (1 - x) ** k3)

    plt.figure()
    plt.plot(x, 0.3 * f_delta, 'k-')
    plt.plot(x, 0.6 * f_delta, 'gx')
    plt.plot(x, f_delta, 'r+')

    plt.plot(x, 0.3 * f_delta_m, 'k-')
    plt.plot(x, 0.6 * f_delta_m, 'gx')
    plt.plot(x, f_delta_m, 'r+')
    plt.show()

    phi_s = np.round(np.arange(0, 0.7, 0.1), 1)
    phi_h = np.round(np.arange(0, 0.7, 0.1), 1)

    print('x : ', np.round(x * 255), len(x))
    lut = []
    plt.figure()
    for s in phi_s:
        for h in phi_h:
            f_x = x + s * f_delta - h * f_delta_m
            plt.plot(x, f_x)
            # print(s, h, np.round(f_x * 255, 1))
            lut.append(np.round(f_x * 255, 0))

    plt.show()
    return lut

5.3 通过多组lut曲线apply到图像，然后计算图像的细节量，根据图像细节量和人的感观选择合适的lut

比如 一下不同的 lut查找表得到的
原图，查找后的图，查找后的边缘检测
原图Y直方图， 查找后的图的Y直方图， lut形状

下面举例几个不同的lut得到图像效果和对应的边缘
lut 1:
在这里插入图片描述

lut 2:
在这里插入图片描述

lut 3:
在这里插入图片描述

lut 4:
在这里插入图片描述

会打印出每种lut apply图像后得到的边缘检测细节数量，比如一共49各lut
0 7850
1 7428
2 7124
3 6623
4 6540
5 6733
6 6648
7 9567
8 9041
9 8718
10 8252
11 8117
12 8382
13 8205
14 11584
15 11057
16 10775
17 10285
18 10161
19 10503
20 10358
21 15409
22 14748
23 14554
24 14008
25 13883
26 14122
27 14040
28 18099
29 17580
30 17237
31 16885
32 16777
33 17000
34 16953
35 19699
36 19176
37 18825
38 18540
39 18419
40 18617
41 18540
42 21226
43 20720
44 20310
45 20029
46 19906
47 20151
48 20024

这里细节最高的 42各lut ，对应细节数量为21226， 但是实际效果不一定最好。
因此只是参考把。

import cv2
import numpy as np
from matplotlib import pyplot as plt


def generate_lut():
    k1 = 5
    k2 = 14
    k3 = 1.6

    # x = np.arange(0, 1.0001, 1/255)
    x = np.arange(0, 256, 1) / 255
    f_delta = k1 * x * np.exp(-k2 * x ** k3)

    f_delta_m = k1 * (1 - x) * np.exp(-k2 * (1 - x) ** k3)

    plt.figure()
    plt.plot(x, 0.3 * f_delta, 'k-')
    plt.plot(x, 0.6 * f_delta, 'gx')
    plt.plot(x, f_delta, 'r+')

    plt.plot(x, 0.3 * f_delta_m, 'k-')
    plt.plot(x, 0.6 * f_delta_m, 'gx')
    plt.plot(x, f_delta_m, 'r+')
    plt.show()

    phi_s = np.round(np.arange(0, 0.7, 0.1), 1)
    phi_h = np.round(np.arange(0, 0.7, 0.1), 1)

    print('x : ', np.round(x * 255), len(x))
    lut = []
    plt.figure()
    for s in phi_s:
        for h in phi_h:
            f_x = x + s * f_delta - h * f_delta_m
            plt.plot(x, f_x)
            # print(s, h, np.round(f_x * 255, 1))
            lut.append(np.round(f_x * 255, 0))

    plt.show()
    return lut

def apply_curve(y, lut):
    y1 = y.copy()
    h, w = y1.shape
    for i in range(h):
        for j in range(w):
            y1[i,j] = lut[y1[i,j]]
    return y1.astype(np.uint8)

def get_canny(im1, lut):
    yuv = cv2.cvtColor(im1, cv2.COLOR_BGR2YUV)
    y1 = apply_curve(yuv[..., 0], lut)
    yuv2 = cv2.merge([y1, yuv[..., 1], yuv[..., 2]])

    bgr = cv2.cvtColor(yuv2, cv2.COLOR_YUV2BGR)
    plt.subplot(231)
    plt.imshow(im1[..., ::-1])
    plt.subplot(232)
    plt.imshow(bgr[..., ::-1])

    plt.subplot(233)
    low_thr = 60
    high_thr = 210
    im1_canny = cv2.Canny(bgr, low_thr, high_thr)
    plt.imshow(im1_canny, 'gray')

    plt.subplot(234)
    plt.hist(yuv[..., 0].ravel(), 256, [0, 256])

    plt.subplot(235)
    plt.hist(y1.ravel(), 256, [0, 256])

    plt.subplot(236)

    x = np.arange(0, 256, 1)
    fx = lut[x]
    plt.plot(x, fx)
    plt.show()


    v = np.count_nonzero(im1_canny)
    return v, bgr, yuv, yuv2
if __name__ == "__main__":

    luts = generate_lut()

    file1 = r'D:\code\aec-awb\pegbis-master\data\aecc.png'
    im1 = cv2.imread(file1)



    index = 0
    v_max = 0
    plt.figure()
    for lut in luts:
        v, bgr, yuv, yuv2 = get_canny(im1, lut)

        if v > v_max:
            v_max = v
            index_max = index

        print(index, v)
        index += 1

    v, bgr, yuv, yuv2 = get_canny(im1, luts[index_max])
    print(v)

6. detail_preserve 方法

直接应用lut曲线感觉效果比较朦胧，因此论文中对此改进。

在这里插入图片描述

通透性效果会好很多

在这里插入图片描述

具体实现代码

import glob

import cv2
import numpy as np
from matplotlib import pyplot as plt

from curve import get_canny, generate_lut

def curve_s(bgr, d):
    im23 = bgr + [2 * bgr * (1 - bgr)] * (d / 255)
    im23 = np.squeeze(im23)
    im23 = np.clip(im23 * 255, 0, 255).astype(np.uint8)
    return im23
if __name__ == "__main__":
    file1 = r'D:\code\aec-awb\pegbis-master\data\40.jpg'
    im1 = cv2.imread(file1)[...,::-1]

    yuv = cv2.cvtColor(im1, cv2.COLOR_BGR2YUV)
    print(yuv.shape, yuv.dtype)

    im1_filter1 = cv2.bilateralFilter(im1, 27, 100, 100)
    im1_filter2 = cv2.bilateralFilter(im1, 27, 200, 200)
    im1_filter3 = cv2.bilateralFilter(im1, 27, 400, 400)

    d1 = im1.astype(np.int16) - im1_filter1
    d2 = im1.astype(np.int16) - im1_filter2
    d3 = im1.astype(np.int16) - im1_filter3

    plt.figure()
    plt.subplot(241)
    plt.imshow(im1_filter1)
    plt.subplot(242)
    plt.imshow(im1_filter2)
    plt.subplot(243)
    plt.imshow(im1_filter3)
    plt.subplot(244)
    plt.imshow(im1)

    plt.subplot(245)
    plt.imshow(np.abs(d1).astype(np.uint8))
    plt.subplot(246)
    plt.imshow(np.abs(d2).astype(np.uint8))
    plt.subplot(247)
    plt.imshow(np.abs(d3).astype(np.uint8))
    plt.show()


    indexs = [15, 20]
    luts = generate_lut()


    v, bgr, yuv, yuv2 = get_canny(im1[..., ::-1], luts[15])
    v2, bgr2, yuva, yuvb = get_canny(im1[..., ::-1], luts[42])
    cv2.imwrite(file1[:-4]+'_bgr.png', bgr)
    cv2.imwrite(file1[:-4] + '_bgr3.png', bgr2)


    bgr = bgr / 255
    bgr2 = bgr2 / 255

    im23 = curve_s(bgr, d3)
    im22 = curve_s(bgr, d2)
    im21 = curve_s(bgr, d1)

    im33 = curve_s(bgr2, d3)
    im32 = curve_s(bgr2, d2)
    im31 = curve_s(bgr2, d1)


    plt.figure()
    plt.subplot(251)
    plt.imshow(im1)
    plt.subplot(252)
    plt.imshow(bgr[...,::-1])
    plt.subplot(253)
    plt.imshow(im21[...,::-1])
    plt.subplot(254)
    plt.imshow(im22[..., ::-1])
    plt.subplot(255)
    plt.imshow(im23[..., ::-1])

    plt.subplot(257)
    plt.imshow(bgr2[..., ::-1])
    plt.subplot(258)
    plt.imshow(im31[..., ::-1])
    plt.subplot(259)
    plt.imshow(im32[..., ::-1])
    plt.subplot(2,5,10)
    plt.imshow(im33[..., ::-1])
    plt.show()

    cv2.imwrite(file1[:-4] + '_21.png', im21)
    cv2.imwrite(file1[:-4] + '_22.png', im22)
    cv2.imwrite(file1[:-4] + '_23.png', im23)
    cv2.imwrite(file1[:-4] + '_41.png', im31)
    cv2.imwrite(file1[:-4] + '_42.png', im32)
    cv2.imwrite(file1[:-4] + '_43.png', im33)

    files = glob.glob(r'D:\code\aec-awb\pegbis-master\testdata\*')
    for file in files:
        if not file.endswith('b.png'):
            print(file)
            im1 = cv2.imread(file)[..., ::-1]
            # yuv = cv2.cvtColor(im1, cv2.COLOR_BGR2YUV)

            v, bgr, yuv, yuv2 = get_canny(im1[..., ::-1], luts[15])
            v2, bgr2, yuva, yuvb = get_canny(im1[..., ::-1], luts[42])
            cv2.imwrite(file[:-4] + '_bgr.png', bgr)
            cv2.imwrite(file[:-4] + '_bgr3.png', bgr2)

            bgr = bgr / 255
            bgr2 = bgr2 / 255

            im1_filter1 = cv2.bilateralFilter(im1, 27, 100, 100)
            im1_filter2 = cv2.bilateralFilter(im1, 27, 200, 200)
            im1_filter3 = cv2.bilateralFilter(im1, 27, 400, 400)

            d1 = im1.astype(np.int16) - im1_filter1
            d2 = im1.astype(np.int16) - im1_filter2
            d3 = im1.astype(np.int16) - im1_filter3
            im23 = curve_s(bgr, d3)
            im22 = curve_s(bgr, d2)
            im21 = curve_s(bgr, d1)
            im33 = curve_s(bgr2, d3)
            im32 = curve_s(bgr2, d2)
            im31 = curve_s(bgr2, d1)
            cv2.imwrite(file[:-4] + '_21.png', im21)
            cv2.imwrite(file[:-4] + '_22.png', im22)
            cv2.imwrite(file[:-4] + '_23.png', im23)
            cv2.imwrite(file[:-4] + '_41.png', im31)
            cv2.imwrite(file[:-4] + '_42.png', im32)
            cv2.imwrite(file[:-4] + '_43.png', im33)

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

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

相关文章

【Flask框架】——24 创建ROM映射

【Flask框架】——24 创建ROM映射

创建ROM映射 ORM&#xff1a;Object Relationship Mapping 创建一个类&#xff0c;一个类对应了一个数据库中的一张表&#xff0c;类的数据属性对应了表中的字段名&#xff0c;这个类称为映射类。 根据映射类创建出一个一个的对象&#xff0c;每个对象对应了表中的一条实际的…
阅读更多...
函数（6）

函数（6）

目录 1、函数是什么&#xff1f; 2、C语言中函数的分类&#xff1a; 1、库函数 2、自定义函数 3、函数的参数 4、函数的调用 5、练习 1、打印100~200之间的素数 2、打印100~200之间的闰年 3、写一个函数&#xff0c;实现一个整形有序数组的二分查找 6、函数的嵌套调…
阅读更多...
CSDN每日一练求最小元素 C语言

CSDN每日一练求最小元素 C语言

题目名称&#xff1a;求最小元素 时间限制&#xff1a;1000ms内存限制&#xff1a;256M 题目描述 Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand. (i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]). Find the minimum…
阅读更多...
MS17-010漏洞攻击与防御（利用永恒之蓝攻击Win7系统）

MS17-010漏洞攻击与防御（利用永恒之蓝攻击Win7系统）

任务1 利用永恒之蓝攻击Win7系统 在Kali终端中输入命令“msfconsole ”&#xff0c;启动Metasploit&#xff1b;输入命令“use auxiliary/scanner/smb/smb_ms17_010”&#xff0c;加载扫描模块&#xff1b;输入命令“set RHOSTS 192.168.0.6”&#xff0c;设置需要被扫描的目标…
阅读更多...
哈希表题目：环形链表 II

哈希表题目：环形链表 II

文章目录题目标题和出处难度题目描述要求示例数据范围进阶解法一思路和算法代码复杂度分析解法二思路和算法证明代码复杂度分析题目 标题和出处 标题&#xff1a;环形链表 II 出处&#xff1a;142. 环形链表 II 难度 2 级 题目描述 要求 给你一个链表的头结点 head\tex…
阅读更多...
CSDN周赛第16期-100分满分题解

CSDN周赛第16期-100分满分题解

前言 这是时隔两年再参加比赛了&#xff0c;上次参加算法竞赛还是2020年在公司1024活动的时候。当时获得了二等奖&#xff08;switch套装&#xff09;和一个快题奖&#xff08;小米行李箱&#xff09;。 这次比赛获得了满分&#xff0c;也还不错。题目除了二维积水的问题&…
阅读更多...
8Manage：提高项目执行力的策略有哪些？

8Manage：提高项目执行力的策略有哪些？

在项目管理中实施执行战略&#xff0c;将战略目标转化为商业价值的企业将发现取得成功所涉及的大团队——最高管理层、中层管理人员、项目经理和项目团队。 以下是阻碍项目成功执行的六个主要差距&#xff1a; ● 缺少共同的理解 ● 缺乏参与的执行赞助者 ● 与战略目标不一致…
阅读更多...
计算机网络—Nginx概述

计算机网络—Nginx概述

文章目录nginx负载均衡&#xff1a;例&#xff1a;安装配置nginx————————————————————————————————nginx负载均衡&#xff1a; 请求会打到nginx上面&#xff0c;nginx可以用作负载均衡&#xff0c; 例&#xff1a;一个网站用一台服务器不够&a…
阅读更多...
001 软件安装与配置

001 软件安装与配置

1、Anaconda安装及使用 1.1 下载地址 Anaconda3-2022.10-Windows-x86_64 1.2 Anaconda创建虚拟环境 下面均在Anaconda终端中输入 查看python版本 python --version1.2.1、Anaconda创建虚拟环境 conda create -n pytorch python3.9conda create 创建虚拟环境命令 -n pytor…
阅读更多...
解决vue代码不规范而出现的问题：Eslint修复

解决vue代码不规范而出现的问题：Eslint修复

当我们刚创建一个vue项目&#xff0c;写代码时候&#xff0c;因为代码写的不规范会出很多问题&#xff0c;报很多错误&#xff0c;除了一个一个去修改他们&#xff0c;还有没有其他办法去解决他们呢&#xff1f; 这里介绍三种办法去统一解决&#xff1a; 方法一&#xff1a;每…
阅读更多...
MCU-51：让LED闪烁起来

MCU-51：让LED闪烁起来

目录一、LED闪烁1.1 编写代码1.2 延时函数1.3 由0和1控制实现二、LED流水灯2.1 流水灯基础版2.2 移位法实现LED流水灯一、LED闪烁 昨天我们初识单片机&#xff0c;点亮了一个灯开启了我们51单片机的学习之旅。那么今天我们来一步步深入学习。 1.1 编写代码 会了点亮一个灯&a…
阅读更多...
嵌入式分享~IO相关1 ##

嵌入式分享~IO相关1 ##

这里仅总结一下IO控制相关 单片机IO直接驱动继电器 上图是随便找到的两个不同型号的继电器。继电器就是个开关&#xff0c;这个开关是由它内部的线圈控制的&#xff0c;给线圈通电&#xff0c;继电器就吸合&#xff0c;开关就动作了。绝大部分的继电器反面都会有如下图一样的…
阅读更多...
win10 git 标准化commit工具commitizen安装教程

win10 git 标准化commit工具commitizen安装教程

1、 安装nodjs https://nodejs.org/en/ 下载最新版本 安装完成后&#xff0c;修改环境变量 默认 nodejs是有的&#xff0c;需要自己添加npm路径 2、安装commitizen 在桌面上右键打开power shell 查看node 和npm的版本&#xff0c;npm最好升级一下 升级命令问题 npm inst…
阅读更多...
【HDR】曝光融合（Exposure Fusion）

【HDR】曝光融合（Exposure Fusion）

文章目录0 前言1 算法细节1.1 Naive1.1.1 主要思想1.1.2 权重计算1.1.3 融合1.2 Multi-resolution2 实验3 参考0 前言 在曝光融合&#xff08;Exposure Fusion&#xff09;算法问世之前&#xff0c;多曝光序列合成用于显示的HDR需要两个步骤&#xff0c;第一步是将多张不同曝光…
阅读更多...
MySql加密存储的数据，如何模糊搜索？

MySql加密存储的数据，如何模糊搜索？

背景 蔚来被勒索 225 万美元&#xff0c;大量数据遭泄露&#xff01; 根据网络上流传的截图显示&#xff0c;黑客似乎掌握着蔚来内部员工数据 22800 条、车主用户身份证数据 399000 条、用户地址数据 6500000 条、注册用户数据 4850000 条、企业及企业代表联系人数据 10000 条…
阅读更多...
dpdk编译

dpdk编译

ubuntu网卡信息配置 虚拟机中除去最开始的一块网卡&#xff0c;再另外添加两块网卡&#xff0c;如下图所示 修改Ubuntu20_x64.vmx里面的配置信息 将ethernet0.virtualDev "e1000"里面的e1000更改成vmxnet3,因为e1000只支持网卡单队列&#xff0c;vmxnet3支持网卡对…
阅读更多...
5G无线技术基础自学系列 | 5G移动性KPI

5G无线技术基础自学系列 | 5G移动性KPI

素材来源&#xff1a;《5G无线网络规划与优化》 一边学习一边整理内容&#xff0c;并与大家分享&#xff0c;侵权即删&#xff0c;谢谢支持&#xff01; 附上汇总贴&#xff1a;5G无线技术基础自学系列 | 汇总_COCOgsta的博客-CSDN博客 5G移动类KPI用来评估NR网络的移动性能&…
阅读更多...
29. 如何通过 ABAP 代码给 SAP OData 元数据增添注解

29. 如何通过 ABAP 代码给 SAP OData 元数据增添注解

笔者的这篇 SAP UI5 开发教程文章&#xff0c;* SAP UI5 应用开发教程之一百二十九 - 如何给 SAP UI5 SmartField 添加 Value Help 功能&#xff0c;有朋友留言&#xff1a; 你好&#xff0c;请教一个问题&#xff0c;请问如何在odata里面通过annotations添加一个自定义注解&am…
阅读更多...
2022年哪些工具适合设计企业产品手册？

2022年哪些工具适合设计企业产品手册？

产品手册是什么&#xff1f; 产品手册是因特网发展的成果&#xff0c;是一种以移动端为基础进行在线营销的新内容&#xff0c;其中包含了对原有的纸质商品、小册子、促销软文、邀请函等现有促销资料进行数字化的更新。 产品手册是从传统的纸质公司样本书中升级而来的&#xf…
阅读更多...
Git 入门

Git 入门

文章目录0. 前言学习目标参考教程链接1. Git概念1.1 什么是Git1.2 Git 的下载1.3 Git三大区域1.4 远程仓库2. Git的使用2.1 图形化操作2.1.1 IDEA图形化操作2.1.2 GitKraken(可选)2.2 命令行操作2.2.1 Git 配置2.2.2 分支命令2.2.3 拉取与推送3. 总结0. 前言 学习目标 了解 G…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023