逐步实现接口。

ssat_sdk/MenuTree3/TMenu.py

@@ -1,2464 +1,341 @@
 # -*- 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
+import os, time
+from BaseLog import CBaseLog
+from ExtraData import CExtraData
+from OptionExcel import COptionExcel
+from OptionConfig import COptionConfig
+from OptionFocus import COptionFocus
+from OptionOCR import COptionOCR
+from OptionAction import COptionAction
 from ssat_sdk.source_input import SourceGenInput
+# 测试使用到
+import random
 
-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')
+class CTMenu(CBaseLog):
+    sourceInput = SourceGenInput()
 
-        # 截图,获取分辨率;
-        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 __init__(self, ocrDict=None):
+        CBaseLog.__init__(self)
+        self.__exData = CExtraData()
+        self.__optionExcel = COptionExcel(self.__exData)
+        self.__optionConfig = COptionConfig(self.__exData, self.__optionExcel)
 
     '''
-    对应OptionConfig中的getThresholdDict和__getICONConfig
+    函数：判断两值(for_ocr与ocr识别结果)是否相等;
+    参数：
+        srcValue        源值，excel表格中读取的value值。
+        tagValue        目标值，ocr识别的结果值。
+    返回：相同返回True。
     '''
-    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 __isValueEqual(self, srcValue, tagValue):
+        self.info(u"源值=%s, 目标值=%s" % (str(srcValue), str(tagValue)))
 
-    # 获取焦点框文本;
-    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
+    '''
+    函数：移动到目标节点上（路径节点和value节点）
+    参数：
+        opa                 COptionAction对象;
+        moveDirection       移动方向，True表示调用move_key[1](向下或向右), False表示调用move_key[0]。
+        maxTry              最大移动次数，防止死循环。
+    返回：Boolean是否在目标节点上, 文本或数值。
+    '''
+    def __move2TargetNode(self, opa, moveDirection, maxTry=15):
+        tryCount = 0
+        # 是否到目标结点了;
+        isOnTargetNode = False
+        # 目标节点聚焦状态;
+        targetFocus = False
+        # 目标文本或数值;
+        targetText = None
+        # 移动到目标节点;
+        while True:
+            # 判断是否移动成功;
+            targetFocus, targetText = opa.isOnTargetNode()
+            if targetFocus is True:
+                # 如果已在目标结点,退出循环;
+                if opa.isOnTargetOption() or opa.isOnValueSheet():
+                    self.info(u"<到达目标路径节点或value节点>")
+                    isOnTargetNode = 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 47 < ord(ch) < 58:
-                str_int += ch
-                if str_ch.__len__():
-                    ret.append(str_ch)
-                    str_ch = ''
-            else:
-                if 47 < 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:
+                # 未到目标,进入下一节点;
+                self.info(u"<进入下一节点>")
+                opa.enterNode()
                 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)
+            # 移动到下/上一节点;
+            if moveDirection:
+                opa.move2NextSiblingNode()
             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)
+                opa.move2PrevSiblingNode()
 
-        # # 去除大小写的识别字符
-        # 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:
+            tryCount += 1
+            if tryCount > maxTry:
+                self.warn(u"已%s遍历超过%d次，仍未找到焦点" % ("正向" if moveDirection else "逆向", maxTry))
                 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"
+        # end-while
 
-        # 正向寻找的遥控器按键值
-        findDirection = move_key[1]  # 向右或者向下
-        # 反向寻找的遥控器按键值
-        findReverseDirection = move_key[0]  # 向左或者向上
+        return isOnTargetNode, targetText
 
+    '''
+    函数：聚焦到指定option中。
+    参数：
+        opa         COptionAction对象。
+    返回：Boolean，成功返回True.
+    '''
 
+    def __focusOption(self, opa):
+        # 检测路径是否有效;
+        if opa.checkRunOptionPath() is False:
+            self.__back2Home(opa)
+            return False
 
+        # 首先,调用根菜单;
+        opa.callFirstOptionShortCutKey()
+        time.sleep(1)
+        if opa.isOnFirstOption() is False:
+            self.error(u"未聚焦到根节点上,退出")
+            self.__back2Home(opa)
+            return False
 
-        # 获取等待时间
-        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)))
+        # 遍历到目标option中;
+        if self.__move2TargetNode(opa, True)[0] is False:
+            if self.__move2TargetNode(opa, False)[0] is False:
+                self.__back2Home(opa)
                 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
+        return True
 
-                    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)))
+    '''
+    函数：进入到指定的option中。
+    参数：
+        opa         COptionAction对象。
+    返回：Boolean，成功返回True.
+    '''
+    def __openOption(self, opa):
+        if self.__focusOption(opa) is False:
             return False
+        # 到达目标option后;
+        self.info(u"进入option")
+        opa.enterNode()
 
         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
+    '''
+    函数：返回到主页（不一定就是Home页，一般指返回运行前的那个画面）
+    参数：
+        opa         COptionAction对象;
+    返回：
+    
+    '''
+    def __back2Home(self, opa):
+        self.info(u"返回主页")
+        while opa.pos > 0:
+            opa.back2ParentNode()
+        self.info(u"【如果设置value时，会自动回退到上一层父节点，此处操作正常。否则要多返回一层。】")
 
-    # 对外接口：设置操作值;
-    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)))
+    '''
+    函数：设置指定的option的值为optionValue。
+    参数：
+        optionName      要设置的option；
+        optionValue     option要设置的值；
+    返回： Boolean。
+    '''
+    def setOptionValue(self, optionName, optionValue):
+        self.info(u"【%s】【%s】" % (optionName, optionValue))
+        CTMenu.sourceInput.setPattern(11)
+        opa = COptionAction(optionName, optionValue, self.__optionConfig, self.__optionExcel)
 
-        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))
+        # 检测路径是否有效;
+        if self.__openOption(opa) is False:
             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'
+        # 遍历到value节点中;
+        if self.__move2TargetNode(opa, True)[0] is False:
+            if self.__move2TargetNode(opa, False)[0] is False:
+                self.__back2Home(opa)
+                return False
 
-            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)
+        # 找到value节点,设置值;
+        self.info(u"设置value值：一般只适用于Number类型或Input类型，不适合选择类型。但都必须调用，因为里面有enterkey操作")
+        opa.setOptionValue()
 
-        # 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)
+        # 返回主页;
+        self.__back2Home(opa)
 
-        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
+    '''
+    函数：移动到目标option后，读取该option的value值，与optionValue进行比较，相等表示检测值与目标值一致;
+    参数：
+        optionName      要设置的option；
+        optionValue     option要设置的值；
+    返回： Boolean。
+    '''
 
-    # 对外接口：检测操作值是否正确;
-    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)))
+    def checkOptionValue(self, optionName, optionValue):
+        self.info(u"【%s】【%s】" % (optionName, optionValue))
+        CTMenu.sourceInput.setPattern(11)
+        opa = COptionAction(optionName, optionValue, self.__optionConfig, self.__optionExcel)
 
-        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))
+        # 进入节点;
+        if self.__openOption(opa) is False:
             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
+        isValueEqual = False
+        # 获取value节点值;
+        valueFocus, valueText = opa.isOnTargetNode()
+        self.info(u"===当前捕获的文本内容=%s，目标文本=%s，状态：%d===" % (str(valueText), str(optionValue), valueFocus))
 
-        if result:
-            printLog(u"检测option:%s 选中value:%s的值成功！" % (str(option), str(value)))
+        # 如果是数值,则判断获取的值是否相等;否则,只判断是否聚焦.
+        if type(optionValue) == int or type(optionValue) == float:
+            isValueEqual = True if float(optionValue) == float(valueText) else False
         else:
-            printLog(u"检测option:%s 选中value:%s的值失败！" % (str(option), str(value)))
-        # 返回结果;
-        return result
+            isValueEqual = valueFocus
 
-    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)
+        # 因为只是查看值,没有设置值,所以需要再手动返回一层。
+        opa.back2ParentNode(False)
 
-        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
+        # 返回主页;
+        self.__back2Home(opa)
+
+        # 聚焦状态就是结果;
+        self.info(u"checkOptionValue结果：optionValue=%s, ocrValue=%s, 结果=%d" % (str(optionValue), str(valueText), isValueEqual))
+        return isValueEqual
 
-    
-    # 对外接口：信源设置接口;  先切换再识别
     '''
-    不允许切换信源，在MenuTree.ini文件中配置：source={"offset":20,"minPeri":0,"maxPeri":0,"minArea":0,"maxArea":0,"enable":0}。
-    enable没有，默认值enable=1；enable=0，表示不允许切换信源，仅判断是否为目标信源。
+    函数：进入指定的option，并且不返回主页。
+    参数：
+        optionName          指定要进入的option节点。
+    返回：Boolean。成功进入返回True.
     '''
+    def openOption(self, optionName):
+        self.info(u"【%s】" % optionName)
+        CTMenu.sourceInput.setPattern(11)
+        opa = COptionAction(optionName, None, self.__optionConfig, self.__optionExcel)
 
-    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))
+        if self.__focusOption(opa) is False:
             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
+        # 到达目标option后;
+        self.info(u"进入option")
+        opa.enterNode()
 
-                    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 <<<<"
+        # 聚焦状态就是结果;
+        self.info(u"成功open指定option" % optionName)
         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)))
+    '''
+    函数：聚焦到指定option的value上，不设置不打开不返回。
+    参数：
+        optionName
+        optionValue
+    返回：
+    '''
+    def focusOptionValue(self, optionName, optionValue):
+        self.info(u"【%s】【%s】" % (optionName, optionValue))
+        CTMenu.sourceInput.setPattern(11)
+        opa = COptionAction(optionName, optionValue, self.__optionConfig, self.__optionExcel)
 
-        checkRunOptionPathResult = self.uitPathManage.checkRunOptionPath(path_params)
-        if str(checkRunOptionPathResult) == "NoExit":
-            printLog(u"表格中不存在到达Option:   %s   的路径,在表格中排查到达该Option路径" % str(option))
+        # 进入节点;
+        if self.__openOption(opa) is False:
             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)))
+        # 遍历到value节点中;
+        if self.__move2TargetNode(opa, True)[0] is False:
+            if self.__move2TargetNode(opa, False)[0] is False:
+                self.__back2Home(opa)
                 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))
+    '''
+    函数：获取当前option节点的value值。
+    参数：
+        optionName      要获取值的option;
+    返回：Boolean, str/int/float
+    '''
+    def getOptionValue(self, optionName):
+        self.info(u"【%s】" % optionName)
+        CTMenu.sourceInput.setPattern(11)
+        opa = COptionAction(optionName, None, self.__optionConfig, self.__optionExcel)
 
-        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))
+        # 检测路径是否有效;
+        if self.__openOption(opa) is False:
             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)
+        # 获取value节点值;
+        valueFocus, valueText = opa.isOnTargetNode()
+        self.info(u"===当前捕获的文本内容=%s，状态：%d===" % (str(valueText), valueFocus))
 
-            printLog("openOption=level:", path_params[level])
-            # 是否进入根结点;
-            if entry == False:
-                # 标记已进入根;
-                entry = True
-                first_parent = path_params[level]["parent"]
+        # 因为只是查看值,没有设置值,所以需要再手动返回一层。
+        opa.back2ParentNode(False)
 
-            # 由于已经到达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
+        # 返回主页;
+        self.__back2Home(opa)
 
-                move_key = path_params[level]["move_key"]
+        return valueFocus, valueText
 
-                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)
+    def focusOption(self, optionName):
+        self.info(u"【%s】" % optionName)
+        CTMenu.sourceInput.setPattern(11)
+        opa = COptionAction(optionName, None, self.__optionConfig, self.__optionExcel)
 
-                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
+        return self.__focusOption(opa)
 
-    # 找到两个字符串左边或者右边相同的部分
-    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
+    ml = CTMenu()
+    if 1:
+        ml.setOptionValue('picture_preset', 'personal')
+        time.sleep(2)
+        ml.setOptionValue('picture_preset', 'dynamic')
+        time.sleep(2)
+        ml.setOptionValue('picture_preset', 'stadium')
+        time.sleep(2)
+        ml.setOptionValue('picture_preset', 'standard')
+        time.sleep(2)
+        ml.setOptionValue('picture_preset', 'natural')
+        time.sleep(2)
+        ml.setOptionValue('picture_preset', 'movie')
+
+    if 0:
+        value = random.randint(0, 100)
+        ml.setOptionValue('backlight', value)
+        time.sleep(8)
+        ml.checkOptionValue('backlight', value + 10)
+        time.sleep(8)
+        ml.checkOptionValue('backlight', value)
+        time.sleep(8)
+        ml.checkOptionValue('backlight', value+20)
+
+        # time.sleep(2)
+        # ml.setOptionValue('brightness', value)
+        # time.sleep(2)
+        # ml.setOptionValue('contrast', value)
+        # time.sleep(2)
+        # ml.setOptionValue('saturation', value)
+        # time.sleep(2)
+        # ml.setOptionValue('tint', value)
+        # time.sleep(2)
+        # ml.setOptionValue('sharpness', value)
+
+    if 0:
+        ml.setOptionValue('picture_preset', 'stadium')
+        time.sleep(5)
+        print "personal", ml.checkOptionValue('picture_preset', 'personal')
+        time.sleep(8)
+        print "dynamic", ml.checkOptionValue('picture_preset', 'dynamic')
+        time.sleep(8)
+        print "stadium", ml.checkOptionValue('picture_preset', 'stadium')
+        time.sleep(8)
+        print "standard", ml.checkOptionValue('picture_preset', 'standard')
+        time.sleep(8)
+        print "natural", ml.checkOptionValue('picture_preset', 'natural')
+        time.sleep(8)
+        print "movie", ml.checkOptionValue('picture_preset', 'movie')