OpenCV颜色识别

news2024/11/18 7:37:59

颜色分辨

在这里插入图片描述

单个颜色识别

代码

import cv2
import numpy as np


def color(lower, upper, name):
    Img = cv2.imread('image/origin/all.png')  # 读入一幅图像

    kernel_3 = np.ones((3, 3), np.uint8)  # 3x3的卷积核

    if Img is not None:  # 判断图片是否读入
        HSV = cv2.cvtColor(Img, cv2.COLOR_BGR2HSV)  # 把BGR图像转换为HSV格式

        # mask是把HSV图片中在颜色范围内的区域变成白色，其他区域变成黑色
        if name == 'red':
            mask = cv2.inRange(HSV, lower[:3], upper[:3])
            mask = mask + cv2.inRange(HSV, lower[3:], upper[3:])
        else:
            mask = cv2.inRange(HSV, lower, upper)

        # 下面四行是用卷积进行滤波
        # erode()函数可以对输入图像用特定结构元素进行腐蚀操作，该结构元素确定腐蚀操作过程中的邻域的形状，
        # 各点像素值将被替换为对应邻域上的最小值：
        erosion = cv2.erode(mask, kernel_3, iterations=1)
        erosion = cv2.erode(erosion, kernel_3, iterations=1)
        # dilate()函数可以对输入图像用特定结构元素进行膨胀操作，该结构元素确定膨胀操作过程中的邻域的形状，
        # 各点像素值将被替换为对应邻域上的最大值：
        dilation = cv2.dilate(erosion, kernel_3, iterations=1)
        dilation = cv2.dilate(dilation, kernel_3, iterations=1)

        # target是把原图中的非目标颜色区域去掉剩下的图像
        cv2.bitwise_and(Img, Img, mask=dilation)

        # 将滤波后的图像变成二值图像放在binary中
        ret, binary = cv2.threshold(dilation, 127, 255, cv2.THRESH_BINARY)

        # 在binary中发现轮廓，轮廓按照面积从小到大排列
        contours, hierarchy = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        for index, contour in enumerate(contours):  # 遍历所有的轮廓
            x, y, w, h = cv2.boundingRect(contour)  # 将轮廓分解为识别对象的左上角坐标和宽、高
            # 在图像上画上矩形（图片、左上角坐标、右下角坐标、颜色、线条宽度）
            cv2.rectangle(Img, (x, y), (x + w, y + h), (0, 255,), 3)
            # 给识别对象写上标号
            font = cv2.FONT_HERSHEY_SIMPLEX
            cv2.putText(Img, name + str(index+1), (x - 10, y + 10), font, 1, (0, 0, 255), 2)  # 加减10是调整字符位置

        print(name, '方块的数量是', len(contours), '个')  # 终端输出目标数量

        # cv2.imshow('target', target)
        # cv2.imshow('Mask', mask)
        # cv2.imshow("prod", dilation)
        cv2.namedWindow('Img', 0)
        cv2.imshow('Img', Img)
        cv2.imwrite('./image/' + name + '.png', Img)  # 将画上矩形的图形保存到当前目录

    while True:
        key = cv2.waitKey(10) & 0xFF
        if key == 27 or cv2.getWindowProperty('Img', cv2.WND_PROP_VISIBLE) < 1.0:
            break


if __name__ == '__main__':
    # 下面两个值是要识别的颜色范围
    lower_yellow = np.array([20, 20, 20])  # 黄色的下限
    upper_yellow = np.array([30, 255, 255])  # 黄色上限
    # color(lower_yellow, upper_yellow, 'yellow')

    # 红色需要特殊处理
    lower_red = np.array([0, 43, 46, 156, 43, 46])  # 红色阈值下界
    higher_red = np.array([10, 255, 255, 180, 255, 255])  # 红色阈值上界
    # color(lower_red, higher_red, 'red')

    lower_green = np.array([35, 110, 106])  # 绿色阈值下界
    higher_green = np.array([77, 255, 255])  # 绿色阈值上界
    # color(lower_green, higher_green, 'green')

    lower_blue = np.array([78, 43, 46])  # 蓝色阈值下界
    upper_blue = np.array([110, 255, 255])  # 蓝色阈值下界
    color(lower_blue, upper_blue, 'blue')

效果

在这里插入图片描述

多个颜色识别

代码

import cv2
import numpy as np


def bitwise_or_fun(masks):
    if len(masks) <= 1:
        return
    mask = cv2.bitwise_or(masks[0], masks[1])

    for i in range(2, len(masks)):
        mask = cv2.bitwise_or(mask, masks[i])


def color(img):
    colors, lower_highers = get_params()
    frame = cv2.imread(img)  # 读入一幅图像
    font = cv2.FONT_HERSHEY_SIMPLEX
    img_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    masks = []
    for index, lower_higher in enumerate(lower_highers):
        lower_color = lower_higher[0]
        higher_color = lower_higher[1]

        if colors[index] == 'red':
            mask = cv2.inRange(img_hsv, lower_color[:3], higher_color[:3])  # 可以认为是过滤出红色部分，获得红色的掩膜
            mask = mask + cv2.inRange(img_hsv, lower_color[3:], higher_color[3:])  # 可以认为是过滤出红色部分，获得红色的掩膜
        else:
            mask = cv2.inRange(img_hsv, lower_color, higher_color)
        mask = cv2.medianBlur(mask, 7)  # 中值滤波
        masks.append(mask)

    bitwise_or_fun(masks)
    cntss = []
    for mask in masks:
        cnts, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)  # 轮廓检测
        cntss.append(cnts)

    for (colorname, cnts) in zip(colors, cntss):
        for index, cnt in enumerate(cnts):
            (x, y, w, h) = cv2.boundingRect(cnt)  # 该函数返回矩阵四个点
            # cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 0), 2)  # 将检测到的颜色框起来
            cv2.putText(frame, colorname + str(index + 1), (x, y - 5), font, 0.7, (0, 0, 0), 2)
        cv2.drawContours(frame, cnts, -1, (0, 0, 0), 3)
    # cv2.namedWindow('frame', 0)
    cv2.imshow('frame', frame)
    cv2.imwrite('image/frame.png', frame)  # 将画上矩形的图形保存到当前目录

    while True:
        key = cv2.waitKey(10) & 0xFF
        if key == 27 or cv2.getWindowProperty('frame', cv2.WND_PROP_VISIBLE) < 1.0:
            break


def get_params():
    # 下面两个值是要识别的颜色范围
    lower_yellow = np.array([20, 20, 20])  # 黄色的下限
    upper_yellow = np.array([30, 255, 255])  # 黄色上限

    # 红色需要特殊处理
    lower_red = np.array([0, 43, 46, 156, 43, 46])  # 红色阈值下界
    higher_red = np.array([10, 255, 255, 180, 255, 255])  # 红色阈值上界

    lower_green = np.array([35, 110, 106])  # 绿色阈值下界
    higher_green = np.array([77, 255, 255])  # 绿色阈值上界

    lower_blue = np.array([78, 43, 46])  # 蓝色阈值下界
    upper_blue = np.array([110, 255, 255])  # 蓝色阈值下界

    # 下面两个值是要识别的颜色范围
    lower_purple = np.array([125, 43, 46])  # 紫色的下限
    upper_purple = np.array([155, 255, 255])  # 紫色上限

    params = []
    colors = []
    params.append([lower_red, higher_red]);colors.append('red')
    params.append([lower_yellow, upper_yellow]);colors.append('yellow')
    params.append([lower_green, higher_green]);colors.append('green')
    params.append([lower_blue, upper_blue]);colors.append('blue')
    params.append([lower_purple, upper_purple]);colors.append('purple')

    return colors, params


if __name__ == '__main__':
    color('./image/origin/all.png')

效果

在这里插入图片描述

模板匹配+颜色识别

源码

import cv2
import numpy as np


def bitwise_or_fun(masks):
    if len(masks) <= 1:
        return
    mask = cv2.bitwise_or(masks[0], masks[1])

    for i in range(2, len(masks)):
        mask = cv2.bitwise_or(mask, masks[i])


def match_color(img,template):
    positions = match(img, template)
    colors, lower_highers = get_params()
    frame = cv2.imread(img)  # 读入一幅图像
    font = cv2.FONT_HERSHEY_SIMPLEX
    img_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    masks = []
    for index, lower_higher in enumerate(lower_highers):
        lower_color = lower_higher[0]
        higher_color = lower_higher[1]

        if colors[index] == 'red':
            mask = cv2.inRange(img_hsv, lower_color[:3], higher_color[:3])  # 可以认为是过滤出红色部分，获得红色的掩膜
            mask = mask + cv2.inRange(img_hsv, lower_color[3:], higher_color[3:])  # 可以认为是过滤出红色部分，获得红色的掩膜
        else:
            mask = cv2.inRange(img_hsv, lower_color, higher_color)
        mask = cv2.medianBlur(mask, 7)  # 中值滤波
        masks.append(mask)

    bitwise_or_fun(masks)
    cntss = []
    for mask in masks:
        cnts, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)  # 轮廓检测
        cntss.append(cnts)

    for (colorname, cnts) in zip(colors, cntss):
        index = 0
        for cnt in cnts:
            (x, y, w, h) = cv2.boundingRect(cnt)  # 该函数返回矩阵四个点
            for position in positions:
                (x1, y1, w1, h1) = position
                if x >= x1 and y >= y1 and x + w <= x1 + w1 and y + h <= y1 + h1:
                    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 0), 2)  # 将检测到的颜色框起来
                    cv2.putText(frame, colorname + str(index + 1), (x, y - 5), font, 0.7, (0, 0, 0), 2)
                    index = index + 1
                    break
    # 可以进行拉伸图片
    # cv2.namedWindow('frame', 0)
    cv2.imshow('frame', frame)

    while True:
        key = cv2.waitKey(10) & 0xFF
        if key == 27 or cv2.getWindowProperty('frame', cv2.WND_PROP_VISIBLE) < 1.0:
            break


def get_params():
    # 下面两个值是要识别的颜色范围
    lower_yellow = np.array([20, 20, 20])  # 黄色的下限
    upper_yellow = np.array([30, 255, 255])  # 黄色上限

    # 红色需要特殊处理
    lower_red = np.array([0, 43, 46, 156, 43, 46])  # 红色阈值下界
    higher_red = np.array([10, 255, 255, 180, 255, 255])  # 红色阈值上界

    lower_green = np.array([35, 110, 106])  # 绿色阈值下界
    higher_green = np.array([77, 255, 255])  # 绿色阈值上界

    lower_blue = np.array([78, 43, 46])  # 蓝色阈值下界
    upper_blue = np.array([110, 255, 255])  # 蓝色阈值下界

    # 下面两个值是要识别的颜色范围
    lower_purple = np.array([125, 43, 46])  # 紫色的下限
    upper_purple = np.array([155, 255, 255])  # 紫色上限

    params = []
    colors = []
    params.append([lower_red, higher_red]);colors.append('red')
    params.append([lower_yellow, upper_yellow]);colors.append('yellow')
    params.append([lower_green, higher_green]);colors.append('green')
    params.append([lower_blue, upper_blue]);colors.append('blue')
    params.append([lower_purple, upper_purple]);colors.append('purple')

    return colors, params


def match(img_src, template_src):
    img = cv2.imread(img_src)
    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    template = cv2.imread(template_src, 0)
    h, w = template.shape[:2]

    res = cv2.matchTemplate(img_gray, template, cv2.TM_CCOEFF_NORMED)
    threshold = 0.8

    # 取匹配程度大于%80的坐标
    loc = np.where(res >= threshold)
    position = []
    for pt in zip(*loc[::-1]):  # *号表示可选参数
        position.append([pt[0], pt[1], w, h])

    return position


if __name__ == '__main__':
    img = 'color2.png'
    template = 'tmp2.png'

    match_color(img,template)

效果

注意：模板和图片中的大小应当一直
如果需要不一致的请看下面的升级版本
在这里插入图片描述

当模板和图片中的大小不一致的时候，就无法识别

在这里插入图片描述

模板匹配+颜色识别升级

代码

  • get_params() 要进行识别的颜色
  • def match(img_src, template_src, wh, ratio)
    wh为图片的宽和高，ratio为宽高比例
import cv2
import numpy as np
from imutils import contours


# 传入一个轮廓计算面积
def contourArea(cnt):
    rect = cv2.minAreaRect(cnt)  # 最小外接矩形
    box = cv2.boxPoints(rect)
    box = np.int0(box)
    return cv2.contourArea(box)


# 绘图展示
def cv_show(name, img):
    # cv2.namedWindow(name, 0)
    cv2.imshow(name, img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


# 初始化颜色参数
def get_params():
    # 下面两个值是要识别的颜色范围
    lower_yellow = np.array([20, 20, 20])  # 黄色的下限
    upper_yellow = np.array([30, 255, 255])  # 黄色上限

    lower_green = np.array([35, 110, 106])  # 绿色阈值下界
    higher_green = np.array([77, 255, 255])  # 绿色阈值上界

    lower_blue = np.array([78, 43, 46])  # 蓝色阈值下界
    upper_blue = np.array([110, 255, 255])  # 蓝色阈值下界

    # 下面两个值是要识别的颜色范围
    lower_purple = np.array([125, 43, 46])  # 紫色的下限
    upper_purple = np.array([155, 255, 255])  # 紫色上限

    # 红色需要特殊处理
    lower_red = np.array([0, 43, 46, 156, 43, 46])  # 红色阈值下界,
    higher_red = np.array([10, 255, 255, 180, 255, 255])  # 红色阈值上界

    params = []
    colors = []

    # 进行要识别颜色的添加
    params.append([lower_red, higher_red]);colors.append('red')
    params.append([lower_yellow, upper_yellow]);colors.append('yellow')
    params.append([lower_green, higher_green]);colors.append('green')
    params.append([lower_blue, upper_blue]);colors.append('blue')
    params.append([lower_purple, upper_purple]);colors.append('purple')

    return colors, params


def match_color(img1):
    img_hsv = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)
    colors, lower_highers = get_params()

    max = 0
    i = -1
    for index, lower_higher in enumerate(lower_highers):
        area = 0
        lower_color = lower_higher[0]
        higher_color = lower_higher[1]

        if colors[index] == 'red':
            mask = cv2.inRange(img_hsv, lower_color[:3], higher_color[:3])  # 可以认为是过滤出红色部分，获得红色的掩膜
            mask = mask + cv2.inRange(img_hsv, lower_color[3:], higher_color[3:])  # 可以认为是过滤出红色部分，获得红色的掩膜
        else:
            mask = cv2.inRange(img_hsv, lower_color, higher_color)
        mask = cv2.medianBlur(mask, 7)  # 中值滤波
        cnts, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)  # 轮廓检测

        if len(cnts) > 0:
            for cnt in cnts:
                area = area + contourArea(cnt)
                # area = area+cv2.contourArea(cnt)
            if area > max:
                max = area
                i = index
                # print(max, colors[i])

    # print("=======================================================")
    if i > -1:
        return colors[i]
    else:
        return "no"


# wh为图片的宽和高，ratio为宽高比例
def match(img_src, template_src, wh, ratio):
    # 模板处理，固定大小
    template = cv2.imread(template_src)
    ref = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
    # 二值图像
    ref = cv2.threshold(ref, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
    template = cv2.resize(ref, (wh[0], wh[1]))
    # cv_show('ref', template)

    # 图像处理
    img = cv2.imread(img_src)
    # 读取输入图像，预处理
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (5, 5), 0)

    # 边缘检测第一种方法
    # thresh = cv2.Canny(gray, 10, 200)
    # 边缘检测第二种方法（105-118行）
    # Sobel算子检测元素的边缘
    gradX = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)  # ksize=-1相当于用3*3的
    gradX = cv2.convertScaleAbs(gradX)
    gradY = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=-1)
    gradY = cv2.convertScaleAbs(gradY)

    grad = cv2.addWeighted(gradX, 0.5, gradY, 0.5, 0)
    # cv_show("grad", grad)
    (minVal, maxVal) = (np.min(grad), np.max(grad))
    grad = (255 * ((grad - minVal) / (maxVal - minVal)))
    grad = grad.astype("uint8")
    # 阈值设定，THRESH_OTSU会自动寻找合适的阈值，适合双峰，
    thresh = cv2.threshold(grad, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
    cv_show("thresh", thresh)

    # 轮廓检测
    cnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    cur_img = img.copy()
    cv2.drawContours(cur_img, cnts, -1, (0, 0, 255), 3)
    cv_show("cur_img", cur_img)

    # 遍历每一个轮廓中的样本
    for (i, c) in enumerate(cnts):
        # 计算矩形
        (x, y, w, h) = cv2.boundingRect(c)
        ar = w / float(h)

        # 选择合适的区域，根据实际任务来，这里的基本都是四个数字一组
        if ratio[0] < ar < ratio[1]:
            if (30 < w) and (30 < h):
                # 符合的留下来
                roi = gray[y - 5:y + h + 5, x - 5:x + w + 5]
                roi = cv2.resize(roi, (wh[0], wh[1]))
                res = cv2.matchTemplate(roi, template, cv2.TM_CCOEFF_NORMED)
                # cv_show("roi", roi)
                if res >= 0.5:
                    # 画出来
                    name = match_color(img[y - 5:y + h + 5, x - 5:x + w + 5])
                    print(res, name)
                    # print(res, name + str(i))
                    print("=======================================================")
                    cv2.rectangle(img, (x - 5, y - 5), (x + w + 5, y + h + 5), (0, 0, 255), 1)
                    # cv2.putText(img, name + str(i), (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 255), 2)
                    cv2.putText(img, name, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 255), 2)
    cv_show("img", img)
    cv2.imwrite('img.png', img)


if __name__ == '__main__':
    img = './image/testt.png'
    template = './image/test33_tmp.png'
    match(img, template, [30, 90], [0.3, 0.45])

效果

在这里插入图片描述

原图

testt.png
在这里插入图片描述
test33_tmp.png
在这里插入图片描述
color2.png
在这里插入图片描述
temp2.png
在这里插入图片描述
all.png
在这里插入图片描述

实际项目

实际项目中干扰太大效果不佳

更好的效果请查看 目标检测算法deformable detr

在这里插入图片描述

原图

control-light.jpg
在这里插入图片描述
c2.png
在这里插入图片描述

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

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

相关文章

maven中profiles使用详解，多环境开发配置文件（开发，测试，生产）+ pom中resources部分标签介绍

maven中profiles使用详解，多环境开发配置文件（开发，测试，生产）+ pom中resources部分标签介绍

一.maven中profiles使用详解&#xff08;仅供参考&#xff09; 使用的场景 常常遇到一些项目中多环境切换的问题。比如在开发过程中用到开发环境&#xff0c;在测试中使用测试环境&#xff0c;在生产中用生产环境的情况。springboot中提供了 spring.profile.active的方式来实…
阅读更多...
以mariadb为例介绍如何使用systemctl命令集设置服务开机自启动

以mariadb为例介绍如何使用systemctl命令集设置服务开机自启动

以mariadb为例介绍如何使用systemctl命令集设置服务开机自启动一、systemd简介二、systemctl命令集常用命令三、以mariadb自启动为例四、更多说明一、systemd简介 systemd即为system daemon,是linux下的一种init软件,由Lennart Poettering带头开发,并在LGPL 2.1及其后续版本许…
阅读更多...
[思维模式-13]：《复盘》-1- “知”篇 - 认识复盘

[思维模式-13]：《复盘》-1- “知”篇 - 认识复盘

目录 前言 一、什么是复盘 二、复盘的三个关键词 三、复盘&#xff0c;而非总结 四、复盘的优势与局限 五、复盘与行动学习、培训、绩效改进的区别与联系 六、关于复盘的几个常见误解 误解1&#xff1a;可否对他人之事进行复盘 误解2&#xff1a;“项目后评估”是复盘吗…
阅读更多...
细粒度图像分类模型（含实战代码）

细粒度图像分类模型（含实战代码）

来源&#xff1a;投稿 作者&#xff1a;lsc 编辑&#xff1a;学姐 理论部分 01细粒度图片分类问题 1.1细粒度图片分类特点 可判别区域往往只是在图像中很小的一块区域内。 1.2细粒度图像分类数据集 1.3细粒度图像分类竞赛 1.4细粒度图像分类模型分类: (1)强监督模型: 需要…
阅读更多...
Java之AQS

Java之AQS

AQS是什么 是用来实现锁或者其它同步器组件的公共基础部分的抽象实现&#xff0c;整体就是一个抽象的FIFO队列来完成资源获取线程的安排工作&#xff0c;并通过一个int类变量表示持有锁的状态。 使用到AQS的一些类 ReentranLock: CountDownLatch ReentrantReadWriteLock:…
阅读更多...
Go语言开发小技巧易错点100例（四）

Go语言开发小技巧易错点100例（四）

往期回顾&#xff1a; Go语言开发小技巧&易错点100例&#xff08;一&#xff09;Go语言开发小技巧&易错点100例&#xff08;二&#xff09;Go语言开发小技巧&易错点100例&#xff08;三&#xff09; 本期看点&#xff08;技巧类用【技】表示&#xff0c;易错点用…
阅读更多...
_14LeetCode代码随想录算法训练营第十四天-C++二叉树

_14LeetCode代码随想录算法训练营第十四天-C++二叉树

_14LeetCode代码随想录算法训练营第十四天-C二叉树 题目列表 104.二叉树的最大深度559.n叉树的最大深度111.二叉树的最小深度222.完全二叉树的节点个数 104.二叉树的最大深度 题目 给定一个二叉树&#xff0c;找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长…
阅读更多...
RabbitMQ 第一天 基础 3 RabbitMQ 快速入门 3.1 入门程序【生产者】

RabbitMQ 第一天 基础 3 RabbitMQ 快速入门 3.1 入门程序【生产者】

RabbitMQ 【黑马程序员RabbitMQ全套教程&#xff0c;rabbitmq消息中间件到实战】 文章目录RabbitMQ第一天 基础3 RabbitMQ 快速入门3.1 入门程序3.1.1 生产者第一天 基础 3 RabbitMQ 快速入门 3.1 入门程序 3.1.1 生产者 看下文档 点进去 先就来做一个 这个简单模式 P&…
阅读更多...
vector

vector

目录vector的介绍和使用vector的介绍vector的使用vector 空间增长问题vector 迭代器失效问题。&#xff08;重点&#xff09;vector与erase迭代器失效的代码vector深度剖析及模拟实现vector模拟实现代码使用memcpy拷贝问题动态二维数组理解vector反向迭代器reverse_iteratorvec…
阅读更多...
Android开发进阶——Coil对比Glide分析

Android开发进阶——Coil对比Glide分析

Coil概述 Coil是Android上的一个全新的图片加载框架&#xff0c;它的全名叫做coroutine image loader,即协程图片加载库。 与传统的图片加载库Glide&#xff0c;Picasso或Fresco等相比。该具有轻量&#xff08;只有大约1500个方法&#xff09;、快、易于使用、更现代的API等优…
阅读更多...
【Vue项目搭建】vue-admin-template修改（2）

【Vue项目搭建】vue-admin-template修改（2）

接上文、、 --------------------------------------------------------- 优化登录 单独封装路由守卫 &#xff0c;设置白名单&#xff0c;permission.js&#xff0c;鉴权 跳转动画优化&#xff08;使用NProgress插件&#xff09; 显示logo svg 改填充颜色 stroke //画线颜色…
阅读更多...
小题 错题总结

小题 错题总结

要是对象具有序列化&#xff0c;应该实现的接口是 Java.IO.Serializable在 JVM 内存划分中 &#xff0c;方法通常存储在 方法区多态的3种表现形式&#xff1a; 继承重写 重载 向上转型Java 中继承可以间接继承&#xff0c;即便中间跨过一个类&#xff0c;栗子&#xff1a;所有…
阅读更多...
一文读懂Linux内核中的Device mapper映射机制

一文读懂Linux内核中的Device mapper映射机制

本文结合具体代码对 Linux 内核中的 device mapper 映射机制进行了介绍。Device mapper 是 Linux 2.6 内核中提供的一种从逻辑设备到物理设备的映射框架机制&#xff0c;在该机制下&#xff0c;用户可以很方便的根据自己的需要制定实现存储资源的管理策略&#xff0c;当前比较流…
阅读更多...
基于PHP的动漫电影信息管理系统

基于PHP的动漫电影信息管理系统

有需要请私信或看评论链接哦 可远程调试 基于PHP的动漫电影管理系统一 介绍 此动漫电影信息管理系统基于原生PHP开发&#xff0c;数据库mysql&#xff0c;前端bootstrap。系统角色分为用户和管理员&#xff0c;用户注册登录后可观看/下载/收藏/留言/评分动漫电影等&#xff0c…
阅读更多...
Multi-Channel PCe QDMARDMA Subsystem

Multi-Channel PCe QDMARDMA Subsystem

可交付资料&#xff1a; 1. 详细的用户手册 2. Design File&#xff1a;Post-synthesis EDIF netlist or RTL Source 3. Timing and layout constraints&#xff0c;Test or Design Example Project 4. 技术支持&#xff1a;邮件&#xff0c;电话&#xff0c;现场&…
阅读更多...
隐私计算概述

隐私计算概述

1. 基本概念 隐私计算是指在保证数据提供方不泄露原始数据的前提下，对数据进行分析计算的一些列信息技术，保障数据在流通和融合过程中的“可用不可见”。 从技术交付出发，隐私计算是众多学科的交叉融合技术，目前主流的隐私计算技术分为三大方向：第一类是多方安全计算为代…
阅读更多...
linux内核中断

linux内核中断

目录 硬中断特点 中断API 线程中断 系统标准的优先级顺序 中断信息查看 中断上半部与下半部 软中断与并发 硬中断特点 优先级最高中断函数在中断上下文中&#xff0c;不能阻塞不要间接或直接调用shedule() 在申请内存空间时&#xff0c;使用GFP_ATOMIC 标志&#xff08…
阅读更多...
Blender——苹果纹理绘制

Blender——苹果纹理绘制

效果图 前言 在进行纹理绘制之前&#xff0c;首先要具有苹果三维模型。 关于苹果的建模请参考&#xff1a;Blender——“苹果”建模_行秋的博客 1.苹果UV的展开 1.1首先点击UV Eidting&#xff0c;滑动三维模型&#xff0c;使其大小适中。 1.2打开左上角的UV选区同步&#x…
阅读更多...
IPv6 的地址(计算机网络-网络层)

IPv6 的地址(计算机网络-网络层)

目录 IPv6地址的表示方法 IPv6的分类 IPv6 全球单播地址 IPv6 多播地址 IPv6地址的表示方法 在 IPv6 中&#xff0c;每个地址占 128 位&#xff0c;地址空间大于 3.4 *10^ 38 。在想象得到的将来&#xff0c;IPv6的地址空间是不可能用完的 128位的IPv6地址使用冒号十六进制记…
阅读更多...
玩以太坊链上项目的必备技能（库 [library]-Solidity之旅十七）

玩以太坊链上项目的必备技能（库 [library]-Solidity之旅十七）

库&#xff08;library&#xff09; 作为开发者的您&#xff0c;想必对项目中重复使用的工具函数&#xff0c;抽取到一个公共中&#xff0c;以便可以在您项目中的其它位置可调用。 而 Solidity 与您所熟知的没有什么不同&#xff0c;它也是用来实现可重复调用&#xff0c;且还…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023