# -*- coding:utf-8 -*- import os, sys, time from ssat_sdk.device_manage.capturecard_manager import CCardManager from pic_tool import ImageCMP from sound_tool import AudioIdentify from picture.feature_detect import * from ssat_sdk.picture.color_space import CIEluvCaculator from ssat_sdk.sat_environment import * from ocr_convert import OCRConvert from ssat_sdk.picture import image_util from ssat_sdk.pic_tool import ImageCMP import cv2 as cv import thread import threading from ssat_sdk.utils import LoggingUtil from ssat_sdk.TvDetect.colorbar_detect import ColorBarDetect pyFileName = os.path.split(__file__)[-1] def get_current_function_name(): return inspect.stack()[1][3] # 模板匹配全局对象; g_threadMonitor = None g_monitorResult = {} g_stopThread = False class TvDetect(): def __init__(self): self.audioChecker = AudioIdentify() self.vp = VideoCapture() self.featureDetect = FeatureDetect() self.CIECaculator = CIEluvCaculator() self.OCR = OCRConvert() self.className = self.__class__.__name__ self.imageUtil = image_util.ImageUtil() self.imgCMP = ImageCMP() self.colorBarDetect = ColorBarDetect() ''' 检测电视锁屏。自行截取电视画面后检索 :return hasLockStr:是否有锁屏提示字符 :return isBlack:是否全是黑屏，没有画面 :return hasLockStr:是否有锁屏提示字符 ''' def detectLockScreen(self): # lockPic = r"D:\temp-pic\parentlock\channel_lock2.png" # lockPic = r"D:\temp-pic\parentlock\channel_lock1.png" # lockPic = r"D:\temp-pic\parentlock\source_lock1.png" lockPic = os.path.join(getSATTmpDIR(), "lock_screen.png") self.vp.takePicture(lockPic) return self.detectLockPic(lockPic) ''' 检测电视锁屏.根据提供的图片进行检测 :param lockPic：电视画面的图片路径 :return hasLockStr:是否有锁屏提示字符 :return isBlack:是否全是黑屏，没有画面 :return hasLockStr:是否有锁屏提示字符 ''' def detectLockPic(self, lockPic): maxDiff = 5 blackLuv = (11,96,136) hasLockStr = False isBlack = True lockRect = self.featureDetect.findRectByFile(lockPic, "parentLock") print lockRect rectPic = os.path.join(getSATTmpDIR(), "rect.png") image_util.saveCropPic(lockPic, rectPic, lockRect) info = self.OCR.getStr(rectPic, "english", 2) print "detectLockPic,str:",info if info.lower().find("locked") > 0: hasLockStr = True retImgList = image_util.saveRetCropPic(lockPic, lockRect) for index in range(retImgList.__len__()): # cv.imshow(str(index),retImgList[index]) imgLuv = cv.cvtColor(retImgList[index], cv.COLOR_BGR2Luv) l, u, v = self.CIECaculator.getAverageLUV(imgLuv) diffLevel = self.CIECaculator.getDiffuvLevel(blackLuv, (l, u, v)) if (diffLevel > maxDiff): isBlack = False # cv.waitKey(0) # cv.destroyAllWindows() # print hasLockStr, isBlack, lockPic return hasLockStr, isBlack, lockPic ''' 传入电视的重现率检测画面（22293/4 pattern304 或者TG39 mark画面），按像素计算重现率。 :param pic_path:重现率电视画面图片路径 :param scaleGray:刻度与悲剧G枪分界值 :param scaleMax_W:宽，即水平刻度数，不包含图像边界 :param scaleMax_H:高，即垂直刻度数，不包含图像边界 :param scaleUnit_W：宽，水平刻度单位值 :param scaleUnit_H: 高，垂直刻度单位值 :param scaleLineOffset：刻度线段可偏离像素点数 :return 浮点数组。[左边重显率，右边重显率，上边重显率，下边重显率] ''' def detectOverScan(self, pic_path, scaleMax_W=10, scaleMax_H=10, scaleUnit_W=0.02, scaleUnit_H=0.04, scaleLineOffset=3): img = cv.imread(pic_path) img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) h1, w1 = img_gray.shape center_height, center_width = self.findCenterPoint(img_gray) #计算左边重现率 # print "detectOverScan,scale_left" scale_left = self.detectWhiteScale(img_gray, scaleMax_W, scaleUnit_W, (0, center_height-scaleLineOffset), (center_width/3, center_height-scaleLineOffset)) # print "detectOverScan,scale_right" scale_right = self.detectWhiteScale(img_gray, scaleMax_W, scaleUnit_W, (w1-1, center_height-scaleLineOffset), (5*center_width/3, center_height-scaleLineOffset)) # print "detectOverScan,scale_up" scale_up = self.detectWhiteScale(img_gray, scaleMax_H, scaleUnit_H, (center_width-scaleLineOffset, 0), (center_width-scaleLineOffset, center_height/2)) # print "detectOverScan,scale_down" scale_down = self.detectWhiteScale(img_gray, scaleMax_H, scaleUnit_H, (center_width - scaleLineOffset, h1-1), (center_width - scaleLineOffset, 3*center_height / 2)) # print scale_left,scale_right,scale_up,scale_down return scale_left,scale_right,scale_up,scale_down ''' 寻找图片白色条相交中心点，例如：重现率图片 ''' def findCenterPoint(self, img): h1,w1 = img.shape center_x1 = 4 * w1 / 10 center_y1 = 4 * h1 / 10 center_x2 = 6 * w1 / 10 center_y2 = 6 * h1 / 10 # print center_x1, center_y1, center_x2, center_y2 area_center = [center_x1, center_y1, center_x2, center_y2] img_center = image_util.cutMat(img, area_center) h2, w2 = img_center.shape # print h2,w2,dim2 # 寻找中心点的高坐标 line_w = w2 / 20 line_1 = [line_w, h2 / 3, line_w, 2 * h2 / 3] # print "line_1:",line_1 center_height = center_y1 grayAvg1 = self.imageUtil.calGrayAvg(img_center, line_1) # print "grayAvg:",grayAvg1 for height in range(line_1[1], line_1[3]): if img_center[height, line_w] >= grayAvg1: center_height += height break print "center_height:",center_height # 寻找纵向直线的宽坐标 line_h = h2 / 20 line_2 = [w2 / 3, line_h, 2 * w2 / 3, line_h] center_width = center_x1 grayAvg2 = (np.max(line_1) + np.min(line_1)) / 2 for width in range(line_2[0], line_2[2]): if img_center[line_h, width] >= grayAvg2: center_width += width break print "center_width:", center_width return center_height, center_width ''' 判断是否在重显率画面 :param picPath：图片路径 :return True/False:True:是重显率画面，False：不是重显率 ''' def isOverScan(self, picPath): print "isOverScan,picPath:",picPath srcImg = cv.imread(picPath) height,widht,dim = srcImg.shape grayImg = cv.cvtColor(srcImg,cv.COLOR_BGR2GRAY) center_height, center_width = self.findCenterPoint(grayImg) dHeight = center_height*2.0/height dWidth = center_width*2.0/widht if 0.98 < dHeight < 1.02 and 0.98 < dWidth < 1.02: return True else: return False ''' 根据指定的直线，扫描刻度线条。去掉刻度线条宽度的影响，同时刻度线条和背景灰阶阈值，采用像素点平均值。 :param img:待检测图片。22293 pattern :param scaleLevel：刻度等级数，即多少条刻度线.刻度线不包含图像边界线。 :param scaleUnit: 每一个刻度，读数值 :param pointStart：刻度起始点坐标。 width-x,height-y坐标系 :param pointEnd: 刻度重点坐标。 width-x,height-y坐标系 :return 重显率scaleDG：取值范围 0.00 ~ 1.00 ''' def detectWhiteScale(self, img, scaleLevel, scaleUnit, pointStart, pointEnd, grayMidOffset = 50): grayMid = self.imageUtil.calGrayAvg(img, (pointStart[0],pointStart[1], pointEnd[0],pointEnd[1])) + grayMidOffset print "detectWhiteScale:pointStart:pointEnd:grayMid:",(pointStart,pointEnd, grayMid) scalePointList = [] w_list,h_list = self.genPointHWArray(pointStart,pointEnd) selPoint = None prevPoint = (w_list[0], h_list[0]) for height in h_list: for width in w_list: # print img[prevPoint[1], prevPoint[0]] , img[height,width] if img[height,width] > grayMid: if selPoint is None or \ (int(img[prevPoint[1], prevPoint[0]]) <= grayMid and image_util.caculateLinLen((selPoint[0],selPoint[1],width,height)) > 5): # 每条刻度的宽度像素点不定，取刻度的第一个像素点，作为刻度坐标 selPoint = (width,height) scalePointList.append(selPoint) prevPoint = (width,height) print u"刻度点列表:", scalePointList if scalePointList.__len__() < 2: print u"重显率检测失败，刻度点列表:", scalePointList return -1.0 x1,y1 = scalePointList[0] x2,y2 = scalePointList[1] step = image_util.caculateLinLen((x1,y1, x2,y2)) # print "detectWhiteScale step:", step hintLevel = scaleLevel - scalePointList.__len__() # print "detectWhiteScale hintLevel:",hintLevel # direction = self.featureDetect.lineUtil.lineDirect((x1,y1, x2,y2)) oneLevel = (step - (image_util.caculateLinLen((x1,y1,pointStart[0],pointStart[1]))))/step # print "detectWhiteScale oneLevel:",oneLevel scaleDG = 1 - (hintLevel*scaleUnit + oneLevel*scaleUnit) # print "detectWhiteScale scaleDG:",scaleDG return scaleDG ''' 将坐标全部存入数组，解决坐标从小到大和从大到小均可遍历问题。 ''' def genPointHWArray(self, pointStart, pointEnd): w1 = pointStart[0] h1 = pointStart[1] w2 = pointEnd[0] h2 = pointEnd[1] w_list = [] h_list = [] if w1 >= w2: for dw in range(0, w1-w2+1): w_list.append(w1-dw) else: for w in range(w1, w2+1): w_list.append(w) if h1 >= h2: for dh in range(0, h1-h2+1): h_list.append(h1-dh) else: for h in range(h1, h2+1): h_list.append(h) # print "w_list:",w_list # print "h_list:",h_list return w_list,h_list ''' 监听视频，查看是否会中途无声无像 :param 要监听时间长度。单位秒。 :param 要监听的画面，标准：0 代表黑屏，1 代表有画面 :param galleryDir.指定窗口样图路径，有代表需要监听，没有代表不需要监听 :param blackTh: 黑色图片判断阈值，低于或等于则表示为黑色。默认50 :return 两个数组：SoundExpList,VideoExpList。 list的格式：数组内存放字典。字典{"time":time.asctime( time.localtime(time.time()))}。 List里面的第一个time值，表示开始监听的时间。 SoundExpList第一个字典数据，有audio 键，取录音文件路径。status键：0 代表无异常；1代表没有声音发出；2代表声音有间断。 VideoExpList每一个异常字典数据，有picture键，取图片。第一个字典数据中，status键：0 代表一直有画面；1代表一直黑屏；2代表有黑屏出现，-1代表截图失败。 第一个字典数据中，motion_picture：1 代表运动画面，0 代表静态画面。 ''' def monitorVideo(self, seconds = 10, galleryDir = "", picTarget=1, blackTh = 50): soundExpList = [] soundTID = thread.start_new_thread(self.audioChecker.monitorSound, (seconds, soundExpList)) pictureExpList = [] picTID = thread.start_new_thread(self.monitorTvPicture, (seconds,pictureExpList, picTarget, blackTh)) global g_monitorResult if os.path.exists(unicode(galleryDir)) == True: self.startMonitorAbnormal(seconds, galleryDir) count = 0 while soundExpList.__len__() < 1 or pictureExpList.__len__() < 1: print "monitorVideo ...seconds:",count time.sleep(1) count += 1 # print "monitorVideo, abnormal:",g_monitorResult # 为保持向前兼容，g_monitorResult结果单独使用getMonitorAbnormalResults获取 return soundExpList,pictureExpList#,g_monitorResult def monitorTvPicture(self,seconds, expList, picTarget=1, blackTh = 50): hasImage = False startSeconds = time.time() expList.append({"time": time.asctime(time.localtime(startSeconds)),"picture":"", "status":0}) expList[0]["motion_picture"] = 0 #默认为静态画面 curSeconds = time.time() prevPic = os.path.join(getSATTmpDIR(), "monitorTvPicture" + str(time.time()) + ".png") self.vp.takePicture(prevPic) LoggingUtil.printLog("Record picture...") while (curSeconds - startSeconds) < seconds: currentPic = os.path.join(getSATTmpDIR(), "monitorTvPicture"+str(time.time())+".png") self.vp.takePicture(currentPic) # 加0.5秒延时，防止截图过快导致异常 time.sleep(0.5) curSeconds = time.time() try: #检测画面是否纯黑色背景 if picTarget == 1:#黑屏无画面，异常 if (self.imgCMP.isBlack(currentPic)): expList.append({"time":time.asctime(time.localtime(curSeconds)),"picture":currentPic}) else: hasImage = True else: #黑屏无画面，正常 if (self.imgCMP.isBlack(currentPic, blackTh)): pass else: expList.append({"time":time.asctime(time.localtime(curSeconds)),"picture":currentPic}) hasImage = True except Exception,e: # 未能正常截到图，导致测试失败 LoggingUtil.printLog(u"monitorTvPicture截图失败！！！\nErrorMsg:%s\ncurrentPic路径：%s\n"%(e,currentPic)) expList[0]["status"] = -1 return #检测画面是动态还是静态 if self.imgCMP.cmpPicTotal(prevPic, currentPic, expDotRate=0) is False: expList[0]["motion_picture"] = 1 prevPic = currentPic LoggingUtil.printLog("Record picture End") if hasImage and expList.__len__() == 1: expList[0]["status"] = 0 elif hasImage and expList.__len__() > 1: expList[0]["status"] = 2 else: expList[0]["status"] = 1 ''' # 描述：监控异常 # 参数： # seconds：监控时长. # galleryDir：图库目录路径 # 返回：bool, fileAbnormal, coordinate，fileTV # True：有异常，False：正常 # fileAbnormal：异常时，与异常匹配的图库文件路径 # coordinate：异常时，异常框的坐标。 # fileTV：出现异常的视频截图路径。 # ''' def monitorAbnormal(self, seconds, galleryDir): pic_path = "" result = {"result": False, "tmpVal":0, "galleryFile":"", "coordinate":[0,0,0,0]} setting = {'method':5, 'colorType':0, 'thresholdVal':0, 'thresholdMaxVal':255} #可从配置文件读取,不用从参数传入 global g_stopThread startSeconds = time.time() while g_stopThread == False: # 一秒截一图; pic_path = os.path.join(getAbnormalDir(), time.strftime('%Y%m%d%H%M%S',time.localtime(time.time()))+".png") self.vp.takePicture(pic_path) # 异常匹配; result = self.featureDetect.matchImage(pic_path, None, galleryDir, setting) if result["result"] == True: result["screenFile"] = pic_path break # 删除无异常的截图; os.remove(pic_path) # 超时退出线程; if int(time.time() - startSeconds) > seconds: break # 返回全局对象; if result["result"] == False: result["screenFile"] = "" global g_monitorResult g_monitorResult = result print u'异常监控结果：',g_monitorResult["result"],g_monitorResult["tmpVal"],g_monitorResult["coordinate"],g_monitorResult["screenFile"].encode('gb2312'),g_monitorResult["galleryFile"].encode('gb2312') # 启动监控线程; def startMonitorAbnormal(self, seconds, galleryDir): global g_threadMonitor,g_stopThread if g_threadMonitor is not None and g_threadMonitor.is_alive() == True: print u'线程已运行' return g_stopThread = False g_threadMonitor = threading.Thread(target=self.monitorAbnormal, name='MonitorAbnormal', args=(seconds,galleryDir)) g_threadMonitor.start() # 停止监控; def stopMonitorAbnormal(self): global g_threadMonitor,g_stopThread if g_threadMonitor is not None and g_threadMonitor.is_alive() == True: g_stopThread = True print u'开始停止' else: print u'线程已停止' ''' # 描述：获取监控结果 # # ''' def getMonitorAbnormalResults(self): global g_monitorResult return g_monitorResult ''' HDMI重显率测试：1080P及以上分辨率重显率为100%；1080P分辨率以下重显率为95%-97%，显示器模式时为100%. 片源 22294： pattern：304 根据传入的图片和重显率要求，返回检测结果。 重现率最小界限，增加0.01容错。两边偏移不超过0.02 :param picPath: 电视截图路径 :param resolution: "Full":全屏显示。 "HD"：高清， "SD":标清 :param offsetMax = 0.02#中心点偏移的容错值 :param downTh = 0.01#重现率偏小的容错值 :return :两个参数。参数1 True或者False，参数2， 具体结果参数数组。 ''' def detectHDMIOverScan(self, picPath, resolution="", STD=[],offsetMax = 0.02, downTh = 0): print "detectHDMIOverScan:", picPath, resolution if STD == []: hdmiRSTD = {"full":[1.0,1.0], "hd":[1.0,1.0], "sd":[0.95,0.97]} STD = hdmiRSTD[resolution.lower()] left, right, up, down = self.detectOverScan(picPath) # print "detectHDMIOverScan,left, right, up, down:", left, right, up, down hOverscan, hOffset = self.calOverScan(left,right) vOverscan, vOffset = self.calOverScan(up,down) if hOverscan + downTh >= STD[0] and hOverscan <= STD[1] and hOffset < offsetMax\ and (vOverscan + downTh) >= STD[0] and vOverscan <= STD[1] and vOffset < offsetMax: return True, [resolution, STD, [(hOverscan,hOffset), (vOverscan,vOffset)]] else: return False, [resolution, STD, [(hOverscan,hOffset), (vOverscan,vOffset)]] def calOverScan(self, side1, side2): scale = (side1+side2)/2 return round(scale, 3), round(abs(side1-side2),3) ''' AV重显率测试：重显率为95%-97% 片源 22294： pattern：304 重现率最小界限，增加0.01容错。两边偏移不超过0.02 根据传入的图片和重显率要求，返回检测结果。 :param picPath: 电视截图路径 :param offsetMax = 0.02#中心点偏移的容错值 :param downTh = 0.01#重现率偏小的容错值 :return :两个参数。参数1 True或者False，参数2， 具体结果参数数组。 ''' def detectAVOverScan(self, picPath, STD = [0.95,0.97], offsetMax = 0.02, downTh = 0): print "detectAVOverScan:", picPath left, right, up, down = self.detectOverScan(picPath) # print "detectAVOverScan,left, right, up, down:", left, right, up, down hOverscan, hOffset = self.calOverScan(left,right) vOverscan, vOffset = self.calOverScan(up,down) if hOverscan+downTh >= STD[0] and vOverscan <= STD[1] and hOffset < offsetMax\ and hOverscan+downTh >= STD[0] and vOverscan <= STD[1] and vOffset < offsetMax: return True, [STD, [(hOverscan, hOffset), (vOverscan, vOffset)]] else: return False, [STD, [(hOverscan, hOffset), (vOverscan, vOffset)]] ''' ATV重显率（重现率要求95%-97%之间，（行6.5-7，帧5-6） 片源 检测片源TG39 mark 根据传入的图片和重显率要求，返回检测结果。 重现率最小界限，增加0.01容错。两边偏移不超过0.02 :param picPath: 电视截图路径 :param offsetMax = 0.02#中心点偏移的容错值 :param downTh = 0.01#重现率偏小的容错值 :return :两个参数。参数1 True或者False，参数2， 具体结果参数数组。 ''' def detectAtvOverScan(self, picPath, STD = [0.95, 0.97], offsetMax = 0.02, downTh = 0): print "detectAtvOverScan:", picPath left, right, up, down = self.detectOverScan(picPath, scaleMax_W=4, scaleMax_H=5, scaleUnit_W=0.05, scaleUnit_H=0.05, scaleLineOffset=5) # print "detectAtvOverScan,left, right, up, down:", left, right, up, down hOverscan, hOffset = self.calOverScan(left,right) vOverscan, vOffset = self.calOverScan(up,down) if (hOverscan + downTh) >= STD[0] and hOverscan <= STD[1] and hOffset < offsetMax \ and (vOverscan + downTh) >= STD[0] and vOverscan <= STD[1] and vOffset < offsetMax: return True, [STD, [(hOverscan, hOffset), (vOverscan, vOffset)]] else: return False, [STD, [(hOverscan, hOffset), (vOverscan, vOffset)]] def detectAtv3116OverScan(self, picPath, STD = [0.95, 0.97], offsetMax = 0.02, downTh = 0): print "detectAtv3116OverScan:", picPath left, right, up, down = self.detectOverScan(picPath, scaleMax_W=4, scaleMax_H=3, scaleUnit_W=0.05, scaleUnit_H=0.05, scaleLineOffset=5) # print "detectAtvOverScan,left, right, up, down:", left, right, up, down hOverscan, hOffset = self.calOverScan(left, right) vOverscan, vOffset = self.calOverScan(up, down) if (hOverscan + downTh) >= STD[0] and hOverscan <= STD[1] and hOffset < offsetMax \ and (vOverscan + downTh) >= STD[0] and vOverscan <= STD[1] and vOffset < offsetMax: return True, [STD, [(hOverscan, hOffset), (vOverscan, vOffset)]] else: return False, [STD, [(hOverscan, hOffset), (vOverscan, vOffset)]] ''' 假定重现率正确 检测画面：TG39 网格 根据传入的网格图片，判断比例模式是否正确。 :param mode: "full", origin, smart, zoom :param testPic: 图片路径 :return :1个参数。参数1 True或者False ''' def detectATVAspectRatio(self, testPic, mode): scale_W = 17.0 scale_H = 13.0 widthRatio = 0 heightRatio = 0 if mode == "full": widthRatio = 1.0 heightRatio = 1.0 elif mode == "origin": widthRatio = 1.0 heightRatio = 0 elif mode == "smart": widthRatio = 1.0 heightRatio = 11/scale_H elif mode == "zoom": widthRatio = 1.0 heightRatio= 9/scale_H else: pass return self.detectAspectRatio(testPic, scale_W, scale_H,widthRatio,heightRatio) ''' 假定重现率正确 检测画面：22294 Timing65 Pattern55 根据传入的网格图片，判断比例模式是否正确。 :param mode: "full", origin, smart, zoom :param testPic: 图片路径 :return :1个参数。参数1 True或者False ''' def detectHDMIAspectRatio(self, testPic, mode): scale_W = 15.0 scale_H = 11.0 widthRatio = 0 heightRatio = 0 if mode == "full": widthRatio = 1.0 heightRatio = 1.0 elif mode == "origin": widthRatio = 1.0 heightRatio = 0 elif mode == "smart": widthRatio = 1.0 heightRatio = 11 / scale_H elif mode == "zoom": widthRatio = 1.0 heightRatio = 9 / scale_H else: pass return self.detectAspectRatio(testPic, scale_W, scale_H,widthRatio,heightRatio) ''' 假定重显率正确 检测画面：22294 Timing36 Pattern55 根据传入的网格图片，判断比例模式是否正确。 :param mode: "full", origin, smart, zoom :param testPic: 图片路径 :return :1个参数。参数1 True或者False ''' def detectAVAspectRatio(self, testPic, mode): return self.detectHDMIAspectRatio(testPic,mode) ''' 根据传入的网格图片，判断比例模式是否正确。 :param mode: "full", origin, smart, zoom :param testPic: 图片路径 :param scale_W:水平宽的网格线数量 :param scale_H：垂直高的网格线数量 :param widthRatio：相比于origin，水平宽的比例要求 :param heightRatio：相比于origin，垂直高的比例要求 :param scaleGray：网格黑色背景和白色刻度线的G枪分界线 :return :1个参数。参数1 True或者False ''' def detectAspectRatio(self, testPic, scale_W, scale_H, widthRatio, heightRatio,scaleGray=80): print "detectAspectRatio:", scale_W, scale_H img = cv.imread(testPic) height, width, color =img.shape scalePointListW = self.getScaleNumber(img, (0,5), (width-1, 5), scaleGray) print "detectAspectRatio,scalePointListW:",scalePointListW.__len__(),scalePointListW scalePointListH = self.getScaleNumber(img, (5,0), (5, height-1), scaleGray) print "detectAspectRatio,scalePointListH:",scalePointListH.__len__(),scalePointListH # print "detectAspectRatio:",scalePointListW.__len__() /scale_W,widthRatio,scalePointListH.__len__() / scale_H,heightRatio if scalePointListW.__len__() /scale_W == widthRatio\ and scalePointListH.__len__() / scale_H == heightRatio: return True else: return False def getScaleNumber(self, img,pointStart,pointEnd, scaleGray): # print "getScaleNumber:", pointStart, pointEnd scalePointList = [] w_list, h_list = self.genPointHWArray(pointStart, pointEnd) selPoint = None prevPoint = (w_list[0], h_list[0]) for height in h_list: for width in w_list: # print img[prevPoint[1], prevPoint[0]][1] , img[height,width][1],prevPoint[1], prevPoint[0] if img[height, width][1] > scaleGray: if selPoint is None or \ int(img[prevPoint[1], prevPoint[0]][1]) <= scaleGray: # 每条刻度的宽度像素点不定，取刻度的第一个像素点，作为刻度坐标 selPoint = (width, height) scalePointList.append(selPoint) prevPoint = (width, height) return scalePointList ''' 检测电视是否已经关机 检测方式：1 检测画面是否有变化；检测连续5张截图，均没有变化，且四个角落为相同纯色，且没有声音，则表示处于关机状态。 声音检测和纯色检测，可选。 :param : checkSignle:选择是否要检测四周纯色。 :param ：checkAudio ： 是否要检测无声。 :param : colorOffset : 颜色允许的偏移量 :param : expDotRate : 异常点比例范围上限.前后两张图片差分时的差异点比例。 :return : [检测结果，[图片地址列表], [音频地址列表]] ''' def detectPowerOff(self, checkSignle=True, checkAudio=True, colorOffset=20, expDotRate = 0.0001): picList = [] soundList = [] ccard= CCardManager() count = 0 matchCount = 0 previewPic = os.path.join(getSATTmpDIR(), "detectPowerOff_"+str(time.time())+".png") ccard.takePicture(previewPic) picList.append(previewPic) while count < 5: currentPic = os.path.join(getSATTmpDIR(), "detectPowerOff_"+str(time.time())+".png") ret = ccard.takePicture(currentPic) print "detectPowerOff,截图：",ret if ret == 1: count += 1 ret1 = self.imgCMP.cmpPicTotal(previewPic, currentPic, colorOffset, expDotRate) print "detectPowerOff,前后图片比对：",ret1 #检测4个角落纯色 if checkSignle is True: ret2 = self.imgCMP.checkAroundSSColor(currentPic) print "detectPowerOff,四周相同纯色：", ret2 else: ret2= True if ret1 and ret2: matchCount += 1 previewPic = currentPic picList.append(currentPic) if matchCount < 5: return False, picList, soundList #检测声音 if checkAudio is True: self.audioChecker.startCHK(5) soundList.append(self.audioChecker.audioFile) return not self.audioChecker.isOK(), picList, soundList else: return True, picList, soundList def isColorBar(self, picPath, type): if type.lower()=="hdmi" or type.lower()=="dtv": return self.colorBarDetect.isHDMIColorBar(picPath) elif type.lower()=="av": return self.colorBarDetect.isAVColorBar(picPath) elif type.lower()=="atv": return self.colorBarDetect.isATVColorBar(picPath) else: return False if __name__ == "__main__": tvDetect = TvDetect() # pic = "D:/test/4k2.jpg" pic = "D:/test/colorbar_hdmi_std.png" ret = tvDetect.isColorBar(pic,"hdmi") print "isColorBar HDMI:",ret ret = tvDetect.isColorBar(pic,"dtv") print "isColorBar DTV:",ret ret = tvDetect.isColorBar(pic,"av") print "isColorBar AV:",ret ret = tvDetect.isColorBar(pic,"atv") print "isColorBar ATV:",ret # print "detectHDMIOverScan:", tvDetect.detectHDMIOverScan(pic,"full") # lockPic = r"D:\temp-pic\parentlock\unlockChannel_channelLock.jpg" # lockPic = r"D:\temp-pic\parentlock\unlockTV_image.jpg" # lockPic = r"D:\temp-pic\parentlock\inputLock_image.jpg" # print tvDetect.detectLockPic(lockPic) # print tvDetect.monitorVideo(500) # time.sleep(2) # print tvDetect.startMonitorAbnormal(1000, r'C:\Users\jianfeng1.wang\Pictures\图库') # print tvDetect.startMonitorAbnormal(10, r'C:\Users\jianfeng1.wang\Pictures\图库') # time.sleep(10) # tvDetect.stopMonitorAbnormal() # time.sleep(11) # print tvDetect.startMonitorAbnormal(10, r'C:\Users\jianfeng1.wang\Pictures\图库')