# -*- coding:utf-8 -*- from ssat_sdk.utils.LoggingUtil import printLog from ssat_sdk.utils.string_util import getDigitFromString from ssat_sdk.device_manage.capturecard_manager import CCardManager from ssat_sdk.MenuTree3.TExcelParser import CExcelParser from ssat_sdk.MenuTree3.UIT_runner import UITRunner from ssat_sdk import getMenuTree3SelectedProjectCfgPath, OCRConvert, getSATTmpDIR, ImageCMP, \ getMenuTree3SelectedPExcelPath, getMenuTree3SelectedTvExcelPath from ssat_sdk.MenuTree3.TFocus import TFocus from ssat_sdk.MenuTree3.TConfig import TConfig from ssat_sdk.MenuTree3.TSourceImpl import TSourceImpl from ssat_sdk.tv_operator import * import json import time import cv2 as cv from ssat_sdk.utils.string_util import strcmp from ssat_sdk.picture.DoubleImage import DoubleImage from ssat_sdk.source_input import SourceGenInput g_level = ['First', 'Second', 'Third', 'Fourth', 'Fifth', 'Sixth', 'Seventh', 'Eighth', 'Ninth', 'Tenth', 'Eleventh', 'Twelfth'] class CTMenu(): # def __init__(self, ocrDict={"lan": "CHN_ENG", "type": 10000}): def __init__(self, ocrDict=[{"lan": "ChinesePRC+English", "type": 4}, {"lan": "ChinesePRC+English", "type": 253}, {"lan": "ChinesePRC+English", "type": 10001}]): self.uitRunner = UITRunner() self.uitPathManage = self.uitRunner.uitPathManage # 创建视频采集对象 self.ccard = CCardManager() # 创建OCR对象 self.ocr = OCRConvert() # 图片切割对象 self.imgCMP = ImageCMP() # 读取excel并解析出内容; # 红老鼠遥控对象; self.redRat3 = TvOperator() # 配置文件; self.tconfig = self.uitRunner.uitData.tConfig self.icon_shape = [1920, 1080] if self.tconfig.has_option('Screen', 'shape'): self.icon_shape = self.tconfig.get_value_dict('Screen', 'shape') # 截图,获取分辨率; self.Screen = [1920, 1080] pic = self.getCurrentUIPath() if os.path.exists(pic) is True: img = cv.imread(pic) if img is not None: self.Screen = [img.shape[1], img.shape[0]] # 创建获取聚焦区域对象 self.tFocus = TFocus(getMenuTree3SelectedProjectCfgPath(), self.uitRunner, self.Screen, self.icon_shape) self.ocrDict = ocrDict # 某数据是否读取过; self.got_dict = {} # 22293 self.sourceInput = SourceGenInput() self.tSource = TSourceImpl(self.ocr, self.ccard, self.redRat3, self.tFocus, self.tconfig, self.uitRunner) def currentTime(self): return time.strftime('_%Y-%m-%d_%H_%M_%S', time.localtime(time.time())) def get_ocr_list(self, level, option): # OCR识别参数字典 默认值为：百度中英文免费类型 ini_path = os.path.join(getMenuTree3SelectedProjectCfgPath(), "menutree.ini") if os.path.exists(ini_path) is True: tconfig = self.uitRunner.uitData.tConfig # if tconfig.has_option(level, parent + u'.ocr'): # self.ocrDict = tconfig.get_dict(tconfig.get_value(level, parent + u'.ocr')) # return result, path = self.uitRunner.uitData.UITree.get_option(option) print u"get_ocr_list, path:",path if result: # 从当前层逐层往上遍历，寻找ocr参数列表 for i in range(g_level.index(level), -1, -1): cur_parent = path['parent'] first_parent = path['first_parent'] i_level = g_level[i] if tconfig.has_option(i_level, option + u'.ocr'): self.ocrDict = tconfig.get_dict(tconfig.get_value(i_level, option + u'.ocr')) printLog("TMenu.get_ocr_list:", "Get ocr list by: %s.ocr"%option) break elif tconfig.has_option(i_level, cur_parent + u'.ocr'): self.ocrDict = tconfig.get_dict(tconfig.get_value(i_level, cur_parent + u'.ocr')) printLog("TMenu.get_ocr_list:", "Get ocr list by: %s.ocr"%cur_parent) break elif tconfig.has_option(i_level, first_parent + u'.ocr'): self.ocrDict = tconfig.get_dict(tconfig.get_value(i_level, first_parent + u'.ocr')) printLog("TMenu.get_ocr_list:", "Get ocr list by: %s.ocr"%first_parent) break else: # 如果没有，使用默认; self.ocrDict = [{"lan": "ChinesePRC+English", "type": 4}, {"lan": "ChinesePRC+English", "type": 253}, {"lan": "ChinesePRC+English", "type": 10001}] printLog("TMenu.get_ocr_list:", "Get ocr list fail!!!Using default list!!!") printLog("TMenu.get_ocr_list:", "Present ocr list:%s"%self.ocrDict) # 截图并返回当前截图路径 def getCurrentUIPath(self): current_uiPic = os.path.join(getSATTmpDIR(), "menutree_runpath.png") self.ccard.takePicture(current_uiPic) return current_uiPic def getFocusTextBox(self, level, root, focus_box): # 读取ini文件，判断是否有文字方向; if self.tconfig.has_option(level, root + u".text.dir") is True: dict_text = self.tconfig.get_dict(self.tconfig.get_value(level, root + u".text.dir")) # 四个方向的起点坐标计算; left, top, right, bottom = 0, 0, 0, 0 if dict_text["dir"] == u"up": left = focus_box[0] + dict_text["x-offset"] bottom = focus_box[1] + dict_text["y-offset"] top = bottom - dict_text["height"] right = left + dict_text["width"] elif dict_text["dir"] == u"down": left = focus_box[0] + dict_text["x-offset"] top = focus_box[3] + dict_text["y-offset"] right = left + dict_text["width"] bottom = top + dict_text["height"] elif dict_text["dir"] == u"left": top = focus_box[1] + dict_text["y-offset"] right = focus_box[0] + dict_text["x-offset"] left = right - dict_text["width"] bottom = top + dict_text["height"] elif dict_text["dir"] == u"right": left = focus_box[2] + dict_text["x-offset"] top = focus_box[1] + dict_text["y-offset"] right = left + dict_text["width"] bottom = top + dict_text["height"] # 返回文本坐标; return [left, top, right, bottom] # endif # 如果没有字段原样返回; return focus_box def getFocusTextBox3(self, cur_option, focus_box, is_value_sheet=False): resutl, opcfg = self.tFocus.getOptionConfig(cur_option, is_value_sheet) dcfg = opcfg['dcfg'] icon_path = opcfg['icon_path'] icon_dir_path = opcfg['dir_path'] if resutl is False or os.path.exists(icon_dir_path) is False: print u'getFocusTextBox:current use dir_path=%s is null' % ( icon_dir_path) return focus_box if icon_dir_path in self.got_dict: x, y = focus_box[0] - self.got_dict[icon_dir_path]['ref_box'][0], focus_box[1] - \ self.got_dict[icon_dir_path]['ref_box'][1] return [x, y, x + self.got_dict[icon_dir_path]['width'], y + self.got_dict[icon_dir_path]['height']] else: if os.path.exists(icon_dir_path) is True: # 读取例图,宽高; img = cv.imread(icon_dir_path) # 在例图中查找轮廓; result, box = self.tFocus.findRectByIcon2(icon_dir_path, cur_option, is_value_sheet) if result is True: self.got_dict[icon_dir_path] = {"ref_box": box, "width": img.shape[1], "height": img.shape[0]} x, y = focus_box[0] - box[0], focus_box[1] - box[1] return [x, y, x + img.shape[1], y + img.shape[0]] # endif # endif # 如果没有字段原样返回; return focus_box def getFocusTextBox4(self, icon_dir_path, cur_option, focus_box, is_value_sheet=False): if os.path.exists(icon_dir_path) is False: print u'getFocusTextBox:current use dir_path=%s is null' % ( icon_dir_path) return focus_box if icon_dir_path in self.got_dict: x, y = focus_box[0] - self.got_dict[icon_dir_path]['ref_box'][0], focus_box[1] - \ self.got_dict[icon_dir_path]['ref_box'][1] return [x, y, x + self.got_dict[icon_dir_path]['width'], y + self.got_dict[icon_dir_path]['height']] else: if os.path.exists(icon_dir_path) is True: # 读取例图,宽高; img = cv.imread(icon_dir_path) # 在例图中查找轮廓; result, box = self.tFocus.findRectByIcon2(icon_dir_path, cur_option, is_value_sheet) if result is True: self.got_dict[icon_dir_path] = {"ref_box": box, "width": img.shape[1], "height": img.shape[0]} x, y = focus_box[0] - box[0], focus_box[1] - box[1] return [x, y, x + img.shape[1], y + img.shape[0]] # endif # endif # 如果没有字段原样返回; return focus_box # 获取焦点框文本; def getFocusText(self, level, first_parent, paths, src_pic, focus_box, is_for_value=False): # 是否有文字方向字段存在在ini里,如果有则转换文本框坐标; text_pic = os.path.join(getSATTmpDIR(), "meuttree_area_text.png") contourRect = self.getFocusTextBox3(paths['option'], focus_box, is_for_value) self.imgCMP.saveCropPic(src_pic, text_pic, (contourRect[0], contourRect[1], contourRect[2], contourRect[3])) # 获取ocr_list; cur_parent, cur_option = paths['parent'], paths['option'] ocr_list = self.uitRunner.uitData.UITree.get_ocr_list(level, cur_parent, cur_option, True if cur_parent == cur_option else False) print u"%s,%s,%s =>ocr_list=%s" % (level, cur_parent, cur_option, str(ocr_list)) # 遍历ocr类型; found = False ocr_str = '' # 获取ocr列表; self.get_ocr_list(level, cur_option) for item in self.ocrDict: # 识别ocr; thresholdDict = self.tconfig.getThresholdDict(first_parent) ocr_str = self.ocr.getStrWithImgProcess(text_pic, thresholdDict, item["lan"], item["type"], reconTimes=1) printLog(u"OCR识别的类型字典:%s" % str(item)) printLog(u"OCR识别出的ocr_str为：%s" % str(ocr_str)) # print(u"getCurrentFocusTextEx.ocr_str land = %s, type =%d, ocr_str=%s:"%(item["lan"], item["type"], ocr_str.encode('GB18030'))) ocr_str = unicode(ocr_str).lower() if is_for_value: parent_ocr_dict = self.uitRunner.uitData.UITree.get_parent_ocr_dict(cur_parent, value_sheet=True) else: parent_ocr_dict = self.uitRunner.uitData.UITree.get_parent_ocr_dict(cur_option) print u"getCurrentFocusTextEx.parent_ocr_dict:", parent_ocr_dict list_parent_ocr_value = list(parent_ocr_dict.keys()) print u"getCurrentFocusTextEx.list_parent_ocr_value:", list_parent_ocr_value current_parent_ocr_value = "" for parent_ocr_value in list_parent_ocr_value: parent_ocr_value = str(parent_ocr_value).lower() if parent_ocr_value in ocr_str or parent_ocr_value == ocr_str: current_parent_ocr_value = parent_ocr_value break try: curentOption = parent_ocr_dict[current_parent_ocr_value] except Exception, e: curentOption = "" printLog(u"OCR识别出的current_parent_ocr_value为：%s" % str(current_parent_ocr_value)) printLog(u"OCR识别出的curentOCROption为：%s" % str(curentOption)) # printLog(u"传入的目标option为：%s" % str(option)) # 通过OCR来反向识别判断当前识别的option是否为传入的option if str(curentOption).lower() != "" and str(curentOption).lower() != str(cur_option).lower(): # print "非焦点框=%s" % (ocr_str) printLog(u"非焦点框=%s" % str(ocr_str)) return 0, ocr_str # 再遍历目标焦点ocr; for std_str in paths["option_for_ocr"]: std_str = str(std_str).lower() # print 'std_str:', std_str, type(std_str) # print 'ocr_str:', ocr_str, type(ocr_str) if std_str in ocr_str or std_str == ocr_str: found = True break # endfor if found is True: break # endfor return found, ocr_str # 获取焦点框轮廓; def getFocusBox_temp(self, level, first_parent, option=''): # 焦点框截图; bx_pic = '' # 当前截图; cur_img = self.getCurrentUIPath() # 查找焦点框轮廓; bx_found, bx_focus = self.tFocus.findRectByIcon(cur_img, level, first_parent, option) printLog("getCurrentFocusBox(%d,%s):" % (int(bx_found), str(bx_focus))) if bx_found is True: # 保存焦点框截图; bx_pic = os.path.join(getSATTmpDIR(), "menutree_focus_area" + str(time.time()) + ".png") self.imgCMP.saveCropPic(cur_img, bx_pic, (bx_focus[0], bx_focus[1], bx_focus[2], bx_focus[3])) # 返回结果; return bx_found, bx_focus, bx_pic # 获取焦点框滚动文本; def getMarqueeText(self, level, first_parent, option=''): # 获取焦点框信息; bx_found, bx_focus, bx_pic = self.getFocusBox_temp(level, first_parent, option) if bx_found is False: printLog("getMarqueeText=>焦点框识别失败") return False, '' # 按要求,跑马灯只需要百度高精度; orc_type = {"lan": "ChinesePRC+English", "type": 253} # ocr识别; thresholdDict = self.tconfig.getThresholdDict(first_parent) # ocr_result = self.ocr.getStr(bx_pic, orc_type["lan"], orc_type["type"]) ocr_result = self.ocr.getStrWithImgProcess(bx_pic, thresholdDict, orc_type["lan"], orc_type["type"], reconTimes=1) if ocr_result == "ERR" or ocr_result.__len__() == 0: printLog("getMarqueeText=>ocr识别失败=%s" % (ocr_result)) return False, ocr_result # 返回结果; return True, ocr_result def getOCRStrListByOptionList(self, optionList): OCRStrList = [] for option in optionList: hasOption, optionDict = self.uitRunner.uitData.UITree.get_option(option) if hasOption: optionStrList = optionDict["option_ocr"] OCRStrList.extend(optionStrList) return OCRStrList def getOCRStrDictByOptionList(self, optionList): OCRStrDict = {} for option in optionList: hasOption, optionDict = self.uitRunner.uitData.UITree.get_option(option) if hasOption: optionStrList = optionDict["option_ocr"] OCRStrDict[option] = optionStrList return OCRStrDict def getFocusBoxMarqueeText(self, marquee_dict, level, first_parent, paths): # 截图2次,判断是否是跑马菜单; # 第一次; bx_found, bx_focus, bx_pic1 = self.getFocusBox_temp(level, first_parent, paths['option']) if bx_found is False: printLog("getFocusBoxMarqueeText:焦点框识别失败1") return -1, '' # 等待1秒后截图; time.sleep(marquee_dict['sleep_time']) # 发送鲜活键; self.redRat3.sendKey(marquee_dict['alive_key'], 1, 0.1) # 第二次; bx_found, bx_focus, bx_pic2 = self.getFocusBox_temp(level, first_parent, paths['option']) if bx_found is False: printLog("getFocusBoxMarqueeText:焦点框识别失败2") return -1, '' # 二图ocr文本是否相似，如果相似认为不是滚动文本;#如果网络问题; thresholdDict = self.tconfig.getThresholdDict(first_parent) # ocr_result_text1 = self.ocr.getStr(bx_pic1, "ChinesePRC+English", 253) ocr_result_text1 = self.ocr.getStrWithImgProcess(bx_pic1, thresholdDict, "CHN_ENG", 10000, reconTimes=1) # 发送鲜活键; self.redRat3.sendKey(marquee_dict['alive_key'], 1, 0.1) # ocr_result_text2 = self.ocr.getStr(bx_pic2, "ChinesePRC+English", 253) ocr_result_text2 = self.ocr.getStrWithImgProcess(bx_pic2, thresholdDict, "CHN_ENG", 10000, reconTimes=1) # 发送鲜活键; self.redRat3.sendKey(marquee_dict['alive_key'], 1, 0.1) # 对比结果：相等非滚动文本,否则视为滚动文本; if ocr_result_text1 != "" and ocr_result_text1 == ocr_result_text2: return self.getCurrentFocusTextEx(level, first_parent, paths['parent'], paths['option'], paths['option_for_ocr']) else: destOption = paths['option'] menuList = marquee_dict["menu"] # 如果只有一项跑马灯，且目标option亦在跑马灯列表中，则直接返回成功结果 if menuList.__len__() == 1 and (destOption in menuList): return 1, destOption list_img = [] result = False ocr_result_text = '' ocr_text_list = [] # 截图5次; for i in range(0, 5): bx_found, bx_focus, bx_pic = self.getFocusBox_temp(level, first_parent, paths['option']) if bx_found is True: list_img.append(bx_pic) # 间隔多久截图; time.sleep(marquee_dict['sleep_time']) # 发送鲜活键; self.redRat3.sendKey(marquee_dict['alive_key'], 1, 0.1) # endfor # 遍历文本list_img; # 按要求,跑马灯只用百度识别; orc_type = {"lan": "ChinesePRC+English", "type": 10000} for bx_pic in list_img: # ocr识别; # ocr_result_text = self.ocr.getStr(bx_pic, orc_type["lan"], orc_type["type"]) ocr_result_text = self.ocr.getStrWithImgProcess(bx_pic, thresholdDict, orc_type["lan"], orc_type["type"], reconTimes=1) # 识别一次，发送一次鲜活键; self.redRat3.sendKey(marquee_dict['alive_key'], 1, 0.1) if ocr_result_text == "ERR" and ocr_result_text.__len__() == 0: return 0, ocr_result_text ocr_text_list.append(ocr_result_text) #end for # 处理识别到的ocr列表：有部分聚焦状态会将option及其值一起包括其中，所以要把相同的部分（option或者值）去掉 ocr_text_list = self.removeDuplicateString(ocr_text_list) # 获取到跑马灯option的ocr字典 ocrStrDict = self.getOCRStrDictByOptionList(menuList) print u"获取到的跑马灯Option对应的ocr字典ocrStrDict:", ocrStrDict print u"识别到的跑马灯ocr文字列表ocr_text_list：",ocr_text_list for marquee_option in ocrStrDict: option_ocr_list = ocrStrDict[marquee_option] for option_ocr in option_ocr_list: # 一共5张截图，只要有3张满足条件，就算找到了该option（规避同时存在两条相似的跑马灯选项问题，以及跑马灯头尾同时显示的问题） count = 0 for ocr_text in ocr_text_list: if ocr_text.lower() in option_ocr: count += 1 if count >= 3 and destOption == marquee_option: return 1, destOption elif count >= 3: printLog(u"当前聚焦的跑马灯Option实际为：%s"%marquee_option) return 0, marquee_option else: printLog(u"未能识别到当前聚焦的跑马灯Option！！！") return 0, "unknown marquee text" def strSplit(self, str): ret = [] str_int = '' str_ch = '' ch_last = ' ' for ch in str: if ord(ch) > 47 and ord(ch) < 58: str_int += ch if str_ch.__len__(): ret.append(str_ch) str_ch = '' else: if ord(ch_last) > 47 and ord(ch_last) < 58 and ch == '.': str_int += ch if str_ch.__len__(): ret.append(str_ch) str_ch = '' else: str_ch += ch if str_int.__len__(): ret.append(str_int) str_int = '' ch_last = ch if str_ch.__len__(): ret.append(str_ch) if str_int.__len__(): ret.append(str_int) return ret def getCurrentFocusOcr_Int(self, icon_level, first_parent, option="", isForValue=False): print u"getCurrentFocusOcr_Int Start>>>", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) # 聚集框识别; cur_img = self.getCurrentUIPath() print u"isForValue:", isForValue if isForValue: bxfound, cur_box = self.tFocus.findRectByIcon2(cur_img, option, True) else: bxfound, cur_box = self.tFocus.findRectByIcon2(cur_img, option) # print "getCurrentFocusBox(%d,%s):" % (int(bxfound), str(cur_box)) printLog("getCurrentFocusBox(%d,%s):" % (int(bxfound), str(cur_box))) if not bxfound or cur_box == []: return False, "", 0 cur_box = self.getFocusTextBox3(option, cur_box, True) printLog("getCurrentFocusBox(%d,%s):" % (int(bxfound), str(cur_box))) # 截图文本框; txt_pic = os.path.join(getSATTmpDIR(), "meuttree_area_text.png") self.imgCMP.saveCropPic(cur_img, txt_pic, (cur_box[0], cur_box[1], cur_box[2], cur_box[3])) # ocr识别; ocr_result = '' # 获取ocr列表; hasOption, path = self.uitRunner.uitData.UITree.get_option(option) if hasOption: self.get_ocr_list(path['level'], option) for orc_item in self.ocrDict: thresholdDict = self.tconfig.getThresholdDict(first_parent) # ocr_result = self.ocr.getStr(txt_pic, orc_item["lan"], orc_item["type"]) ocr_result = self.ocr.getStrWithImgProcess(txt_pic, thresholdDict, orc_item["lan"], orc_item["type"], reconTimes=1) # print("getCurrentFocusOcr_Int=ocr识别结果=%s" % (ocr_result)) printLog("getCurrentFocusOcr_Int=ocr识别结果=%s" % (ocr_result)) if ocr_result == "ERR" or ocr_result.__len__() == 0: continue # 字符串去掉末尾">"符号; ocr_result = ocr_result.strip('>') # 按数字分解多组文本; # list_orc = getDigitFromString(ocr_result) list_ocr = self.strSplit(ocr_result) # 只判断最后一位是否是数字; if list_ocr.__len__() < 1: errorPngName = "menutree_error_" + self.currentTime() + "ocr.png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) # print u"当前识别的ocr 不包含int类型值，截图为：%s" % (str(ocr_result)) printLog(u"当前识别的ocr 不包含int类型值，截图为：%s" % (str(ocr_result))) continue try: # 获取最右边的文本，如果是数字则退出; text_int_str = list_ocr[list_ocr.__len__() - 1] # print 'text_int_str:', text_int_str printLog('text_int_str:%s' % str(text_int_str)) text_num = float(text_int_str) # 返回结果; return True, ocr_result, text_num except Exception: continue # endfor print u"getCurrentFocusOcr_Int End<<<", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) return False, "", 0 # 遍历获取ocr结果; def getCurrentFocusTextEx(self, level, first_parent, cur_parent, option, list_str, isSource=False, isForValue=False): print level, first_parent, cur_parent, option current_uiPic = self.getCurrentUIPath() if isForValue: # cur_parent 对应value表里的option; # option_info = self.xlsparser.get_option(cur_parent) isFind, contourRect = self.tFocus.findRectByIcon2(current_uiPic, cur_parent, isForValue) else: isFind, contourRect = self.tFocus.findRectByIcon2(current_uiPic, option) printLog(u"获取当前聚焦效果isFind:%s 聚焦区域contourRect:%s" % (str(isFind), str(contourRect))) if not isFind or contourRect == []: return -1, "" else: found, ocr_str = False, '' # tmpPic = os.path.join(getSATTmpDIR(), "meuttree_area_text11.png") # self.imgCMP.saveCropPic(current_uiPic, tmpPic, # (contourRect[0], contourRect[1], contourRect[2], contourRect[3])) # 是否有文字方向字段存在在ini里,如果有则转换文本框坐标; tmpPic = os.path.join(getSATTmpDIR(), "meuttree_area_text.png") if isForValue: contourRect = self.getFocusTextBox3(cur_parent, contourRect, True) else: contourRect = self.getFocusTextBox3(option, contourRect) self.imgCMP.saveCropPic(current_uiPic, tmpPic, (contourRect[0], contourRect[1], contourRect[2], contourRect[3])) if isSource: self.redRat3.sendKey("ok") # print "self.ocrDict:", self.ocrDict # 获取ocr_list; ocr_list = self.uitRunner.uitData.UITree.get_ocr_list(level, cur_parent, option, True if cur_parent == option else False) print u"%s,%s,%s =>ocr_list=%s" % (level, cur_parent, option, str(ocr_list)) # 获取ocr列表; self.get_ocr_list(level, option) # 遍历ocr类型; for item in self.ocrDict: # 识别ocr; thresholdDict = self.tconfig.getThresholdDict(first_parent) ocr_str = self.ocr.getStrWithImgProcess(tmpPic, thresholdDict, item["lan"], item["type"], reconTimes=1) # print "\n\ngetCurrentFocusTextEx ==========================:OCR-Type=%s, OCR-Text=%s\n\n" % ( # str(item), str(ocr_str)) printLog(u"OCR识别的类型字典:%s" % str(item)) printLog(u"OCR识别出的ocr_str为：%s" % str(ocr_str)) # print(u"getCurrentFocusTextEx.ocr_str land = %s, type =%d, ocr_str=%s:"%(item["lan"], item["type"], ocr_str.encode('GB18030'))) ocr_str = unicode(ocr_str).lower() if isSource is False: if isForValue: parent_ocr_dict = self.uitRunner.uitData.UITree.get_parent_ocr_dict(cur_parent, value_sheet=True) else: parent_ocr_dict = self.uitRunner.uitData.UITree.get_parent_ocr_dict(option) print u"getCurrentFocusTextEx.parent_ocr_dict:", parent_ocr_dict list_parent_ocr_value = list(parent_ocr_dict.keys()) print u"getCurrentFocusTextEx.list_parent_ocr_value:", list_parent_ocr_value # 比较所有的ocr for parent_ocr_value in list_parent_ocr_value: parent_ocr_value = str(parent_ocr_value).lower() if parent_ocr_value in ocr_str or strcmp(parent_ocr_value, ocr_str): # 优先比较目标option，如果符合要求则直接返回找到结果 for std_str in list_str: std_str = str(std_str).lower() if strcmp(std_str, parent_ocr_value): printLog(u"传入的目标Value_ocr_list为：%s" % list_str) printLog(u"与目标option的ocr_value：%s相同"%std_str) return 1, option else: # 否则则识别出该ocr_value所对应的option try: currentOption = parent_ocr_dict[parent_ocr_value] except Exception,e: currentOption = "" printLog(u"识别出的currentOption为：%s" % currentOption) if currentOption != "": return 0, currentOption else: if isSource is True: # 如果是信源 而且识别出是非目标信源则跳出该语言 for ocr_std_str_list in ocr_list: # print "ocr_std_str_list:",ocr_std_str_list for ocr_std_str in ocr_std_str_list: # print "ocr_std_str:",ocr_std_str ocr_std_str = str(ocr_std_str).lower() # print 'ocr_std_str:', ocr_std_str, type(ocr_std_str) # print 'ocr_str:', ocr_str, type(ocr_str) if ocr_std_str in ocr_str or ocr_std_str == ocr_str: printLog(u"非焦点信源=%s" % str(ocr_str)) return 0, ocr_str else: # 全部ocr_value都不符合要求，则视为menutree中不存在此option相关的数据 printLog(u"未能识别出当前Option！！！请检查Mnenutree相关参数配置！！！") return 0, ocr_str # 移动到目标网格焦点上; def move2TargetGridNode(self, level, first_parent, paths, returnKeyEventCount, Max_Try=15): result = False cur_option = paths['option'] last_box, cur_box = [], [] # 遍历正序; is_positive = True key_idx = False key_dir = ['right', 'left'] # 第一个，最后一个; is_first, is_last = False, False # 上一行,下一行; is_up, is_down = False, False # 获取等待时间 waitTime = self.getOptionWaitTime(paths['option']) time.sleep(waitTime) while True: cur_pic = self.getCurrentUIPath() found_box, cur_box = self.tFocus.findRectByIcon2(cur_pic, cur_option) if found_box is True: if last_box == cur_box: if is_positive is True: # 正序; if is_last is True: is_positive = False key_idx = not key_idx last_box = [] # 移动上一格; self.redRat3.sendKey(key_dir[int(key_idx)]) continue if is_down is False: is_down = True # 移动下一行; self.redRat3.sendKey('down') key_idx = not key_idx else: is_last = True key_idx = not key_idx else: # 逆序; if is_first is True: break if is_up is False: is_up = True # 移动上一行; self.redRat3.sendKey('up') key_idx = not key_idx else: is_first = True key_idx = not key_idx # endif else: found_target, cur_text = self.getFocusText(level, first_parent, paths, cur_pic, cur_box) if found_target is True: result = True break # 保留为上一焦点框; last_box = cur_box # 移动下一焦点; self.redRat3.sendKey(key_dir[int(key_idx)]) # 第一个，最后一个; is_first, is_last = False, False # 上一行,下一行; is_up, is_down = False, False # endif else: printLog(u"网格焦点框识别失败") break # endif # 返回结果; return result def move2TargetGridNode_matchTemp(self, level, first_parent, paths, returnKeyEventCount, Max_Try = 15): # 目标结点; tgt_option = paths['option'] temp_dir = os.path.join(getMenuTree3SelectedProjectCfgPath(), "match_temp", paths['parent']) # 选中时的模板 img_focus_temp = os.path.join(temp_dir, tgt_option + '_focus.jpg') # 未选中模板图 img_unfocus_temp = os.path.join(temp_dir, tgt_option + '_unfocus.jpg') # 获取等待时间 waitTime = self.getOptionWaitTime(paths['option']) time.sleep(waitTime) # 尝试次数; page_try_time = 15 focus_try_time = 100 # 目标聚集结果; tgt_focus_result = False while tgt_focus_result is False: # 电视截图(原图); img_tv = self.getCurrentUIPath() # 查找聚集框是否在目标上; match_result = self.tFocus.feature_detect.matchSingleImage(img_tv, None, img_focus_temp) if match_result is not None: tgt_focus_result = True break #end-if # 查找非聚集目标; match_result = self.tFocus.feature_detect.matchSingleImage(img_tv, None, img_unfocus_temp) if match_result is None: # 尝试次数使用完; if page_try_time == 0: break # 没找到，可能在别的页面，向右移动; self.redRat3.sendKey('right') page_try_time = page_try_time - 1 continue # end-if print u'匹配度=', match_result['tmpVal'] # 找到非聚集目标后，再查找当前聚集框坐标; bfound_box, focus_box = self.tFocus.findRectByIcon2(img_tv, tgt_option, is_value_sheet=False) # 不支持叶结点; if bfound_box is False: printLog("move2TargetGridNode_matchTemp：未找到聚集框") break #end-if box1, box2 = focus_box, match_result['coordinate'] # 计算非聚集模板与聚集框的位置; dir = self.tFocus.feature_detect.getOrientationEx(box1, box2) if dir == -1: break # 中心点坐标;center point # cpt1 = [box1[2]-box1[0],box1[3]-box1[1]] # cpt2 = [box2[2]-box2[0],box2[3]-box2[1]] if dir == 0:# 左上方; self.redRat3.sendKey('right') elif dir == 1:# 正上方; self.redRat3.sendKey('down') elif dir == 2:# 右上方; self.redRat3.sendKey('left') elif dir == 3:# 正左方; self.redRat3.sendKey('right') elif dir == 4:# 正右方; self.redRat3.sendKey('left') elif dir == 5:# 左下方; self.redRat3.sendKey('right') elif dir == 6:# 正下方; self.redRat3.sendKey('up') elif dir == 7:# 右下方; self.redRat3.sendKey('left') # 移动次数用完; focus_try_time = focus_try_time -1 if focus_try_time == 0: break #end-while; return tgt_focus_result # 移动到目标节点上; def move2TargetNode(self, level, first_parent, paths, returnKeyEventCount, findDirection="down", Max_Try=15): # 按照传入的方向寻找Max_Try次，如果仍未聚焦到option_for_ocr所在的区域，则按照传入方向的反方向 反向寻找 Max_Try 次 # 正向寻找的次数计数和最大次数 count = 0 parent = paths['parent'] option_list = self.uitRunner.uitData.UITree.getSubOptionList(parent) if option_list.__len__() != 0: Max_Try = option_list.__len__() print u"move2TargetNode.%s option_list:"%parent, option_list # 反向寻找的次数计数和最大次数 Reversecount = 0 Reverse_Max_Try = Max_Try print u"move2TargetNode:Max_Try:%s, Reverse_Max_Try:%s"%(Max_Try, Reverse_Max_Try) if findDirection == "grid": temp_dir = os.path.join(getMenuTree3SelectedProjectCfgPath(), "match_temp", paths['parent']) if os.path.exists(temp_dir): return self.move2TargetGridNode_matchTemp(level, first_parent, paths, returnKeyEventCount, Max_Try) else: return self.move2TargetGridNode(level, first_parent, paths, returnKeyEventCount, Max_Try) # 记录上一个焦点识别的文字内容 用于判断是否到达列表的边界 如果到达边界则反向寻找 old_text = "init_old_text" # 反向寻找的遥控器按键值 findReverseDirection = "up" if findDirection == "up": findReverseDirection = "down" if findDirection == "down": findReverseDirection = "up" if findDirection == "left": findReverseDirection = "right" if findDirection == "right": findReverseDirection = "left" print u"findDirection:", findDirection, type(findDirection) print u"findReverseDirection:", findReverseDirection, type(findReverseDirection) # # 去除大小写的识别字符 # option_for_ocr_low = str(option_for_ocr).lower() isMarquee = False marquee_dict = {} # 是否有跑马灯文本; if paths["others"].__len__(): data_other = json.loads(paths["others"]) if "marquee" in data_other: marquee_dict = data_other['marquee'] isMarquee = True # 获取等待时间 waitTime = self.getOptionWaitTime(paths['option']) printLog(u"move2TargetNode:获取到进入option_%s，等待时间为%s"%(paths['option'],waitTime)) time.sleep(waitTime) while (True): print "count:", count if count >= Max_Try and Reversecount >= Reverse_Max_Try: break if isMarquee is True: isFind, text = self.getFocusBoxMarqueeText(marquee_dict, level, first_parent, paths) else: isFind, text = self.getCurrentFocusTextEx(level, first_parent, paths["parent"], paths["option"], paths["option_for_ocr"]) if isFind == -1: errorPngName = "menutree_error_" + str(paths["option"]) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"聚焦到目标option:%s失败！当前界面无法找到焦点区域！！！出错界面截图%s" % (str(paths["option"]), str(error_uiPic))) self.redRat3.sendKey("return", returnKeyEventCount, 0.5) return False # elif (self.ocr.cmpOcrStr(text, option_for_ocr)): # 由比较目标文本和识别文本 是否相等 改为 识别文本是否包含目标文本 else: if isFind == 1: printLog(u"聚焦到目标option:%s成功！" % str(paths["option"])) return True # 判断两次识别的text是否相等来判断是否到达边界 print u"move2TargetNode.text",text print u"move2TargetNode.old_text",old_text if self.ocr.cmpOcrStr(text, old_text): # 如果已经到达边界则不再正方向寻找焦点 count = Max_Try old_text = "init_old_text" else: old_text = text if count < Max_Try: count = count + 1 self.redRat3.sendKey(findDirection) else: Reversecount = Reversecount + 1 self.redRat3.sendKey(findReverseDirection) errorPngName = "menutree_error_" + str(paths["option"]) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"聚焦到目标option:%s失败！正向遍历%s次，和反向遍历%s次都没有聚焦到option：%s中,截图路径:%s" % (str(paths["option"]), str(Max_Try), str(Reverse_Max_Try), str(paths["option"]), str(error_uiPic))) return False # 设置叶子节点值; def setLeafNodeValue(self, level, first_parent, option, value_excel, value_for_ocr, value, move_key, enter_key, Max_Try=15): # 按照传入的方向寻找Max_Try次，如果仍未聚焦到option_for_ocr所在的区域，则按照传入方向的反方向 反向寻找 2*Max_Try 次 # 正向寻找的次数计数和最大次数 count = 0 Max_Try = Max_Try # 反向寻找的次数计数和最大次数 Reversecount = 0 Reverse_Max_Try = Max_Try * 2 # 记录上一个焦点识别的文字内容 用于判断是否到达列表的边界 如果到达边界则反向寻找 old_text = "init_old_text" # 正向寻找的遥控器按键值 findDirection = move_key[1] # 向右或者向下 # 反向寻找的遥控器按键值 findReverseDirection = move_key[0] # 向左或者向上 # 获取等待时间 waitTime = self.getLeafWaitTime(option) printLog(u"setLeafNodeValue:获取到进入叶节点%s，等待时间为%s"%(option, waitTime)) time.sleep(waitTime) duration = 0.2 isMarquee = False marquee_dict = {} leaf_data = self.uitRunner.uitData.UITree.get_value(option) if leaf_data["others"].__len__(): data_other = json.loads(leaf_data["others"]) # 是否有跑马灯文本; if "marquee" in data_other: marquee_dict = data_other['marquee'] isMarquee = True # 是否有按键时间设置 if "duration" in data_other: duration = float(data_other['duration']) printLog(u"读取到的设值间隔为%s"%duration) value_for_ocr_low = str(value_for_ocr[0]).lower() # 判断设置值的类型 是rang类型还是str类型 if "range(" in value_for_ocr_low: isRangeType = True str_num = value_for_ocr_low.replace("range", "") list_num = eval(str_num) min_num = list_num[0] max_num = list_num[1] try: value_num = int(value) except Exception: printLog(u"传入的值value:%s和option:%s对应的类型不匹配 ！" % (str(value), str(option))) return False else: isRangeType = False if isRangeType: # 设置数值范围类型的处理 pass while (True): # 执行超过3次操作仍然失败则返回False if count > 3: break isFind, text, text_num = self.getCurrentFocusOcr_Int(level, first_parent, option=option, isForValue=True) if not isFind: errorPngName = "menutree_error_" + str(option) + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"设置叶子节点值时，当前界面无法找到焦点区域！！！getCurrentFocusOcr_Int出错界面截图%s" % str(error_uiPic)) return False else: if text_num < min_num or text_num > max_num: errorPngName = "menutree_error_" + str(option) + '_' + str( value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"设置叶子节点值时，当前option:%s 识别出来的值text:%s 不在value_for_ocr：%s范围内，截图为：%s" % ( str(option), str(text), str(value_for_ocr), str(error_uiPic))) return False # if abs(text_num) == abs(value_num): if text_num == value_num: printLog(u"聚焦到目标option:%s,设置value:%s选项成功！" % (str(option), str(value_excel))) # 聚焦成功发送enter_key if enter_key != 'default': self.redRat3.sendKey(enter_key) return True else: if findDirection == 'input': # 发送按键; for key in list(str(value_num)): self.redRat3.sendKey(key, 1, duration) if max_num > 100: return True else: count = count + 1 # 如果目标值大于现有值，则按正方向按键（向下或者向右）增加当前界面的值 if value_num > text_num: self.redRat3.sendKey(findDirection, value_num - text_num, duration) # 如果目标值小于现有值，则按反方向按键（向上或者向左）减少当前界面的值 if value_num < text_num: self.redRat3.sendKey(findReverseDirection, text_num - value_num, duration) errorPngName = "menutree_error_" + str(option) + '_' + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"设置叶子节点值时，当前option:%s 设置3次仍未设置到目标值value:%s,截图为：%s " % (str(option), str(value), str(error_uiPic))) return False else: # 设置选项类型的处理 while (True): print "count:", count if count >= Max_Try and Reversecount >= Reverse_Max_Try: break if isMarquee is True: # 跑马灯函数需要cur_parent的参数，把cur_parent参数加入到leaf_data中再传进去 result, paths = self.uitRunner.uitData.UITree.get_option(option) leaf_data['parent'] = paths['parent'] leaf_data['option_for_ocr'] = leaf_data['value_for_ocr'] isFind, text = self.getFocusBoxMarqueeText(marquee_dict, level, first_parent, leaf_data) else: isFind, text = self.getCurrentFocusTextEx(level, first_parent, option, value_excel, value_for_ocr, isForValue=True) if isFind == -1: errorPngName = "menutree_error_" + str(option) + '_' + str( value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"设置叶子节点值时，当前界面无法找到焦点区域！！！getCurrentFocusTextEx 出错界面截图%s" % str(error_uiPic)) return False # elif (self.ocr.cmpOcrStr(text, value_for_ocr)): # 由比较目标文本和识别文本 是否相等 改为 识别文本是否包含目标文本 else: if isFind == 1: printLog(u"聚焦到目标option:%s，设置value:%s选项成功！" % (str(option), str(value_excel))) # 聚焦成功发送enter_key if enter_key != 'default': self.redRat3.sendKey(enter_key) return True # 判断两次识别 # 判断两次识别的text是否相等来判断是否到达边界 if self.ocr.cmpOcrStr(text, old_text): # 如果已经到达边界则不再正方向寻找焦点 count = Max_Try old_text = "init_old_text" else: old_text = text if count < Max_Try: count = count + 1 self.redRat3.sendKey(findDirection) else: Reversecount = Reversecount + 1 self.redRat3.sendKey(findReverseDirection) errorPngName = "menutree_error_" + str(option) + '_' + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"设置叶子节点值时，正向遍历%s次，和反向遍历%s次都没有聚焦到option：%s的value:%s选项中,截图为%s" % ( str(Max_Try), str(Reverse_Max_Try), str(option), str(value_excel), str(error_uiPic))) return False return True # 处理others字段; def dealOthers(self, level, path): others = json.loads(path['others']) if "password" in others: password = self.tconfig.get_value("Password", others["password"]) # 发送密码前,停2秒(因为像6586机芯响应很慢,密码框还没弹出就完成了密码输入的操作); time.sleep(2) # 发送按键; for key in list(password): self.redRat3.sendKey(key, 1, 0.2) time.sleep(1) # 发送ok键; if others["enter_key"] != "default": self.redRat3.sendKey(others["enter_key"]) # 判断是否成功输入密码; current_uiPic = self.getCurrentUIPath() # 此处findRectByIcon参数3传递的不是first_parent,而是当前option的parent; isFind, contourRect = self.tFocus.findRectByIcon(current_uiPic, level, path['parent']) return not isFind return False # 由于测试开始之前都切到黑屏背景，去掉聚焦效果OCR验证，3次焦点验证，验证到有聚焦效果就返回 def isFirstOptionShow(self, level, first_parent, first_option): for i in range(3): current_uiPic = self.getCurrentUIPath() isFind, contourRect = self.tFocus.findRectByIcon2(current_uiPic, first_option) if isFind: return True return False # 对外接口：设置操作值; def setOptionValue(self, option, value, Max_Try=15, reTryTime=0, leafNodeValueWaitTime=0.0, returnKeyEventTimes=-1): # 切黑场; self.sourceInput.setPattern(11) printLog(u"开始执行setOptionValue。option:%s value:%s" % (str(option), str(value))) # 寻路结果; result = False # 获取menu path; value_params, path_params = self.uitPathManage.get_menu_paths(option, value) printLog(u"获取到达option:%s的路径字典path_params:%s" % (str(option), str(path_params))) printLog(u"获取设置value:%s的值字典value_params:%s" % (str(value), str(value_params))) checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params) if str(checkRunOptionPathResult) == "NoExit": printLog(u"表格中不存在到达Option: %s 的路径,在表格中排查到达该Option路径" % str(option)) return False if str(checkRunOptionPathResult) == "Fail": printLog(u"表格中到达Option: %s 的路径出现数据断层找不到First层级,在表格中排查到达该Option路径" % str(option)) return False # returnKeyEventCount = path_params.__len__() + 1 returnKeyEventCount = 0 print u"returnKeyEventCount:", returnKeyEventCount # 逆序路径key; revpp = reversed(path_params) # 根节点是否已进入; entry = False first_parent = u'' first_option = u'' # 遍历路径(已排序，从first开始); # print "revpp:", revpp for level in revpp: # print "level:", level, path_params[level] printLog(u"执行路径level:%s 对应路径字典:%s" % (str(level), str(path_params[level]))) # 是否进入根结点; if entry == False: # 标记已进入根; entry = True first_parent = path_params[level]["parent"] first_option = path_params[level]["option"] checkFirstOptionTimes = 0 while True: if checkFirstOptionTimes > 2: errorPngName = "menutree_error_" + str(option) + '_' + str(value) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"执行setOptionValue ERROR!option:%s value:%s ;尝试3次快捷按键仍然没有唤出聚焦焦点界面!!! 出错截图:%s" % ( str(option), str(value), str(error_uiPic))) return False printLog(u"第%s次尝试呼出一级界面" % str(checkFirstOptionTimes)) # 判断是否存在others字段，others字段中存在first_key，则优先使用first_key进入 try: others = json.loads(path_params[level]["others"]) except Exception,e: others = {} printLog("section others:%s"%others) if "first_key" in others.keys(): first_key = others["first_key"] else: first_key = path_params[level]["parent"] printLog(u"进入根节点，first_key:%s"%first_key) # 进入根节点 self.redRat3.sendKey(first_key) waitTime = self.getParentWaitTime(path_params[level]["parent"]) printLog(u"打开%s界面的等待时间waittime为：%s" % (str(path_params[level]["parent"]), str(waitTime))) time.sleep(waitTime) # 获取ocr列表; self.get_ocr_list(level, option) if self.isFirstOptionShow(level, first_parent, first_option): printLog(u"呼出一级菜单界面") break else: time.sleep(5) self.redRat3.sendKey("return", 1) checkFirstOptionTimes = checkFirstOptionTimes + 1 # 如果一级界面弹出成功，则退出时候返回按键次数加1 returnKeyEventCount = returnKeyEventCount + 1 print u"level:", level, "first_parent:", first_parent # 如果 others 字段不为空; if path_params[level]["others"].__len__(): # 如果不是跑马灯处理则按照输入密码处理 if self.dealOthers(level, path_params[level]) is True: # print u"解锁失败!!!" printLog(u"执行setOptionValue ERROR!option:%s value:%s ;解锁失败!!!" % (str(option), str(value))) return False cur_option_enter_key = path_params[level]["option_enter_key"] # 移动到子节点; if cur_option_enter_key.__len__() == 0: enter_key = path_params[level]["enter_key"] else: enter_key = cur_option_enter_key move_key = path_params[level]["move_key"] if str(move_key) == str([u'up', u'down']) or str(move_key) == str([u'down', u'up']): findDirection = str(move_key[1]) elif str(move_key) == str([u'left', u'right']) or str(move_key) == str([u'right', u'left']): findDirection = str(move_key[1]) else: findDirection = 'grid' result = self.move2TargetNode( level, first_parent, path_params[level], returnKeyEventCount, findDirection=findDirection, Max_Try=Max_Try) if result is True: # 子节点的进入方式默认为ok; if enter_key != u'default': self.redRat3.sendKey(enter_key) # 如果执行一次enter_key，则退出时按返回键的次数加一 returnKeyEventCount = returnKeyEventCount + 1 else: break # end-for # 寻路成功，设置叶节点值; if result is True: # 如果是信源选择 自动选择不需要执行 enter_key if self.ocr.cmpOcrStr(option, 'source'): return True time.sleep(leafNodeValueWaitTime) print u"执行设置叶节点：", value_params result = self.setLeafNodeValue( level, first_parent, value_params["option"], value_params["value"], value_params["value_for_ocr"], value, value_params["move_key"], value_params["enter_key"], Max_Try=Max_Try) # else: if returnKeyEventTimes == -1: print u"执行退出，执行退出按键次数returnKeyEventCount：", returnKeyEventCount # 无论成功失败，要返回到初始界面 self.redRat3.sendKey("return", returnKeyEventCount, 0.2) time.sleep(1) # 检测执行回退键是否成功，吐过仍有聚焦效果则继续执行return键 reCount = 0 while True: if reCount >= returnKeyEventCount: printLog(u"执行了returnKeyEventCount:%s次,仍无法退出到初始界面" % str(returnKeyEventCount)) break # isFind, text = self.getCurrentFocusText("First", first_parent) # if isFind: if self.isFirstOptionShow("First", first_parent, first_option): print u"还没有退到初始界面" reCount = reCount + 1 # 如果仍然可以检测到聚焦效果，则继续执行return self.redRat3.sendKey("return") else: printLog(u"回退到初始界面成功！") break else: print u"执行退出，执行退出按键次数returnKeyEventTimes：", returnKeyEventTimes # 无论成功失败，要返回到初始界面 self.redRat3.sendKey("return", returnKeyEventTimes, 0.2) if result: printLog(u"设置option:%s 选中value:%s的值成功！" % (str(option), str(value))) else: printLog(u"重新设置option:%s 选中value:%s的值失败！" % (str(option), str(value))) # 不再执行重试动作 # else: # if reTryTime < 1: # reTryTime = reTryTime + 1 # result = self.setOptionValue(option, value, reTryTime=reTryTime) # if result: # printLog(u"重新设置option:%s 选中value:%s的值成功！" % (str(option), str(value))) # return True # else: # printLog(u"重新设置option:%s 选中value:%s的值失败！" % (str(option), str(value))) # return False # else: # printLog(u"设置option:%s 选中value:%s的值尝试2次仍失败！" % (str(option), str(value))) # return False # 返回结果; return result # 对外接口：检测操作值是否正确; def checkOptionValue(self, option, value, Max_Try=15, leafNodeValueWaitTime=0.0): # 切黑场; self.sourceInput.setPattern(11) printLog(u"开始执行checkOptionValue。option:%s value:%s" % (str(option), str(value))) # 寻路结果; result = False # 获取menu path; value_params, path_params = self.uitPathManage.get_menu_paths(option, value) printLog(u"获取到达option:%s的路径字典path_params:%s" % (str(option), str(path_params))) printLog(u"获取检测value:%s的值字典value_params:%s" % (str(value), str(value_params))) checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params) if str(checkRunOptionPathResult) == "NoExit": printLog(u"表格中不存在到达Option: %s 的路径,在表格中排查到达该Option路径" % str(option)) return False if str(checkRunOptionPathResult) == "Fail": printLog(u"表格中到达Option: %s 的路径出现数据断层找不到First层级,在表格中排查到达该Option路径" % str(option)) return False # returnKeyEventCount = path_params.__len__() + 1 returnKeyEventCount = 0 print "returnKeyEventCount:", returnKeyEventCount # 逆序路径key; revpp = reversed(path_params) # 根节点是否已进入; entry = False root = u'' first_parent = u'' first_option = u'' # 遍历路径(已排序，从first开始); # print "revpp:", revpp for level in revpp: # print "level:", level, path_params[level] printLog(u"执行路径level:%s 对应路径字典:%s" % (str(level), str(path_params[level]))) # 是否进入根结点; if entry == False: # 标记已进入根; entry = True first_parent = path_params[level]["parent"] first_option = path_params[level]["option"] checkFirstOptionTimes = 0 while True: if checkFirstOptionTimes > 2: errorPngName = "menutree_error_" + str(option) + '_' + str(value) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"执行checkOptionValue ERROR!option:%s value:%s ;尝试3次快捷按键仍然没有唤出聚焦焦点界面!!! 出错截图:%s" % ( str(option), str(value), str(error_uiPic))) return False printLog(u"第%s次尝试呼出一级界面" % str(checkFirstOptionTimes)) # # 进入根节点(根节点名就是遥控键名); # self.redRat3.sendKey(path_params[level]["parent"]) # 判断是否存在others字段，others字段中存在first_key，则优先使用first_key进入 try: others = json.loads(path_params[level]["others"]) except Exception,e: others = {} printLog("section others:%s"%others) if "first_key" in others.keys(): first_key = others["first_key"] else: first_key = path_params[level]["parent"] printLog(u"进入根节点，first_key:%s"%first_key) # 进入根节点 self.redRat3.sendKey(first_key) waitTime = self.getParentWaitTime(path_params[level]["parent"]) printLog(u"打开%s界面的等待时间waittime为：%s" % (str(path_params[level]["parent"]), str(waitTime))) time.sleep(waitTime) # 获取ocr列表; self.get_ocr_list(level, option) if self.isFirstOptionShow(level, first_parent, first_option): printLog(u"呼出一级菜单界面") break else: time.sleep(5) self.redRat3.sendKey("return", 1) checkFirstOptionTimes = checkFirstOptionTimes + 1 # 如果一级界面弹出成功，则退出时候返回按键次数加1 returnKeyEventCount = returnKeyEventCount + 1 # 如果 others 字段不为空; if path_params[level]["others"].__len__(): # 如果不是跑马灯处理则按照输入密码处理 if self.dealOthers(level, path_params[level]) is True: # print u"解锁失败!!!" printLog(u"执行checkOptionValue ERROR!option:%s value:%s ;解锁失败!!!" % (str(option), str(value))) return False # 移动到子节点; cur_option_enter_key = path_params[level]["option_enter_key"] # 移动到子节点; if cur_option_enter_key.__len__() == 0: enter_key = path_params[level]["enter_key"] else: enter_key = cur_option_enter_key move_key = path_params[level]["move_key"] if str(move_key) == str([u'up', u'down']) or str(move_key) == str([u'down', u'up']): findDirection = str(move_key[1]) elif str(move_key) == str([u'left', u'right']) or str(move_key) == str([u'right', u'left']): findDirection = str(move_key[1]) else: findDirection = 'grid' result = self.move2TargetNode( level, first_parent, path_params[level], returnKeyEventCount, findDirection=findDirection, Max_Try=Max_Try) if result is True: # 子节点的进入方式默认为ok; # self.redRat3.sendKey('ok') # 子节点的进入方式默认为ok; if enter_key != u'default': self.redRat3.sendKey(enter_key) # 如果执行一次enter_key，则退出时按返回键的次数加一 returnKeyEventCount = returnKeyEventCount + 1 else: break # end-for # 寻路成功，设置叶节点值; if result is True: # 如果是信源选择 自动选择不需要执行 enter_key if self.ocr.cmpOcrStr(option, 'source') or self.ocr.cmpOcrStr(option, 'ok'): return True time.sleep(leafNodeValueWaitTime) result = self.checkLeafNodeValue(level, root, value_params["option"], value_params["value"], value_params["value_for_ocr"], value) print u"执行退出，执行退出按键次数returnKeyEventCount：", returnKeyEventCount # 无论成功失败，要返回到初始界面 self.redRat3.sendKey("return", returnKeyEventCount, 0.2) time.sleep(1) # 检测执行回退键是否成功，吐过仍有聚焦效果则继续执行return键 reCount = 0 while True: if reCount >= returnKeyEventCount: printLog(u"执行了returnKeyEventCount:%s次,仍无法退出到初始界面" % str(returnKeyEventCount)) break if self.isFirstOptionShow("First", first_parent, first_option): reCount = reCount + 1 # 如果仍然可以检测到聚焦效果，则继续执行return self.redRat3.sendKey("return") else: printLog(u"回退到初始界面成功！") break if result: printLog(u"检测option:%s 选中value:%s的值成功！" % (str(option), str(value))) else: printLog(u"检测option:%s 选中value:%s的值失败！" % (str(option), str(value))) # 返回结果; return result def checkLeafNodeValue(self, level, parent, option, value_excel, value_for_ocr, value): # 获取等待时间 waitTime = self.getOptionWaitTime(option) printLog(u"checkLeafNodeValue:获取到进入叶节点%s，等待时间为%s"%(option, waitTime)) time.sleep(waitTime) value_for_ocr_low = str(value_for_ocr[0]).lower() # 判断设置值的类型 是rang类型还是str类型 if "range(" in value_for_ocr_low: isRangeType = True str_num = value_for_ocr_low.replace("range", "") list_num = eval(str_num) min_num = list_num[0] max_num = list_num[1] try: value_num = int(value) except Exception: printLog(u"传入的值value:%S和option:%s对应的类型不匹配 ！" % (str(value), str(option))) return False else: isRangeType = False if isRangeType: # 设置数值范围类型的处理 isFind, text, text_num = self.getCurrentFocusOcr_Int(level, parent, option=option, isForValue=True) if not isFind: errorPngName = "menutree_error_" + str(option) + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"检测叶子节点值时，当前界面无法找到焦点区域！！！出错界面截图%s" % str(error_uiPic)) return False else: pass try: list_text_num = getDigitFromString(text) if list_text_num.__len__() < 1: errorPngName = "menutree_error_" + str(option) + '_' + str( value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"检测叶子节点值时，当前option:%s 识别出来的值text:%s 不包含int类型值，截图为：%s" % ( str(option), str(text), str(error_uiPic))) return False text_int_str = list_text_num[list_text_num.__len__() - 1] # print 'text_int_str:', text_int_str text_num = int(text_int_str) printLog(u"检测到的值text_num:%s" % str(text_num)) except Exception: errorPngName = "menutree_error_" + str(option) + '_' + str( value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"检测叶子节点值时，当前option:%s 识别出来的值text:%s 不能转换成value_for_ocr：%s范围内的int类型，截图为：%s" % ( str(option), str(text_int_str), str(value_for_ocr), str(error_uiPic))) return False if text_num < min_num or text_num > max_num: errorPngName = "menutree_error_" + str(option) + '_' + str( value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"检测叶子节点值时，当前option:%s 识别出来的值text:%s 不在value_for_ocr：%s范围内，截图为：%s" % ( str(option), str(text), str(value_for_ocr), str(error_uiPic))) return False # if abs(text_num) == abs(value_num): if text_num == value_num: printLog(u"检测叶子节点值时，聚焦到目标option:%s,检测value:%s选项成功！" % (str(option), str(value_excel))) return True else: return False else: # 设置选项类型的处理 isFind, text = self.getCurrentFocusTextEx(level, parent, option, value_excel, value_for_ocr, isForValue=True) if not isFind: errorPngName = "menutree_error_" + str(option) + '_' + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"检测叶子节点值时，当前界面无法找到焦点区域！！！出错界面截图:%s" % str(error_uiPic)) return False # elif (self.ocr.cmpOcrStr(text, value_for_ocr)): # 由比较目标文本和识别文本 是否相等 改为 识别文本是否包含目标文本 else: for value_for_ocr_text in value_for_ocr: value_for_ocr_text_low = str(value_for_ocr_text).lower() if value_for_ocr_text_low in text: printLog(u"检测叶子节点值时，聚焦到目标option:%s，检测value:%s选项成功！" % (str(option), str(value_excel))) return True errorPngName = "menutree_error_" + str(option) + '_' + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"检测叶子节点值时，聚焦到目标option:%s，检测value:%s选项失败！出错界面截图:%s" % ( str(option), str(value_excel), str(error_uiPic))) return False # 对外接口：信源设置接口;本方法（先识别再切换）NT72项目由于界面消失太快不适用，下面封的接口逻辑（先切换再识别） # def setSourceValue(self, option, value, sourceWaitTime=1.0, Max_Try=10): # printLog(u"开始执行setSourceValue。option:%s value:%s" % (str(option), str(value))) # # self.get_ocr_list('First', 'source') # # 获取menu path; # value_params, path_params = self.xlsparser.get_menu_paths(option, value) # # print "value_params:", value_params # printLog(u"获取设置信源value:%s的值字典value_params:%s" % (str(value), str(value_params))) # value_for_ocr = value_params['value_for_ocr'] # # old_text = "init_old_text" # # enter_key = value_params["enter_key"] # move_key = value_params["move_key"] # if str(move_key) == str([u'up', u'down']): # findDirection = "down" # findReverseDirection = "up" # else: # findDirection = "right" # findReverseDirection = "left" # # 正向寻找的次数计数和最大次数 # count = 0 # Max_Try = Max_Try # # 反向寻找的次数计数和最大次数 # Reversecount = 0 # Reverse_Max_Try = Max_Try * 2 # sourceWaitTime = self.tconfig.get_value("waitTime", "sourceWaitTime") # if not sourceWaitTime: # sourceWaitTime = 1.0 # while True: # if count >= Max_Try and Reversecount >= Reverse_Max_Try: # return False # time.sleep(2) # self.redRat3.sendKey('source') # time.sleep(sourceWaitTime) # isFind, text = self.getCurrentFocusTextEx('First', 'source', 'source', option, value_for_ocr, True) # if isFind == -1: # # 6586自研机芯USB进入之后无法唤出信源 按return再一次按source呼出界面 # self.redRat3.sendKey("return") # self.redRat3.sendKey('source') # time.sleep(0.2) # isFind, text = self.getCurrentFocusTextEx('First', 'source', 'source', option, value_for_ocr, True) # if isFind == -1: # printLog(u"当前界面找不到焦点！即source没有调出信源界面") # return False # # if isFind == 1: # printLog(u"聚焦到目标option:%s，设置信源value:%s选项成功！" % (str(option), str(value))) # # 聚焦成功发送enter_key # self.redRat3.sendKey('ok') # return True # # 判断两次识别 # print "text:", text, "old_text:", old_text, self.ocr.cmpOcrStr(text, old_text) # # # 判断信源界面有没有消失 如果消失再次按出信源界面 # isFind_source, text = self.getCurrentFocusTextEx('First', 'source', 'source', option, value_for_ocr, True) # if isFind_source == -1: # self.redRat3.sendKey('source') # time.sleep(sourceWaitTime) # # # 判断两次识别的text是否相等来判断是否到达边界 # if self.ocr.cmpOcrStr(text, old_text): # # 如果已经到达边界则不再正方向寻找焦点 # count = Max_Try # old_text = "init_old_text" # else: # old_text = text # # if count < Max_Try: # count = count + 1 # self.redRat3.sendKey(findDirection) # self.redRat3.sendKey('ok') # else: # Reversecount = Reversecount + 1 # self.redRat3.sendKey(findReverseDirection) # self.redRat3.sendKey('ok') # # errorPngName = "menutree_error_" + str(option) + '_' + str(value) + self.currentTime() + ".png" # error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) # self.ccard.takePicture(error_uiPic) # printLog(u"设置信源值时，正向遍历%s次，和反向遍历%s次都没有聚焦到option：%s的value:%s选项中,截图为%s" % ( # str(Max_Try), str(Reverse_Max_Try), str(option), str(value), str(error_uiPic))) # return False # 对外接口：信源设置接口; 先切换再识别 ''' 不允许切换信源，在MenuTree.ini文件中配置：source={"offset":20,"minPeri":0,"maxPeri":0,"minArea":0,"maxArea":0,"enable":0}。 enable没有，默认值enable=1；enable=0，表示不允许切换信源，仅判断是否为目标信源。 ''' def setSourceValue(self, option, value, sourceWaitTime=1.0, Max_Try=10): # 切黑场; self.sourceInput.setPattern(11) return self.tSource.setSourceValue(option, value, sourceWaitTime, Max_Try) def inputUnlock(self, std_str, password=''): # 如果锁住，按ok会弹出输入密码框; self.redRat3.sendKey("ok") # 获取密码; if password.__len__() == 0: password = self.tconfig.get_value("Password", "super") # 发送按键; for key in list(password): self.redRat3.sendKey(key, 1, 0.2) time.sleep(1) # 发送ok键; self.redRat3.sendKey('ok') # 判断是否成功输入密码; current_uiPic = self.getCurrentUIPath() self.get_ocr_list("", "") # 遍历ocr类型; found = False for item in self.ocrDict: # 识别ocr; ocr_str = self.ocr.getStrWithImgProcess(current_uiPic, {}, item["lan"], item["type"], reconTimes=1) ocr_str = unicode(ocr_str).lower() # print("lan=%s,type=%d,ocr=%s" % (item["lan"], item["type"], ocr_str)) printLog("lan=%s,type=%d,ocr=%s" % (item["lan"], item["type"], ocr_str)) if ocr_str in std_str or std_str == ocr_str: found = True break return not found def openOption(self, option, Max_Try=15): # 切黑场; self.sourceInput.setPattern(11) # 获取menu path; print "openOption start >>>" path_params = self.uitPathManage.get_option_paths(option) # print 'openOption=path_params:', path_params printLog('openOption=path_params:%s' % str(path_params)) checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params) if str(checkRunOptionPathResult) == "NoExit": printLog(u"表格中不存在到达Option: %s 的路径,在表格中排查到达该Option路径" % str(option)) return False if str(checkRunOptionPathResult) == "Fail": printLog(u"表格中到达Option: %s 的路径出现数据断层找不到First层级,在表格中排查到达该Option路径" % str(option)) return False # returnKeyEventCount = path_params.__len__() + 1 returnKeyEventCount = 0 print "returnKeyEventCount:", returnKeyEventCount printLog("openOption=returnKeyEventCount:%s" % str(returnKeyEventCount)) # 逆序路径key; revpp = reversed(path_params) # 根节点是否已进入; entry = False first_parent = u'' first_option = u'' # 遍历路径(已排序，从first开始); # print "revpp:", revpp printLog("openOption=revpp:%s" % str(revpp)) for level in revpp: # print "openOption=level:", path_params[level] printLog("openOption=level:", path_params[level]) # 是否进入根结点; if entry == False: # 标记已进入根; entry = True first_parent = path_params[level]["parent"] first_option = path_params[level]["option"] checkFirstOptionTimes = 0 while True: if checkFirstOptionTimes > 2: printLog(u"openOption=尝试3次快捷按键没有唤出聚焦焦点界面!!!") return False printLog(u"第%s次尝试呼出一级界面" % str(checkFirstOptionTimes)) # # 进入根节点(根节点名就是遥控键名); # self.redRat3.sendKey(path_params[level]["parent"]) # 判断是否存在others字段，others字段中存在first_key，则优先使用first_key进入 try: others = json.loads(path_params[level]["others"]) except Exception,e: others = {} printLog("section others:%s"%others) if "first_key" in others.keys(): first_key = others["first_key"] else: first_key = path_params[level]["parent"] printLog(u"进入根节点，first_key:%s"%first_key) # 进入根节点 self.redRat3.sendKey(first_key) waitTime = self.getParentWaitTime(path_params[level]["parent"]) printLog(u"打开%s界面的等待时间waittime为：%s" % (str(path_params[level]["parent"]), str(waitTime))) time.sleep(waitTime) # 获取ocr列表; self.get_ocr_list(level, option) if self.isFirstOptionShow(level, first_parent, first_option): printLog(u"呼出一级菜单界面") break else: time.sleep(5) self.redRat3.sendKey("return", 2) checkFirstOptionTimes = checkFirstOptionTimes + 1 # 如果一级界面弹出成功，则退出时候返回按键次数加1 returnKeyEventCount = returnKeyEventCount + 1 # 如果 others 字段不为空; if path_params[level]["others"].__len__(): # 如果不是跑马灯处理则按照输入密码处理 if self.dealOthers(level, path_params[level]) is True: # print u"解锁失败!!!" printLog(u"openOption=解锁失败!!!") return False # 移动到子节点; cur_option_enter_key = path_params[level]["option_enter_key"] # 移动到子节点; if cur_option_enter_key.__len__() == 0: enter_key = path_params[level]["enter_key"] else: enter_key = cur_option_enter_key move_key = path_params[level]["move_key"] if str(move_key) == str([u'up', u'down']) or str(move_key) == str([u'down', u'up']): findDirection = str(move_key[1]) elif str(move_key) == str([u'left', u'right']) or str(move_key) == str([u'right', u'left']): findDirection = str(move_key[1]) else: findDirection = 'grid' result = self.move2TargetNode( level, first_parent, path_params[level], returnKeyEventCount, findDirection=findDirection, Max_Try=Max_Try) if result is True: # 子节点的进入方式默认为ok; self.redRat3.sendKey(enter_key) # 如果执行一次enter_key，则退出时按返回键的次数加一 if enter_key != u'default': returnKeyEventCount = returnKeyEventCount + 1 else: print "openOption end<<<<" return False # end-for print "openOption end <<<<" return True # 对外接口：检测频道列表; def checkChannelList(self, channelList, Max_Try=15): failChannelList = [] checkResult = True if channelList == []: printLog(u"传入的待检测的频道列表为空！") return False, failChannelList for channel in channelList: isSearched = self.checkOptionValue("ok", channel, Max_Try=Max_Try) if not isSearched: printLog(u"频道:%s查找失败！" % str(channel)) failChannelList.append(channel) checkResult = False # 部分机芯项目（如6586外协松下）按return键无法退出频道，故改为exit键 # self.redRat3.sendKey("return") self.redRat3.sendKey("exit") else: printLog(u"频道:%s查找成功！" % str(channel)) self.redRat3.sendKey("exit") printLog(u"频道列表检测结果checkResult:%s,检测失败频道列表failChannelLis:%s" % (str(checkResult), str(failChannelList))) return checkResult, failChannelList # 对外唯一接口：设置操作值; def focusOptionValue(self, option, value, Max_Try=15, leafNodeValueWaitTime=0.0): # 切黑场; self.sourceInput.setPattern(11) printLog(u"focusOptionValue。option:%s value:%s" % (str(option), str(value))) # 寻路结果; result = False # 获取menu path; value_params, path_params = self.uitPathManage.get_menu_paths(option, value) printLog(u"获取到达option:%s的路径字典path_params:%s" % (str(option), str(path_params))) printLog(u"获取聚焦value:%s的值字典value_params:%s" % (str(value), str(value_params))) checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params) if str(checkRunOptionPathResult) == "NoExit": printLog(u"表格中不存在到达Option: %s 的路径,在表格中排查到达该Option路径" % str(option)) return False if str(checkRunOptionPathResult) == "Fail": printLog(u"表格中到达Option: %s 的路径出现数据断层找不到First层级,在表格中排查到达该Option路径" % str(option)) return False # returnKeyEventCount = path_params.__len__() + 1 returnKeyEventCount = 0 print "returnKeyEventCount:", returnKeyEventCount # 逆序路径key; revpp = reversed(path_params) # 根节点是否已进入; entry = False root = u'' first_parent = u'' first_option = u'' # 遍历路径(已排序，从first开始); # print "revpp:", revpp for level in revpp: # print "level:", level, path_params[level] printLog(u"执行路径level:%s 对应路径字典:%s" % (str(level), str(path_params[level]))) # 是否进入根结点; if entry == False: # 标记已进入根; entry = True first_parent = path_params[level]["parent"] first_option = path_params[level]["option"] checkFirstOptionTimes = 0 while True: if checkFirstOptionTimes > 2: errorPngName = "menutree_error_" + str(option) + '_' + str(value) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"执行focusOptionValue ERROR!option:%s value:%s ;尝试3次快捷按键仍然没有唤出聚焦焦点界面!!! 出错截图:%s" % ( str(option), str(value), str(error_uiPic))) return False printLog(u"第%s次尝试呼出一级界面" % str(checkFirstOptionTimes)) # # 进入根节点(根节点名就是遥控键名); # self.redRat3.sendKey(path_params[level]["parent"]) # 判断是否存在others字段，others字段中存在first_key，则优先使用first_key进入 try: others = json.loads(path_params[level]["others"]) except Exception,e: others = {} printLog("section others:%s"%others) if "first_key" in others.keys(): first_key = others["first_key"] else: first_key = path_params[level]["parent"] printLog(u"进入根节点，first_key:%s"%first_key) # 进入根节点 self.redRat3.sendKey(first_key) waitTime = self.getParentWaitTime(path_params[level]["parent"]) printLog(u"打开%s界面的等待时间waittime为：%s" % (str(path_params[level]["parent"]), str(waitTime))) time.sleep(waitTime) # 获取ocr列表; self.get_ocr_list(level, option) if self.isFirstOptionShow(level, first_parent, first_option): printLog(u"呼出一级菜单界面") break else: time.sleep(5) self.redRat3.sendKey("return", 2) checkFirstOptionTimes = checkFirstOptionTimes + 1 # 如果一级界面弹出成功，则退出时候返回按键次数加1 returnKeyEventCount = returnKeyEventCount + 1 print "level:", level, "root:", root # 如果 others 字段不为空; if path_params[level]["others"].__len__(): # 如果不是跑马灯处理则按照输入密码处理 if self.dealOthers(level, path_params[level]) is True: # print u"解锁失败!!!" printLog(u"执行setOptionValue ERROR!option:%s value:%s ;解锁失败!!!" % (str(option), str(value))) return False # 移动到子节点; cur_option_enter_key = path_params[level]["option_enter_key"] # 移动到子节点; if cur_option_enter_key.__len__() == 0: enter_key = path_params[level]["enter_key"] else: enter_key = cur_option_enter_key move_key = path_params[level]["move_key"] if str(move_key) == str([u'up', u'down']) or str(move_key) == str([u'down', u'up']): findDirection = str(move_key[1]) elif str(move_key) == str([u'left', u'right']) or str(move_key) == str([u'right', u'left']): findDirection = str(move_key[1]) else: findDirection = 'grid' result = self.move2TargetNode( level, first_parent, path_params[level], returnKeyEventCount, findDirection=findDirection, Max_Try=Max_Try) if result is True: # 子节点的进入方式默认为ok; # self.redRat3.sendKey('ok') # 如果只一层，不进行enter_key执行 if path_params.__len__() != 1: self.redRat3.sendKey(enter_key) # 如果执行一次enter_key，则退出时按返回键的次数加一 if enter_key != u'default': returnKeyEventCount = returnKeyEventCount + 1 else: break # end-for # 如果只一层不进行focusLeafNodeValue设置 if path_params.__len__() != 1: # 寻路成功，设置叶节点值; if result is True: # 如果是信源选择 自动选择不需要执行 enter_key if self.ocr.cmpOcrStr(option, 'source'): return True time.sleep(leafNodeValueWaitTime) print u"执行设置叶节点：", value_params result = self.focusLeafNodeValue( level, root, value_params["option"], value_params["value"], value_params["value_for_ocr"], value, value_params["move_key"], value_params["enter_key"], Max_Try=Max_Try) # 无论成功失败，要返回到初始界面 if result: # 如果执行成功则不返回到初始界面 printLog(u"设置option:%s 选中value:%s的值成功！" % (str(option), str(value))) else: printLog(u"设置option:%s 选中value:%s的值失败！" % (str(option), str(value))) print u"执行退出，执行退出按键次数returnKeyEventCount：", returnKeyEventCount # 执行聚焦失败时候，返回到初始界面 self.redRat3.sendKey("return", returnKeyEventCount, 0.2) time.sleep(1) # 检测执行回退键是否成功，吐过仍有聚焦效果则继续执行return键 reCount = 0 while True: if reCount >= returnKeyEventCount: printLog(u"执行了returnKeyEventCount:%s次,仍无法退出到初始界面" % str(returnKeyEventCount)) break if self.isFirstOptionShow("First", first_parent, first_option): reCount = reCount + 1 # 如果仍然可以检测到聚焦效果，则继续执行return self.redRat3.sendKey("return") else: printLog(u"回退到初始界面成功！") break # 返回结果; return result # 设置叶子节点值; def focusLeafNodeValue(self, level, parent, option, value_excel, value_for_ocr, value, move_key, enter_key, Max_Try=15): # 按照传入的方向寻找Max_Try次，如果仍未聚焦到option_for_ocr所在的区域，则按照传入方向的反方向 反向寻找 2*Max_Try 次 # 正向寻找的次数计数和最大次数 count = 0 Max_Try = Max_Try # 反向寻找的次数计数和最大次数 Reversecount = 0 Reverse_Max_Try = Max_Try * 2 # 记录上一个焦点识别的文字内容 用于判断是否到达列表的边界 如果到达边界则反向寻找 old_text = "init_old_text" # 正向寻找的遥控器按键值 findDirection = move_key[1] # 向右或者向下 # 反向寻找的遥控器按键值 findReverseDirection = move_key[0] # 向左或者向上 # 获取等待时间 waitTime = self.getLeafWaitTime(option) printLog(u"focusLeafNodeValue:获取到进入叶节点%s，等待时间为%s"%(option, waitTime)) time.sleep(waitTime) value_for_ocr_low = str(value_for_ocr[0]).lower() # 判断设置值的类型 是rang类型还是str类型 if "range(" in value_for_ocr_low: isRangeType = True str_num = value_for_ocr_low.replace("range", "") list_num = eval(str_num) min_num = list_num[0] max_num = list_num[1] try: value_num = int(value) except Exception: printLog(u"传入的值value:%s和option:%s对应的类型不匹配 ！" % (str(value), str(option))) return False else: isRangeType = False if isRangeType: # 如果是数值类型，则直接返回聚焦成功 return True else: # 设置选项类型的处理 while (True): print "count:", count if count >= Max_Try and Reversecount >= Reverse_Max_Try: break isFind, text = self.getCurrentFocusTextEx(level, parent, option, value_excel, value_for_ocr, isForValue=True) if isFind == -1: errorPngName = "menutree_error_" + str(option) + '_' + str( value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"聚焦叶子节点值时，当前界面无法找到焦点区域！！！出错界面截图%s" % str(error_uiPic)) return False # elif (self.ocr.cmpOcrStr(text, value_for_ocr)): # 由比较目标文本和识别文本 是否相等 改为 识别文本是否包含目标文本 else: if isFind == 1: printLog(u"聚焦到目标option:%s，设置value:%s选项成功！" % (str(option), str(value_excel))) # 聚焦到某个焦点成功，由于是聚焦接口调用，不用send enter_key进入到焦点 # if enter_key != 'default': # self.redRat3.sendKey(enter_key) return True # 判断两次识别 # 判断两次识别的text是否相等来判断是否到达边界 if self.ocr.cmpOcrStr(text, old_text): # 如果已经到达边界则不再正方向寻找焦点 count = Max_Try old_text = "init_old_text" else: old_text = text if count < Max_Try: count = count + 1 self.redRat3.sendKey(findDirection) else: Reversecount = Reversecount + 1 self.redRat3.sendKey(findReverseDirection) errorPngName = "menutree_error_" + str(option) + '_' + str(value_excel) + self.currentTime() + ".png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) printLog(u"聚焦叶子节点值时，正向遍历%s次，和反向遍历%s次都没有聚焦到option：%s的value:%s选项中,截图为%s" % ( str(Max_Try), str(Reverse_Max_Try), str(option), str(value_excel), str(error_uiPic))) return False return True def getOptionValue(self, option, is_value_sheet=True): # 切黑场; self.sourceInput.setPattern(11) # 获取路径参数; result, option_data = self.uitRunner.uitData.UITree.get_option(option) if result is False: print(u"getOptionValue.获取option菜单内容失败") return False, '' first_parent = option_data['first_parent'] thresholdDict = self.tconfig.getThresholdDict(first_parent) # 根据parent打开特定的option； if self.openOption(option) is False: self.redRat3.sendKey('return', option_data['layers'] + 1, 0.2) print(u"getOptionValue.进入指定option失败") return False, '' # 获取等待时间 waitTime = self.getOptionWaitTime(option) printLog(u"getOptionValue:获取到进入叶节点%s，等待时间为%s"%(option, waitTime)) time.sleep(waitTime) time.sleep(0.5) # 截图; current_uiPic = self.getCurrentUIPath() # 获取焦点框; result, opcfg = self.tFocus.getOptionConfig(option, is_value_sheet) if result is False: self.redRat3.sendKey('return', option_data['layers'] + 1, 0.2) print(u"getOptionValue.获取焦点参数失败") return False, '' dcfg = opcfg['dcfg'] icon_path = opcfg['icon_path'] icon_dir_path = opcfg['dir_path'] # 获取聚集框; result, cur_box = self.tFocus.findFocusByIcon(current_uiPic, icon_path, dcfg) if result is False: self.redRat3.sendKey('return', option_data['layers'] + 1, 0.2) print(u"getOptionValue.获取焦点框轮廓失败") return False, '' # 根据dir计算文本框; cur_box = self.getFocusTextBox4(icon_dir_path, option, cur_box, is_value_sheet) # 获取文本区域截图; ocr_result_text = '' txt_pic = os.path.join(getSATTmpDIR(), "meuttree_area_text.png") self.imgCMP.saveCropPic(current_uiPic, txt_pic, (cur_box[0], cur_box[1], cur_box[2], cur_box[3])) if is_value_sheet is True: value_paramters = self.uitRunner.uitData.UITree.get_value(option, '') isRangeType = False # 判断设置值的类型 是rang类型还是str类型 if value_paramters['value_for_ocr'].__len__() and "range(" in value_paramters['value_for_ocr'][0].lower(): isRangeType = True if isRangeType is True: # 获取ocr列表; hasOption,path = self.uitRunner.uitData.UITree.get_option(option) if hasOption: self.get_ocr_list(path['level'], option) for orc_item in self.ocrDict: # ocr_result = self.ocr.getStr(txt_pic, orc_item["lan"], orc_item["type"]) ocr_result = self.ocr.getStrWithImgProcess(txt_pic, thresholdDict, orc_item["lan"], orc_item["type"], reconTimes=1) # print("getCurrentFocusOcr_Int=ocr识别结果=%s" % (ocr_result)) printLog("getCurrentFocusOcr_Int=ocr识别结果=%s" % (ocr_result)) if ocr_result == "ERR" or ocr_result.__len__() == 0: continue # 字符串去掉末尾">"符号; ocr_result = ocr_result.strip('>') # 按数字分解多组文本; list_ocr = getDigitFromString(ocr_result) # list_ocr = self.strSplit(ocr_result) # 只判断最后一位是否是数字; if list_ocr.__len__() < 1: errorPngName = "menutree_error_" + self.currentTime() + "ocr.png" error_uiPic = os.path.join(getSATTmpDIR(), errorPngName) self.ccard.takePicture(error_uiPic) # print u"当前识别的ocr 不包含int类型值，截图为：%s" % (str(ocr_result)) printLog(u"当前识别的ocr 不包含int类型值，截图为：%s" % (str(ocr_result))) continue try: # 获取最右边的文本，如果是数字则退出; text_int_str = list_ocr[list_ocr.__len__() - 1] # print 'text_int_str:', text_int_str printLog('text_int_str:%s' % str(text_int_str)) ocr_result_text = float(text_int_str) break except Exception: continue else: # 普通ocr文本识别; # ocr_result_text = self.ocr.getStr(txt_pic, "ChinesePRC+English", 4) ocr_result_text = self.ocr.getStrWithImgProcess(txt_pic, thresholdDict, "ENG", 10000, reconTimes=1) else: # 普通ocr文本识别; # ocr_result_text = self.ocr.getStr(txt_pic, "ChinesePRC+English", 4) ocr_result_text = self.ocr.getStrWithImgProcess(txt_pic, thresholdDict, "ENG", 10000, reconTimes=1) # 退出菜单; self.redRat3.sendKey('return', option_data['layers'] + 1, 0.2) # 返回结果; return True, ocr_result_text def getParentWaitTime(self, parent): optionName = parent + "WaitTime" try: waitTime = float(self.tconfig.get_value("waitTime", optionName)) except Exception: waitTime = 1.0 # print "获取%s界面的等待界面时间失败，使用默认值1.0s" % str(parent) return waitTime def getOptionWaitTime(self, option): result, option_data = self.uitRunner.uitData.UITree.get_option(option) print u"getOptionWaitTime.option_data:",option_data if result: try: others = json.loads(option_data['others']) waitTime = float(others['waitTime']) except Exception,e: print u"获取%s界面的等待时间失败，使用默认值1.0s" % str(option) waitTime = 1.0 else: waitTime = 1.0 return waitTime def getLeafWaitTime(self, option): leaf_data = self.uitRunner.uitData.UITree.get_value(option) print u"getLeafWaitTime.option_data:",leaf_data try: others = json.loads(leaf_data['others']) waitTime = float(others['waitTime']) except Exception,e: print u"获取%s界面的等待时间失败，使用默认值1.0s" % str(option) waitTime = 1.0 return waitTime # channel_count：如果有频道，最大可能的频道数量; # black_th:黑色频道背景色RGB单通道值 # black_rate：图片分割成100块，纯黑色区域占有比 def getBlackChannel(self, channel_count, black_th=20, black_rate=0.8): result = False # 根据频道数量遍历; for i in range(0, channel_count): pass # 截图,取左半边; pic_path = self.getCurrentUIPath() img = cv.imread(pic_path) pic_path2 = os.path.join(getSATTmpDIR(), "menutree_focus_area_half.png") self.imgCMP.saveCropPic(pic_path, pic_path2, (0, 0, img.shape[1] / 2, img.shape[0])) # 是否符合要求; result = self.imgCMP.isBlack(pic_path2, black_th, 10, 1 - black_rate) if result is True: break # 下一频道号; self.redRat3.sendKey('C+') time.sleep(4) # endfor return result # 新增操作接口 # 聚焦到Option 区别于openOption，focusOption不会执行到option的子界面中 def focusOption(self, option, Max_Try=15): # 切黑场; self.sourceInput.setPattern(11) # 获取menu path; print u"focusOption start >>>" path_params = self.uitPathManage.get_option_paths(option) # print 'openOption=path_params:', path_params printLog('focusOption=path_params:%s' % str(path_params)) checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params) if str(checkRunOptionPathResult) == "NoExit": printLog(u"表格中不存在到达Option: %s 的路径,在表格中排查到达该Option路径" % str(option)) return False if str(checkRunOptionPathResult) == "Fail": printLog(u"表格中到达Option: %s 的路径出现数据断层找不到First层级,在表格中排查到达该Option路径" % str(option)) return False runPathCount = 0 pathCount = path_params.__len__() printLog("focusOption=pathCount:%s" % str(pathCount)) # returnKeyEventCount = path_params.__len__() + 1 returnKeyEventCount = 0 print "returnKeyEventCount:", returnKeyEventCount printLog("focusOption=returnKeyEventCount:%s" % str(returnKeyEventCount)) # 逆序路径key; revpp = reversed(path_params) # 根节点是否已进入; entry = False first_parent = u'' first_option = u'' # 遍历路径(已排序，从first开始); # print "revpp:", revpp printLog("focusOption=revpp:%s" % str(revpp)) for level in revpp: # print "openOption=level:", path_params[level] printLog("focusOption=level:", path_params[level]) # 是否进入根结点; if entry == False: # 标记已进入根; entry = True first_parent = path_params[level]["parent"] first_option = path_params[level]["option"] checkFirstOptionTimes = 0 while True: if checkFirstOptionTimes > 2: printLog(u"focusOption=尝试3次快捷按键没有唤出聚焦焦点界面!!!") return False printLog(u"第%s次尝试呼出一级界面" % str(checkFirstOptionTimes)) # # 进入根节点(根节点名就是遥控键名); # self.redRat3.sendKey(path_params[level]["parent"]) # 判断是否存在others字段，others字段中存在first_key，则优先使用first_key进入 try: others = json.loads(path_params[level]["others"]) except Exception,e: others = {} printLog("section others:%s"%others) if "first_key" in others.keys(): first_key = others["first_key"] else: first_key = path_params[level]["parent"] printLog(u"进入根节点，first_key:%s"%first_key) # 进入根节点 self.redRat3.sendKey(first_key) waitTime = self.getParentWaitTime(path_params[level]["parent"]) printLog(u"打开%s界面的等待时间waittime为：%s" % (str(path_params[level]["parent"]), str(waitTime))) time.sleep(waitTime) # 获取ocr列表; self.get_ocr_list(level, option) if self.isFirstOptionShow(level, first_parent, first_option): printLog(u"呼出一级菜单界面") break else: time.sleep(5) self.redRat3.sendKey("return", 2) checkFirstOptionTimes = checkFirstOptionTimes + 1 # 如果一级界面弹出成功，则退出时候返回按键次数加1 returnKeyEventCount = returnKeyEventCount + 1 # 如果 others 字段不为空; if path_params[level]["others"].__len__(): # 如果不是跑马灯处理则按照输入密码处理 if self.dealOthers(level, path_params[level]) is True: # print u"解锁失败!!!" printLog(u"focusOption=解锁失败!!!") return False # 移动到子节点; cur_option_enter_key = path_params[level]["option_enter_key"] # 移动到子节点; if cur_option_enter_key.__len__() == 0: enter_key = path_params[level]["enter_key"] else: enter_key = cur_option_enter_key move_key = path_params[level]["move_key"] if str(move_key) == str([u'up', u'down']) or str(move_key) == str([u'down', u'up']): findDirection = str(move_key[1]) elif str(move_key) == str([u'left', u'right']) or str(move_key) == str([u'right', u'left']): findDirection = str(move_key[1]) else: findDirection = 'grid' result = self.move2TargetNode( level, first_parent, path_params[level], returnKeyEventCount, findDirection=findDirection, Max_Try=Max_Try) if result is True: runPathCount = runPathCount + 1 printLog("focusOption=runPathCount:%s" % str(runPathCount)) if runPathCount == pathCount: print u"执行到最后一级" pass else: # 子节点的进入方式默认为ok; self.redRat3.sendKey(enter_key) # 如果执行一次enter_key，则退出时按返回键的次数加一 if enter_key != u'default': returnKeyEventCount = returnKeyEventCount + 1 else: print "focusOption end<<<<" return False # end-for print "focusOption end <<<<" return True # 假定已经在option所在的页面，逐步移动到目标option，聚焦到option def moveToOption(self, option, Max_Try=15): # 切黑场; # self.sourceInput.setPattern(11) # 获取menu path; print "moveToOption start >>>" path_params = self.uitPathManage.get_option_paths(option) # print 'openOption=path_params:', path_params printLog('moveToOption=path_params:%s' % str(path_params)) checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params) if str(checkRunOptionPathResult) == "NoExit": printLog(u"表格中不存在到达Option: %s 的路径,在表格中排查到达该Option路径" % str(option)) return False if str(checkRunOptionPathResult) == "Fail": printLog(u"表格中到达Option: %s 的路径出现数据断层找不到First层级,在表格中排查到达该Option路径" % str(option)) return False runPathCount = 0 pathCount = path_params.__len__() printLog("moveToOption=pathCount:%s" % str(pathCount)) returnKeyEventCount = path_params.__len__() # print "returnKeyEventCount:", returnKeyEventCount printLog("moveToOption=returnKeyEventCount:%s" % str(returnKeyEventCount)) # 逆序路径key; revpp = reversed(path_params) # 根节点是否已进入; entry = False first_parent = u'' # first_option = u'' # 遍历路径(已排序，从first开始); # print "revpp:", revpp printLog("moveToOption=revpp:%s" % str(revpp)) for level in revpp: # print "openOption=level:", path_params[level] runPathCount = runPathCount + 1 print "level:", level, type(level) print "runPathCount:", runPathCount, type(runPathCount) print "pathCount:", pathCount, type(pathCount) printLog("openOption=level:", path_params[level]) # 是否进入根结点; if entry == False: # 标记已进入根; entry = True first_parent = path_params[level]["parent"] # 由于已经到达option同级界面，只执行最后一层 if runPathCount == pathCount: # 移动到子节点; cur_option_enter_key = path_params[level]["option_enter_key"] # 移动到子节点; if cur_option_enter_key.__len__() == 0: enter_key = path_params[level]["enter_key"] else: enter_key = cur_option_enter_key move_key = path_params[level]["move_key"] if str(move_key) == str([u'up', u'down']) or str(move_key) == str([u'down', u'up']): findDirection = str(move_key[1]) elif str(move_key) == str([u'left', u'right']) or str(move_key) == str([u'right', u'left']): findDirection = str(move_key[1]) else: findDirection = 'grid' result = self.move2TargetNode( level, first_parent, path_params[level], returnKeyEventCount, findDirection=findDirection, Max_Try=Max_Try) if result is True: # runPathCount = runPathCount+1 printLog("moveToOption=runPathCount:%s" % str(runPathCount)) if runPathCount == pathCount: print "执行到最后一级" pass else: # 子节点的进入方式默认为ok; self.redRat3.sendKey(enter_key) else: print "moveToOption end<<<<" return False # end-for print "moveToOption end <<<<" return True # 找到两个字符串左边或者右边相同的部分 def findDuplicateString(self, str1, str2, direction="right"): index = 0 if direction == "right": while True: index -= 1 if abs(index) > str1.__len__() or abs(index) > str2.__len__(): break if not str1[index] == str2[index]: break if index == -1: return "" return str1[index+1:] elif direction == "left": while True: if abs(index) >= str1.__len__() or abs(index) >= str2.__len__(): break if not str1[index] == str2[index]: break index += 1 return str1[:index] # 去掉字符串数组中每个字符串 左边或右边相同的部分 def removeDuplicateString(self, strList): finishedList = strList directionList = ["left", "right"] for direction in directionList: same_str = self.findDuplicateString(strList[0], strList[1], direction) if same_str == "": continue else: for i in range(2, strList.__len__()): same_str = self.findDuplicateString(same_str,strList[i], direction) if same_str == "": break if same_str != "": finishedList = [] for str in strList: if direction == "left": str = str[same_str.__len__():] else: str = str[:-same_str.__len__()] finishedList.append(str) return finishedList if __name__ == "__main__": tmenu = CTMenu() print "执行开始！" # ThresholdDict = tmenu.tconfig.getThresholdDict("factory") # ThresholdDict = tmenu.tconfig.getThresholdDict("setting") # print "ThresholdDict:", ThresholdDict, type(ThresholdDict) # tmenu.getOptionValue("picture_preset")value # parent_ocr_dict = tmenu.xlsparser.get_parent_ocr_dict("automatic_search_analogue") # print "parent_ocr_dict:",parent_ocr_dict # 获取menu path; # value_params, path_params = tmenu.xlsparser.get_menu_paths('av', '') # print value_params, path_params # tmenu.redRat3.sendKey('home') # tmenu.move2TargetGridNode_matchTemp('First', 'home', path_params['First'], 1) # isSuccessed = tmenu.setOptionValue("picture_preset", "stadium") # isSuccessed = tmenu.setOptionValue("backlight", 50) # isSuccessed = tmenu.checkOptionValue("picture_preset", "stadium") # isSuccessed = tmenu.checkOptionValue("backlight", 50) # print u'isSuccessed:', isSuccessed # isSuccessed_focusOption = tmenu.focusOption("picture_preset") # print u'聚焦到目标Option：auto_volume_control 结果isSuccessed_focusOption:', isSuccessed_focusOption # 确保当前焦点是在目标Option同级的 # if isSuccessed_focusOption: # isSuccessed_moveToOption = tmenu.moveToOption("picture_reset") # print u'焦点移动到目标Option结果isSuccessed_moveToOption:', isSuccessed_moveToOption # value_params, path_params = tmenu.xlsparser.get_menu_paths("picture_preset ", "personal") # print "value_params:",value_params # print "path_params:",path_params # # path_params_1 = tmenu.xlsparser.get_option_paths("picture_preset ") # print "path_params_1:", path_params_1 # isHasValue, ocr_result_text = tmenu.getOptionValue("backlight") # print "isHasValue:",isHasValue,type(isHasValue) # print "ocr_result_text:",ocr_result_text,type(ocr_result_text) # tmenu.setOptionValue("backlight",ocr_result_text) # paths = tmenu.xlsparser.get_option_paths('usb') # tmenu.move2TargetGridNode('first', 'usb', paths, 5) # isSuccessed = tmenu.setOptionValue("source", "tv") # isSuccessed = tmenu.setOptionValue("picture_preset", "stadium") # isSuccessed = tmenu.setOptionValue("picture_preset", "dynamic") # isSuccessed = tmenu.setOptionValue("gamma", 0) # isSuccessed = tmenu.setOptionValue("instant_power_on", "on") # isSuccessed = tmenu.setOptionValue("RGB_mode", "green_only") # isSuccessed = tmenu.focusOptionValue("option", "enjoy_music") # print "isSuccessed:", isSuccessed # settingWaitTime = tmenu.getParentWaitTime("setting") # print settingWaitTime # sourceWaitTime = tmenu.getParentWaitTime("source") # print sourceWaitTime # print tmenu.setOptionValue('overscan', 'off') # print tmenu.getOptionValue('overscan') # settings 检测焦点选择类的setOptionValue # isSuccessed = tmenu.setOptionValue("backlight", 50) # print "isSuccessed:", isSuccessed # isSuccessed = tmenu.setOptionValue("500hz", 50) # print u'isSuccessed:', isSuccessed # settings 检测值设置类的setOptionValue # isSuccessed = tmenu.setOptionValue("backlight", 70) # isSuccessed = tmenu.setOptionValue("auto_volume_control", "on") # print u'isSuccessed:', isSuccessed # settings 检测焦点选择类的checkOptionValue # isSuccessed = tmenu.checkOptionValue("picture_preset", "movie") # print u'isSuccessed:', isSuccessed # isSuccessed = tmenu.setOptionValue("picture_preset", "movie", leafNodeValueWaitTime=2.0) # print u'isSuccessed:', isSuccessed # settings 检测值设置类的checkOptionValue # isSuccessed = tmenu.checkOptionValue("backlight", 70) # print u'isSuccessed:', isSuccessed # 信源切换检测 # isSuccessed = tmenu.setSourceValue('source', 'hdmi2', sourceWaitTime=1.5) # print u'进入信源(hdmi2)isSuccessed:', isSuccessed # isSuccessed = tmenu.setSourceValue('source', 'av') # print u'进入信源(tv)isSuccessed:', isSuccessed # 频道列表检测 # checkResult,failChannelList=tmenu.checkChannelList(["6", "22"]) # print u'checkResult,failChannelList:', checkResult,failChannelList # 检测自动搜台 # isSuccessed = tmenu.auto_search("automatic_search",[["as_tuner_mode","air"],["as_channel_type","analog"]]) # print u'isSuccessed:', isSuccessed # isSuccessed =tmenu.auto_search("automatic_search", [["as_tuner_mode", "air"], ["as_channel_type", "analog"]], # ["as_search", "finished"]) # print u'isSuccessed:', isSuccessed # 检测手动搜台 # isSuccessed =tmenu.manual_search("manual_tuning", [["mt_tuner_mode", "air"], ["mt_channel_type", "analog"], ["mt_ch", 12]]) # print u'isSuccessed:', isSuccessed # isSuccessed = tmenu.manual_search("manual_tuning", # [["mt_tuner_mode", "cable"], ["mt_channel_type", "digital"], ["mt_ch", 12]]) # print u'isSuccessed:', isSuccessed