ROI 성공


그레이처리, 가우시안 블러, 캐니 엣지, 허프변환 , ROI 를 사용해 직선과 곡선을 찾아낸다.



#!/usr/bin/env python
# -*- coding: cp949 -*-

import rospy
import cv2
import numpy as np
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image
from sensor_msgs.msg import CompressedImage


class Display_image():
def __init__(self):
self.selecting_sub_image = "raw"

if self.selecting_sub_image == "compressed":
self._sub = rospy.Subscriber('/usb_cam/image_raw/compressed', CompressedImage, self.callback, queue_size=1)
else:
self._sub = rospy.Subscriber('/usb_cam/image_raw', Image, self.callback, queue_size=1)

self.bridge = CvBridge()

def callback(self, image_msg):

if self.selecting_sub_image == "compressed":
#converting compressed image to opencv image
np_arr = np.fromstring(image_msg.data, np.uint8)
cv_img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)

elif self.selecting_sub_image == "raw":
cv_img = self.bridge.imgmsg_to_cv2(image_msg, "bgr8")

    def gaussian_blur(img, kernel_size):
        return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)
    
    def region_of_interest(img, vertices):

        mask = np.zeros_like(cv_img)
        cv2.fillPoly(mask,vertices, 255)
        ROI_image = cv2.bitwise_and(img, mask)
        return ROI_image

    def draw_lines(img, lines, color=[0, 0, 255], thickness=2):
        for line in lines:
        for x1,y1,x2,y2 in line:
            cv2.line(img, (x1, y1), (x2, y2), color, thickness)

    def hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):
        lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)
        line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
        draw_lines(line_img, lines)

        return line_img

    def weighted_img(img, initial_img, a=1, b=1., c=0.):

     return cv2.addWeighted(initial_img, a, img, b, c)

    
    height, width = cv_img.shape[:2]

    r= 800.0/cv_img.shape[1]

    dim = (800,int(cv_img.shape[0]*r))

    #cv_img = cv2.resize(cv_img, dim, interpolation = cv2.INTER_AREA)
    
    px = cv_img.shape[0]
    px1 = cv_img.shape[1]
    #print(px,px1)

    #mask = np.zeros_like(cv_img)
    #px = mask.shape[0]
    #px1 = mask.shape[1]
    #print(px,px1)

    vertices = np.array([[(50,height),(width/2-45, height/2+60), (width/2+45, height/2+60), (width-50,height)]], dtype=np.int32)
    
    #vertices = np.array([[10,500], [10,300], [300,200], [500,200], [800,300], [800,500],],np.int32)
    
    ROI_img = region_of_interest(cv_img, [vertices])

    cv_gray = cv2.cvtColor(ROI_img, cv2.COLOR_RGB2GRAY)

    cv_blur = gaussian_blur(cv_gray, 3)

    cv_edge = cv2.Canny(cv_blur, 10, 80)

    #vertices = np.array([[(50,height),(width/2-45, height/2+60), (width/2+45, height/2+60), (width-50,height)]], dtype=np.int32)
    
    hough_img = hough_lines(cv_edge, 1, 1 * np.pi/180, 30, 10, 20)

    result = weighted_img(hough_img, cv_img)

cv2.imshow('cv_image', result), cv2.waitKey(1)

def main(self):
rospy.spin()

if __name__ == '__main__':
rospy.init_node('Display_image')
node = Display_image()
node.main()