首页 > 解决方案 > Opencv 屏幕记录作为视频处理的输入

问题描述

试图让屏幕记录充当我的代码的视频流输入,目前正在尝试使用 mss 循环来捕获屏幕,这是有效的

import time
import cv2
import mss
import numpy

with mss.mss() as sct:
    monitor = {"top": 40, "left": 0, "width": 800, "height": 640}

    while "Screen capturing":
        last_time = time.time()

    
        img = numpy.array(sct.grab(monitor))

        cv2.imshow("OpenCV/Numpy normal", img)

    #    print("fps: {}".format(1 / (time.time() - last_time)))

        # Press "q" to quit
        if cv2.waitKey(25) & 0xFF == ord("q"):
            cv2.destroyAllWindows()
            break

这将显示一个 cv2imshow 窗口,该窗口更新并显示我的屏幕的一部分,因此部分工作。我想将此设置为以下函数的输入。

from moviepy.editor import VideoFileClip
from IPython.display import HTML
import numpy as np
import cv2
import pickle
import glob
from tracker import tracker
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.gridspec as gridspec
import mss
import time

def process_image(img):
        #undistort the image
        
      
        bot_width = .80 # percentage of bottom trapezoidal height 76
        mid_width = .20 # percentage of mid trapezoidal height 08
        height_pct = .45 # percentage of trapezoidal height 62
        bottom_trim= .75 # percentage from top to bottom avoiding the hood of the car
    
       
        
        #img = cv2.undistort(img,mtx,dist,None,mtx)
        src = np.float32([[img.shape[1]*(0.5-mid_width/2), img.shape[0]*height_pct],[img.shape[1]*(0.5+mid_width/2),img.shape[0]*height_pct],[img.shape[1]*(0.5+bot_width/2), img.shape[0]*bottom_trim],[img.shape[1]*(0.5-bot_width/2), img.shape[0]*bottom_trim]])
        warptrap = np.copy(img)
        cv2.line(warptrap, (int(src[0][0]), int(src[0][1])), (int(src[1][0]), int(src[1][1])), [255,0,0], 10, cv2.LINE_AA)
        cv2.line(warptrap, (int(src[1][0]), int(src[1][1])), (int(src[2][0]), int(src[2][1])), [255,0,0], 10, cv2.LINE_AA)
        cv2.line(warptrap, (int(src[2][0]), int(src[2][1])), (int(src[3][0]), int(src[3][1])), [255,0,0], 10, cv2.LINE_AA)
        cv2.line(warptrap, (int(src[3][0]), int(src[3][1])), (int(src[0][0]), int(src[0][1])), [255,0,0], 10, cv2.LINE_AA)
        
        #pass image thru the pipeline
        #preprocessImage = np.zeros_like(img[:,:,0])
        #gradx = abs_sobel_thresh(img, orient='x',thresh_min=20, thresh_max=100)
        #s_binary = s_channel_threshold(img, sthresh=(170,255))
        #preprocessImage[((gradx == 1) | (s_binary == 1))] = 1
        
       
        
        preprocessImage = np.zeros_like(img[:,:,0])
        gradx = abs_sobel_thresh(img, orient='x', thresh_min=12, thresh_max=255)
        grady = abs_sobel_thresh(img, orient='y', thresh_min=25, thresh_max=255)
        c_binary = color_threshold(img, sthresh=(100,255), vthresh=(50,255))
        preprocessImage[((gradx == 1) & (grady ==1) | (c_binary == 1))] = 255
    
        binaryImage = np.copy(preprocessImage)
        binaryImage = np.array(cv2.merge((binaryImage,binaryImage,binaryImage)),np.uint8)
        cv2.putText(binaryImage, 'Binary Image',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),2)
        
        img_size = (img.shape[1],img.shape[0])
        
       
        src = np.float32([[img.shape[1]*(0.5-mid_width/2), img.shape[0]*height_pct],[img.shape[1]*(0.5+mid_width/2),img.shape[0]*height_pct],[img.shape[1]*(0.5+bot_width/2), img.shape[0]*bottom_trim],[img.shape[1]*(0.5-bot_width/2), img.shape[0]*bottom_trim]])
        offset = img_size[0]*0.25
        dst = np.float32([[offset,0],[img_size[0]-offset,0],[img_size[0]-offset,img_size[1]],[offset,img_size[1]]])   
        
        #perform the warp perspective transform
        M = cv2.getPerspectiveTransform(src,dst) #M
        Minv = cv2.getPerspectiveTransform(dst,src)
        
        
       #############
    
    
        ######################
        warped = cv2.warpPerspective(preprocessImage, M, img_size, flags=cv2.INTER_LINEAR)
        
        window_width = 25 #25
        window_height = 80 #80
        
        #set up the overall class to do the lane line tracking
        curve_centers = tracker(Mywindow_width=window_width, Mywindow_height=window_height, Mymargin = 25, My_ym = 10/720, My_xm = 4/384, Mysmooth_factor=15)
        
        window_centroids = curve_centers.find_window_centroids(warped)
        
        # Points used to draw all the left and right windows
        l_points = np.zeros_like(warped)
        r_points = np.zeros_like(warped)
            
        # points used to find the right & left lanes
        rightx = []
        leftx = []
    
        # Go through each level and draw the windows 
        for level in range(0,len(window_centroids)):
            # Window_mask is a function to draw window areas
            # Add center value found in frame to the list of lane points per left, right
            leftx.append(window_centroids[level][0])
            rightx.append(window_centroids[level][1])
    
            l_mask = window_mask(window_width,window_height,warped,window_centroids[level][0],level)
            r_mask = window_mask(window_width,window_height,warped,window_centroids[level][1],level)
            # Add graphic points from window mask here to total pixels found 
            l_points[(l_points == 255) | ((l_mask == 1) ) ] = 255
            r_points[(r_points == 255) | ((r_mask == 1) ) ] = 255
    
        # Draw the results
        template = np.array(r_points+l_points,np.uint8) # add both left and right window pixels together
        zero_channel = np.zeros_like(template) # create a zero color channel
        template = np.array(cv2.merge((zero_channel,template,zero_channel)),np.uint8) # make window pixels green
        warpage = np.array(cv2.merge((warped,warped,warped)),np.uint8) # making the original road pixels 3 color channels
        result = cv2.addWeighted(warpage, 1, template, 0.5, 0.0) # overlay the original road image with window results
        
        
        windowfit = np.copy(result)
        cv2.putText(windowfit, 'Sliding window results',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),2)
        
        warpage1 = np.copy(warpage)
        cv2.putText(warpage1, 'Bird\'s-eye View',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),2)
        cv2.line(warpage1, (int(dst[0][0]), int(dst[0][1])), (int(dst[1][0]), int(dst[1][1])), [0,0,255], 10, cv2.LINE_AA)
        cv2.line(warpage1, (int(dst[1][0]), int(dst[1][1])), (int(dst[2][0]), int(dst[2][1])), [0,0,255], 10, cv2.LINE_AA)
        cv2.line(warpage1, (int(dst[2][0]), int(dst[2][1])), (int(dst[3][0]), int(dst[3][1])), [0,0,255], 10, cv2.LINE_AA)
        cv2.line(warpage1, (int(dst[3][0]), int(dst[3][1])), (int(dst[0][0]), int(dst[0][1])), [0,0,255], 10, cv2.LINE_AA)
        
        #fit the lane boundaries to the left, right center positions found
        yvals = range(0,warped.shape[0])
        
        res_yvals = np.arange(warped.shape[0]-(window_height/2),0,-window_height)
        
        left_fit = np.polyfit(res_yvals, leftx, 2)
        left_fitx = left_fit[0]*yvals*yvals + left_fit[1]*yvals + left_fit[2]
        left_fitx = np.array(left_fitx,np.int32)
        
        right_fit = np.polyfit(res_yvals, rightx, 2)
        right_fitx = right_fit[0]*yvals*yvals + right_fit[1]*yvals + right_fit[2]
        right_fitx = np.array(right_fitx,np.int32)
        
        left_lane = np.array(list(zip(np.concatenate((left_fitx-window_width/2, left_fitx[::-1]+window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32)
        right_lane = np.array(list(zip(np.concatenate((right_fitx-window_width/2, right_fitx[::-1]+window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32)
        middle_marker = np.array(list(zip(np.concatenate((right_fitx-window_width/2, right_fitx[::-1]+window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32)
        inner_lane = np.array(list(zip(np.concatenate((left_fitx+window_width/2, right_fitx[::-1]-window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32)
    
        road = np.zeros_like(img)
        road_bkg = np.zeros_like(img)
        cv2.fillPoly(road,[left_lane],color=[255,0,0])
        cv2.fillPoly(road,[right_lane],color=[0,0,255])
        cv2.fillPoly(road,[inner_lane],color=[0,255,0])
        cv2.fillPoly(road_bkg,[left_lane],color=[255,255,255])
        cv2.fillPoly(road_bkg,[right_lane],color=[255,255,255])
        
        #Results screen portion for polynomial fit
        road1 = np.copy(road)
        cv2.putText(road1, 'Polynomial fit',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),2)
        
        road_warped = cv2.warpPerspective(road,Minv,img_size,flags=cv2.INTER_LINEAR)
        road_warped_bkg= cv2.warpPerspective(road_bkg,Minv,img_size,flags=cv2.INTER_LINEAR)
        
        base = cv2.addWeighted(img,1.0,road_warped, -1.0, 0.0)
        result = cv2.addWeighted(base,1.0,road_warped, 1.0, 0.0)
        ym_per_pix = curve_centers.ym_per_pix # meters per pixel in y dimension
        xm_per_pix = curve_centers.xm_per_pix # meters per pixel in x dimension
        #plt.imshow(result)
        #plt.title('Final image results')
        #plt.show()
        curve_fit_cr = np.polyfit(np.array(res_yvals,np.float32)*ym_per_pix,np.array(leftx,np.float32)*xm_per_pix,2)
        curverad = ((1 + (2*curve_fit_cr[0]*yvals[-1]*ym_per_pix + curve_fit_cr[1])**2)**1.5) /np.absolute(2*curve_fit_cr[0])
        
        # Calculate the offset of the car on the road
        camera_center = (left_fitx[-1] + right_fitx[-1])/2
        center_diff = (camera_center-warped.shape[1]/2)*xm_per_pix
        side_pos = 'Right'
        if center_diff <= 0:
            side_pos = 'left'
            
        #extract left rigth wheel turning
    
        # draw the text showing curvature, offset & speed
        
        cv2.putText(result, 'Radius of Curvature='+str(round(curverad,3))+'m ',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
        #cv2.putText(result, 'Vehicle is '+str(abs(round(center_diff,3)))+'m '+side_pos+' of center',(50,100), cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
        cv2.putText(result, 'Turn Wheel '+str(abs(round(center_diff,3)))+'m '+side_pos,(50,100), cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
        #file.write("turnwheel" + center_diff + side_pos +"/n")
    
        height, width = 1080, 1920
        FinalScreen = np.zeros((height, width, 3), dtype=np.uint8)
        FinalScreen[0:1080,0:1920] = cv2.resize(result, (1920,1080), interpolation=cv2.INTER_AREA)
       # FinalScreen[0:360,1280:1920] = cv2.resize(warptrap, (640,360), interpolation=cv2.INTER_AREA)
       # FinalScreen[360:720,1280:1920] = cv2.resize(binaryImage, (640,360), interpolation=cv2.INTER_AREA)
       # FinalScreen[720:1080,1280:1920] = cv2.resize(warpage1, (640,360), interpolation=cv2.INTER_AREA)
       # FinalScreen[720:1080,0:640] = cv2.resize(windowfit, (640,360), interpolation=cv2.INTER_AREA)
       # FinalScreen[720:1080,640:1280] = cv2.resize(road1, (640,360), interpolation=cv2.INTER_AREA)
        return FinalScreen
    
    
    #Output_video = 'output1_tracked.mp4'
    Input_video = 'h2o.mp4'
    Output_video = 'h2finalundistort.mp4'
    #Input_video = 'harder_challenge_video.mp4'
    #Output_video = 'output_challenge_video.mp4'
    #Input_video = 'challenge_video.mp4'
    
    clip1 = VideoFileClip(Input_video)
    video_clip = clip1.fl_image(process_image) # This function expects color images
    video_clip.write_videofile(Output_video, audio=False)

而不是视频文件作为输入,我想使用屏幕录制并使用 cv2.imshow(result) 显示 def live 的输出

标签: pythoninputvideo-processingopencv-pythonscreen-recording

解决方案


推荐阅读