scbc_repos/ssat_sdk/MenuTree3/TMenu.py

# -*- 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 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<Exp>" 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<Exp>" 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<Exp>" 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<Exp>" 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