究极无敌shishishi

最新推荐文章于 2024-08-07 21:39:52 发布
人间油物六子
最新推荐文章于 2024-08-07 21:39:52 发布
阅读量300
点赞数 3
文章标签： opencv 计算机视觉人工智能
本文链接：https://blog.csdn.net/weixin_74889643/article/details/139025862
版权
import numpy as np
import cv2

#94 ksize(9,9)
#30 ksize(5,5)
#33 ksize(3,3)
#54 ksize(1,1)(9,9)
#60 ksize(5,5)
#65 kszie(7,7)
#71 kszie(7,7)
#72 ksize(5,5)(7,7)
#80 ksize(1,1)
#94 ksize(7,7) (9,9)

def find_marker1_1(image):

    #将图像转换成灰度、模糊和检测边缘
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (1,1), 0)
    edged = cv2.Canny(gray, 35, 125)

    #我们假设这是我们在图像中的一张纸
    cnts,_ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    # 求最大面积
    c = max(cnts, key = cv2.contourArea)

    #计算纸张区域的边界框并返回它
    # cv2.minAreaRect() c代表点集，返回rect[0]是最小外接矩形中心点坐标，
    # rect[1][0]是width，rect[1][1]是height，rect[2]是角度
    return cv2.minAreaRect(c)

def find_marker3_3(image):

    #将图像转换成灰度、模糊和检测边缘
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (3,3), 0)
    edged = cv2.Canny(gray, 35, 125)

    #我们假设这是我们在图像中的一张纸
    cnts,_ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    # 求最大面积
    c = max(cnts, key = cv2.contourArea)

    #计算纸张区域的边界框并返回它
    # cv2.minAreaRect() c代表点集，返回rect[0]是最小外接矩形中心点坐标，
    # rect[1][0]是width，rect[1][1]是height，rect[2]是角度
    return cv2.minAreaRect(c)

def find_marker5_5(image):

    #将图像转换成灰度、模糊和检测边缘
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (5,5), 0)
    edged = cv2.Canny(gray, 35, 125)

    #我们假设这是我们在图像中的一张纸
    cnts,_ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    # 求最大面积
    c = max(cnts, key = cv2.contourArea)

    #计算纸张区域的边界框并返回它
    # cv2.minAreaRect() c代表点集，返回rect[0]是最小外接矩形中心点坐标，
    # rect[1][0]是width，rect[1][1]是height，rect[2]是角度
    return cv2.minAreaRect(c)

def find_marker7_7(image):

    #将图像转换成灰度、模糊和检测边缘
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (7,7), 0)
    edged = cv2.Canny(gray, 35, 125)

    #我们假设这是我们在图像中的一张纸
    cnts,_ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    # 求最大面积
    c = max(cnts, key = cv2.contourArea)

    #计算纸张区域的边界框并返回它
    # cv2.minAreaRect() c代表点集，返回rect[0]是最小外接矩形中心点坐标，
    # rect[1][0]是width，rect[1][1]是height，rect[2]是角度
    return cv2.minAreaRect(c)

def find_marker9_9(image):

    #将图像转换成灰度、模糊和检测边缘
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (9,9), 0)
    edged = cv2.Canny(gray, 35, 125)

    #我们假设这是我们在图像中的一张纸
    cnts,_ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    # 求最大面积
    c = max(cnts, key = cv2.contourArea)

    #计算纸张区域的边界框并返回它
    # cv2.minAreaRect() c代表点集，返回rect[0]是最小外接矩形中心点坐标，
    # rect[1][0]是width，rect[1][1]是height，rect[2]是角度
    return cv2.minAreaRect(c)



def detect_color(frame):

    # 裁剪图像
    top = 180  # 顶部裁剪像素数
    bottom = 180  # 底部裁剪像素数
    left = 180  # 左侧裁剪像素数
    right = 180  # 右侧裁剪像素数

    # 计算裁剪后的图像范围
    cropped_image = frame[top: frame.shape[0] - bottom, left: frame.shape[1] - right]

    # 将图像从 BGR 转换为 HSV
    hsv = cv2.cvtColor(cropped_image, cv2.COLOR_BGR2HSV)

    # 定义颜色的范围
    lower_red = np.array([0, 43, 43])
    upper_red = np.array([10, 255, 255])
    lower_red2 = np.array([156, 46, 46])
    upper_red2 = np.array([180, 255, 255])

    lower_green = np.array([35, 43, 46])
    upper_green = np.array([77, 255, 255])

    lower_blue = np.array([100, 43, 46])
    upper_blue = np.array([124, 255, 255])

    lower_yellow = np.array([11, 43, 46])
    upper_yellow = np.array([25, 255, 255])
    lower_yellow2 = np.array([26, 43, 46])
    upper_yellow2 = np.array([43, 255, 255])

    # 创建掩膜
    mask_red1 = cv2.inRange(hsv, lower_red, upper_red)
    mask_red2 = cv2.inRange(hsv, lower_red2, upper_red2)
    mask_red = cv2.bitwise_or(mask_red1, mask_red2)
    mask_green = cv2.inRange(hsv, lower_green, upper_green)
    mask_blue = cv2.inRange(hsv, lower_blue, upper_blue)
    mask_yellow1 = cv2.inRange(hsv, lower_yellow, upper_yellow)
    mask_yellow2 = cv2.inRange(hsv, lower_yellow2, upper_yellow2)
    mask_yellow = cv2.bitwise_or(mask_yellow1, mask_yellow2)

    # 计算各个颜色的区域面积
    area_red = cv2.countNonZero(mask_red)
    area_green = cv2.countNonZero(mask_green)
    area_blue = cv2.countNonZero(mask_blue)
    area_yellow = cv2.countNonZero(mask_yellow)

    # 根据面积大小确定主要颜色
    color = None
    if area_red > area_green and area_red > area_blue and area_red > area_yellow:
        color = "Red"

    elif area_green > area_red and area_green > area_blue and area_green > area_yellow:
        color = "Green"

    elif area_blue > area_red and area_blue > area_green and area_blue > area_yellow:
        color = "Blue"

    elif area_yellow > area_red and area_yellow > area_green and area_yellow > area_blue:
        color = "Yellow"

    return color

def red_identify_rectangle(image_path):
    img = cv2.imread(image_path)  # 读取图片
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)  # 转换颜色空间为HSV

    # 定义红色范围
    lower_red = np.array([0, 43, 43])
    upper_red = np.array([10, 255, 255])
    lower_red2 = np.array([156, 46, 46])
    upper_red2 = np.array([180, 255, 255])

    # 创建掩膜
    mask1 = cv2.inRange(hsv, lower_red, upper_red)
    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
    mask = cv2.bitwise_or(mask1, mask2)

    # 找到红色区域的轮廓
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # 绘制外接矩形
    for contour in contours:
        x, y, w, h = cv2.boundingRect(contour)
        cv2.rectangle(img, (x, y), (x + w, y + h), (0,0,255), 2)

    # 显示结果
    cv2.imshow('image', img)
    #cv2.imshow('mask', mask)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def green_identify_rectangle(image_path):
    # 读取图片
    img = cv2.imread(image_path)
    # 转换颜色空间为HSV
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    # 定义绿色范围
    lower_green = np.array([35, 43, 46])
    upper_green = np.array([77, 255, 255])
    # 创建掩膜
    mask = cv2.inRange(hsv, lower_green, upper_green)
    # 进行图像处理
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # 绘制外接矩形
    for contour in contours:
        x, y, w, h = cv2.boundingRect(contour)
        cv2.rectangle(img, (x, y), (x + w, y + h), (0,255,0), 2)

    # 显示结果
    cv2.imshow('image', img)
    #cv2.imshow('mask', mask)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def blue_identify_rectangle(image_path):
    # 读取图片
    img = cv2.imread(image_path)
    # 转换颜色空间为HSV
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    # 定义蓝色范围
    lower_blue = np.array([100, 43, 46])
    upper_blue = np.array([124, 255, 255])
    # 创建掩膜
    mask = cv2.inRange(hsv, lower_blue, upper_blue)
    # 进行图像处理
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # 绘制外接矩形
    for contour in contours:
        x, y, w, h = cv2.boundingRect(contour)
        cv2.rectangle(img, (x, y), (x + w, y + h), (255,0,0), 2)

    # 显示结果
    cv2.imshow('image', img)
    #cv2.imshow('mask', mask)
    cv2.waitKey(0)
    cv2.destroyAllWindows()



def yellow_identify_rectangle(image_path):
    # 读取图片
    img = cv2.imread(image_path)
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)  # 转换颜色空间为HSV

    # 定义橙黄范围
    lower_yellow = np.array([11, 43, 46])
    upper_yellow = np.array([25, 255, 255])
    lower_yellow2 = np.array([26, 43, 46])
    upper_yellow2 = np.array([43, 255, 255])

    # 创建掩膜
    mask1 = cv2.inRange(hsv, lower_yellow, upper_yellow)
    mask2 = cv2.inRange(hsv, lower_yellow2, upper_yellow2)
    mask = cv2.bitwise_or(mask1, mask2)

    # 进行图像处理
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # 绘制外接矩形
    for contour in contours:
        x, y, w, h = cv2.boundingRect(contour)
        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 255), 2)  # 将颜色修改为黄色

    # 显示结果
    cv2.imshow('image', img)
    #cv2.imshow('mask', mask)
    cv2.waitKey(0)
    cv2.destroyAllWindows()



def distance_to_camera(knownWidth, focalLength, perWidth):

    #计算并返回从目标到相机的距离
    return (knownWidth * focalLength) / perWidth


def identify_color_and_rectangle(image_path):
    frame = cv2.imread(image_path)
    color = detect_color(frame)
    if color == "Red":
        red_identify_rectangle(image_path)
    elif color == "Green":
        green_identify_rectangle(image_path)
    elif color == "Blue":
        blue_identify_rectangle(image_path)
    elif color == "Yellow":
        yellow_identify_rectangle(image_path)



#初始化已知距离从相机到对象，在这种情况下是60厘米
KNOWN_DISTANCE = 60

#初始化已知的物体宽度，在这种情况下，三角形是11.9厘米宽。
# A4纸的长和宽
KNOWN_WIDTH = 11.9
KNOWN_HEIGHT = 14.7

#加载包含一个距离我们相机60厘米的物体的第一张图像，然后找到图像中的纸张标记，并初始化焦距
#读入第一张图，通过已知距离计算相机焦距
image = cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\60_red_Color.png") #应使用摄像头拍的图
marker = find_marker5_5(image)
focalLength = (marker[1][0] * KNOWN_DISTANCE) / KNOWN_WIDTH  #  D’ = (W x F) / P

#-----------------------------------------------------------------------------------------------------------

#1
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\30_blue_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("30_blue_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\30_blue_Color.png")


#2
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\33_yellow_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("33_yellow_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\33_yellow_Color.png")


#3
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\38_green_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("38_green_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\38_green_Color.png")


#4
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\45_red_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("45_red_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\45_red_Color.png")


#5
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\48_green_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("48_green_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\48_green_Color.png")


#6
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\54_blue_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("54_blue_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\54_blue_Color.png")


#7
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\60_red_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("60_red_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\60_red_Color.png")


#8
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\65_red_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("65_red_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\65_red_Color.png")


#9
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\71_yellow_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("71_yellow_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\71_yellow_Color.png")


#10
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\72_blue_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("72_blue_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\72_blue_Color.png")


#11
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\80_red_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("80_red_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\80_red_Color.png")


#12
image_test30=cv2.imread(r"D:\BaiduNetdiskDownload\SRC\SRC\94_green_Color.png")
marker_test = find_marker5_5(image_test30)
distance_test = distance_to_camera(KNOWN_WIDTH,focalLength,marker_test[1][0])
print("图片 \"{}\" 中相机与标记物距离为 {:.2f} 厘米".format("94_green_Color.png", distance_test))

identify_color_and_rectangle(r"D:\BaiduNetdiskDownload\SRC\SRC\94_green_Color.png")