fixed

components/image_framework.py

@@ -10,7 +10,7 @@ import time
 import cv2
 
 from core.edge_component import action, EdgeComponent, service
-from util import get_system_and_library_suffix
+from util import get_system_and_library_suffix,imgProcess
 
 
 # 给回调函数使用
@@ -137,7 +137,7 @@ g_frame_cache = []
 RUNNING_MODE_NONE = -1 # 停止状态
 RUNNING_MODE_LOCATION = 0 # 广角相机运行模式
 RUNNING_MODE_DETECTION = 1 # 高清检测运行模式
-g_running_mode = RUNNING_MODE_LOCATION # 默认是广角相机运行模式
+g_running_mode = RUNNING_MODE_NONE # 默认是广角相机运行模式
 
 #################################################################################### 
 #                                   内部接口定义
@@ -146,9 +146,10 @@ g_running_mode = RUNNING_MODE_LOCATION # 默认是广角相机运行模式
 def _get_msg_info(code) -> str: 
     global MSG_LIST
     for msg in MSG_LIST:
-        if code == msg.keys()[0]:
+        for key, value in msg.items():
-            return msg.values
+            if code == key:
-    return "未知错误"
+                return value.encode("utf-8")
+    return "未知错误".encode("utf-8")
 
 # 加工检测图像
 def _update_location_image(frame):
@@ -169,6 +170,7 @@ def _copy_record(record):
     new_record.code = record.code
     new_record.errorInfo = record.errorInfo
     new_record.bGetData = record.bGetData
+    new_record.roi_size = record.roi_size
     for i in range(record.roi_size):
         subRois = record.subRois[i]
         newSubRois = new_record.subRois[i]
@@ -196,6 +198,7 @@ class ImageFramework(EdgeComponent):
         self.data_callback = None
         self.location_thread = None
         self.process_thread = None
+        self.times = 0
 
     def configure(self, setting: Settings) -> None:
         self.init_image_framework_sdk()
@@ -204,6 +207,9 @@ class ImageFramework(EdgeComponent):
         self.process_thread = threading.Thread(target=self._main_processing_thread)
         self.process_thread.daemon = True
 
+        self.location_thread.start()
+        self.process_thread.start()
+
         self.logger.info(f"Image framework configure done.")
 
     def init_image_framework_sdk(self):
@@ -224,31 +230,43 @@ class ImageFramework(EdgeComponent):
             record = CallbackInfo(code=SYS_OK, errorInfo=b"", bGetData=False)
             frame = None
             ret = SYS_OK
-            record.code = data.contents.code
+            msg = None
-            record.errorInfo = data.contents.errorInfo
+
+            # 获取数据
+            data_type = CallbackInfo
+            data_ptr = cast(data, POINTER(data_type)) 
+            ckinfoCache = data_ptr.contents
+            record = _copy_record(ckinfoCache)
+            print(str(g_running_mode) + " : " + str(record.code) + " : " + bytes.decode(record.errorInfo))
             # 当定位模式下，接收到【定位完成】消息
             if g_running_mode == RUNNING_MODE_LOCATION and record.code == (6 + TO_CLIENT_NOTIFY_BASE):
                 if len(g_frame_cache) == 0:
                     self.logger.error("当前没有广角数据")
                     return
-
                 frame = g_frame_cache.pop()  # 从图像缓存中去除图像
                 g_frame_cache = []  # 清空缓存，避免无限增长
                 msg = Msg(MSG_LOCATION_RECORD, _copy_record(record), frame)
             # 当检测模式下，接收到【拍照完成】消息
-            elif g_running_mode == RUNNING_MODE_DETECTION and record.code == (2 + TO_CLIENT_NOTIFY_BASE):
+            elif (g_running_mode == RUNNING_MODE_DETECTION and record.code == (8 + TO_CLIENT_NOTIFY_BASE)) or\
-                frame.zeros(9344, 7000, cv2.CV_8UC3)
+                (g_running_mode == RUNNING_MODE_DETECTION and record.code == (12 + TO_CLIENT_NOTIFY_BASE)):
-                src_frame_ptr = c_char_p(frame.data.tobytes())
+                frame = np.zeros((7000, 9344, 3), np.uint8)
+                # frame.zeros(9344, 7000, cv2.CV_8UC3)
+                # src_frame_ptr = c_char_p(frame.data.tobytes())
+                mv = memoryview(frame.data)
+                buffer_pointer = cast(mv.obj.ctypes.data, c_void_p)
                 ret = self.image_framework_sdk.LibapiGetHQImage(
-                    src_frame_ptr, frame.shape[1], frame.shape[0], 3, c_char_p(b"PythonProcessing"))
+                    buffer_pointer, frame.shape[1], frame.shape[0], 3, c_char_p(b"PythonProcessing"))
                 if ret != SYS_OK:
                     record = CallbackInfo(code=ret, errorInfo=_get_msg_info(ret), bGetData=False)
-                    msg = Msg(MSG_ONLY_RECORD, record, None)
+                    msg = Msg(MSG_DETECTION_RECORD, record, None)
+                    g_msg_cache.append(msg)
                     # emit msg
                     return
                 msg = Msg(MSG_DETECTION_RECORD, _copy_record(record), frame)
-            elif g_running_mode == RUNNING_MODE_LOCATION or g_running_mode == RUNNING_MODE_DETECTION:
+            elif g_running_mode == RUNNING_MODE_LOCATION:
-                msg = Msg(MSG_ONLY_RECORD, _copy_record(record), None)
+                msg = Msg(MSG_LOCATION_RECORD, _copy_record(record), None)
+            elif g_running_mode == RUNNING_MODE_DETECTION:
+                msg = Msg(MSG_DETECTION_RECORD, _copy_record(record), None)
             else:
                 print("未知回调")
                 return
@@ -266,6 +284,7 @@ class ImageFramework(EdgeComponent):
 
         ret = self.image_framework_sdk.LibapiInit(1, "", self.data_callback)
         if ret != 0:
+            self.logger.info("============================》" + str(ret))
             raise RuntimeError("Image framework 初始化失败!")
 
         self.logger.info("Image framework started.")
@@ -282,39 +301,70 @@ class ImageFramework(EdgeComponent):
 
     @service()
     def start_location(self):
-        self.location_thread.start()
+        global g_running_mode
-        self.process_thread.start()
+        self.logger.info("start_location")
+        if g_running_mode != RUNNING_MODE_LOCATION: 
+            g_running_mode = RUNNING_MODE_LOCATION # 切换为定位模式
 
     @service()
-    def start_detect(self):
+    def stop_all(self):
         global g_running_mode
-        if g_running_mode != RUNNING_MODE_DETECTION:
+        if g_running_mode != RUNNING_MODE_NONE: 
-            g_running_mode = RUNNING_MODE_DETECTION  # 切换为检测模式
+            g_running_mode = RUNNING_MODE_NONE # 切换为静默模式
 
+    @service()
+    def start_adjust(self):
+        global g_running_mode
+        record = CallbackInfo(code=SYS_OK, errorInfo=b"", bGetData=False)
+        if g_running_mode != RUNNING_MODE_DETECTION: 
+            g_running_mode = RUNNING_MODE_DETECTION # 切换为检测模式
+        else: 
+            record.code = -10001
+            record.errorInfo = _get_msg_info(-10001)
+            return record
         ret = self.image_framework_sdk.LibapiStartDetection()
-        if ret != 0:
+        if ret != SYS_OK:
-            raise RuntimeError("启动检测失败!")
+            record = CallbackInfo()
+            record.code = ret
+            record.errorInfo = _get_msg_info(ret)
+            return record
+        return record
 
     @service()
-    def continue_detect(self):
+    def start_check(self):
-        ret = self.image_framework_sdk.LibapiContinuetDetection()
-        if ret != 0:
-            raise RuntimeError("继续检测失败!")
-
-    @service()
-    def stop_detect(self):
         global g_running_mode
-        if g_running_mode == RUNNING_MODE_LOCATION:  # 如果在定位任务模式下，该接口不执行
+        record = CallbackInfo(code=SYS_OK, errorInfo=b"", bGetData=False)
-            raise RuntimeError("正在检测，请稍后停止!")
+        if g_running_mode == RUNNING_MODE_LOCATION: # 如果在定位任务模式下，该接口不执行
+            record.code = -10002
+            record.errorInfo = _get_msg_info( -10002)
+            return MSG_DETECTION_RECORD
+        ret = self.image_framework_sdk.LibapiContinuetDetection()
+        if ret != SYS_OK:
+            record.code = ret
+            record.errorInfo = _get_msg_info(ret)
+            return record
+        return record
 
-        g_running_mode = RUNNING_MODE_NONE  # 切换为无模式
+    @service()
-        ret = self.image_framework_sdk.LibapStopDetection()
+    def stop_check(self):
-        if ret != 0:
+        global g_running_mode
-            raise RuntimeError("停止检测失败!")
+        record = CallbackInfo(code=SYS_OK, errorInfo=b"", bGetData=False)
+        if g_running_mode == RUNNING_MODE_LOCATION: # 如果在定位任务模式下，该接口不执行
+            record.code = -10002
+            record.errorInfo = _get_msg_info(-10002)
+            return record
+        ret = self.image_framework_sdk.LibapiStopDetection()
+        if ret != SYS_OK:
+            record.code = ret
+            record.errorInfo = _get_msg_info(ret)
+            return record
+        g_running_mode = RUNNING_MODE_NONE # 切换为无模式
+        return record
 
     # 广角相机运行定位处理线程
     def _location_processing_thread(self):
         global g_msg_cache, g_frame_cache, g_running_mode
+        record = CallbackInfo(code=SYS_OK, errorInfo=b"", bGetData=False)
         # 打开广角摄像头
         capture = cv2.VideoCapture(0)
         while True:
@@ -330,20 +380,27 @@ class ImageFramework(EdgeComponent):
                 self.logger.error("[ERROR] 广角相机未捕获到图像")
                 continue
 
-            src_frame_ptr = c_char_p(frame.data.tobytes())
+            if self.times % 3 == 0:
-            ret = self.image_framework_sdk.LibapiCameraSendMsgWithImage(
+                src_frame_ptr = c_char_p(frame.data.tobytes())
-                src_frame_ptr, frame.shape[1], frame.shape[0], 3,
+                ret = self.image_framework_sdk.LibapiCameraSendMsgWithImage(
-                c_char_p(b"PythonProcessing"), c_char_p(b"_t_PluginCameraPro"))
+                    src_frame_ptr, frame.shape[1], frame.shape[0], 3,
-            if ret != SYS_OK:
+                    c_char_p(b"PythonProcessing"), c_char_p(b"_t_PluginCameraPro"))
-                self.logger.error(_get_msg_info(ret))
+                if ret != SYS_OK:
-                # emit msg
+                    record = CallbackInfo(code=ret, errorInfo=_get_msg_info(ret), bGetData=False)
-                continue
+                    msg = Msg(MSG_ONLY_RECORD, record, None)
-            # 向 g_frame_cache 中加入消息，对图像进行二次加工
+                    self.logger.error(_get_msg_info(ret))
-            g_frame_cache.append(frame)
+                    # emit msg
+                    continue
+                # 向 g_frame_cache 中加入消息，对图像进行二次加工
+                g_frame_cache.append(frame)
+            self.times += 1
+            if self.times == 999:
+                self.times = 0
 
     # 高清相机运行检测处理线程
     def _main_processing_thread(self):
-        global g_msg_cache, g_frame_cache, g_running_mode
+        global g_msg_cache, g_running_mode
+        record = CallbackInfo(code=SYS_OK, errorInfo=b"", bGetData=False)
 
         while True:
             if len(g_msg_cache) <= 0:
@@ -351,7 +408,6 @@ class ImageFramework(EdgeComponent):
                 continue
 
             msg = g_msg_cache.pop()
-            if msg.msg_type == MSG_LOCATION_RECORD:
+            msg = imgProcess.process(msg)
-                # cv2.imshow("LOCATION", msg.im2D)
+            self.logger.info("msg ==> ui")
-                # cv2.waitKey(1)
+            self.signals.on_image_detect_result.emit(msg)
-                self.signals.on_image_detect_result.emit(msg)

main.py

@@ -1,11 +1,11 @@
 import asyncio
 import sys
 
-from PyQt5.QtCore import Qt, QDate, QThread
+from PyQt5.QtCore import Qt, QDate, QThread, QSize
 from PyQt5.QtGui import QPixmap, QFontDatabase, QFont, QPainter, \
-    QLinearGradient, QColor
+    QLinearGradient, QColor, QIcon
 from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QHBoxLayout, QVBoxLayout, QLabel, QStackedWidget, \
-    QFrame, QSpacerItem, QSizePolicy, QProgressBar
+    QFrame, QSpacerItem, QSizePolicy, QProgressBar, QRadioButton, QPushButton
 
 from core.edge_context import EdgeContext
 from core.logging import logger
@@ -29,7 +29,7 @@ class DetectWindow(QMainWindow):
         # 创建主窗口的中央Widget
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
-        # self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint)  # 去掉窗口边框
+        self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint)  # 去掉窗口边框
 
         # 创建主布局
         main_layout = QVBoxLayout(central_widget)
@@ -66,6 +66,17 @@ class DetectWindow(QMainWindow):
         self.date_label.setStyleSheet(f"color: #898AC5;font-size: {int(self.ratio * 14)}px;")
         header_right_layout.addWidget(self.date_label)
         header_right_layout.addSpacing(int(self.ratio * 10))
+
+        # 雷达
+        self.radar = QPushButton()
+        self.radar.setObjectName("radar-open")
+        self.radar.setIcon(QIcon("assets/radar-fill-red.png"))
+        self.radar.setIconSize(QSize(36, 36))
+        self.radar.setStyleSheet("background-color: rgb(255, 255, 255, 0);")
+        self.radar.clicked.connect(self.radar_clicked)
+        header_right_layout.addWidget(self.radar)
+        header_left_layout.addSpacing(int(self.ratio * 10))
+
         # 充电图标
         self.chargeIcon = QLabel(self)
         self.chargeIcon.setPixmap(QPixmap("assets/icon_charge_finish.png").scaled(36, 36))
@@ -107,6 +118,18 @@ class DetectWindow(QMainWindow):
         ups = AppContext.get_edge_context().get_component('ups')
         ups.signals.battery_change.connect(self.battery_change)
         ups.signals.state_change.connect(self.battery_state_change)
+
+    def radar_clicked(self):
+        gpio_manager = AppContext.get_edge_context().get_component('gpio')
+        if gpio_manager.lidar_value == -1:
+            return
+        elif gpio_manager.lidar_value == 0:
+            gpio_manager.close_lidar()
+            self.radar.setIcon(QIcon("assets/radar-fill-red.png"))
+        else:
+            gpio_manager.open_lidar()
+            self.radar.setIcon(QIcon("assets/radar-fill-green.png"))
+
     #
     def battery_change(self, battery):
         """更新电池电量"""
@@ -174,6 +197,7 @@ if __name__ == '__main__':
     edge_worker.start()
 
     window = DetectWindow()
+    window.setGeometry(0, 0, 1920, 1080)
     window.show()
 
     sys.exit(app.exec_())

styles/global.qss

@@ -162,7 +162,7 @@ EmbedItem QPushButton#STD {
 
 QWidget#checkWidget,
 QWidget#viewCheckWidget {
-    border: 1px dashed #6cff6c;
+    border: 0px dashed #6cff6c;
 }
 
 QWidget#legendCheckWidget {

util/imgProcess.py

@@ -1,3 +1,4 @@
+# -- coding: utf-8 --
 import os
 import threading
 from ctypes import *
@@ -8,7 +9,106 @@ from numpy.ctypeslib import as_array
 import platform
 import time
 import cv2
-import imgProcess
+
+TO_CLIENT_NOTIFY_BASE = 1000
 
 def process(msg):
+    record = msg.record
+    if record.code == (6 + TO_CLIENT_NOTIFY_BASE):
+        return doLocationProcessing(msg)
+    elif record.code == (2 + TO_CLIENT_NOTIFY_BASE) or record.code == (12 + TO_CLIENT_NOTIFY_BASE):
+        return doDetectionProcessing(msg)
+    else : pass
+    return msg
+
+# 处理图像
+def doLocationProcessing(msg):
+    if msg is None:
+        return msg
+    
+    im = msg.im2D
+    record = msg.record
+    print("-------------------- record.roi_size" + str(record.roi_size))
+    ptsRoiPoints = None
+    ptsInnerConners = None
+    ptsInnerConners3D = None
+    for i in range(record.roi_size):
+        roi = record.subRois[i]
+        roiPoints = roi.mRoiPoints
+        innerConners = roi.mInnerConners
+        innerConners3D = roi.mInnerConners3D
+        ptsRoiPoints = np.array([
+            [roiPoints[0],roiPoints[1]],
+            [roiPoints[2],roiPoints[3]],
+            [roiPoints[4],roiPoints[5]],
+            [roiPoints[6],roiPoints[7]]], dtype=np.int32)
+        
+        ptsInnerConners = np.array([
+            [innerConners[0],innerConners[1]],
+            [innerConners[2],innerConners[3]],
+            [innerConners[4],innerConners[5]],
+            [innerConners[6],innerConners[7]]], dtype=np.int32)
+        
+        ptsInnerConners3D = np.array([
+            [innerConners3D[0],innerConners3D[1],innerConners3D[2]],
+            [innerConners3D[3],innerConners3D[4],innerConners3D[5]],
+            [innerConners3D[6],innerConners3D[7],innerConners3D[8]],
+            [innerConners3D[9],innerConners3D[10],innerConners3D[11]]])
+        
+        cv2.polylines(im, [ptsRoiPoints], True, (0,255,0) , 2)
+        cv2.polylines(im, [ptsInnerConners], True, (0,255,0) , 2)
+        # for i in range(4):
+        #     ptsRoiPoints[i][0] = int(ptsRoiPoints[i][0] / 16)
+        #     ptsRoiPoints[i][1] = int(ptsRoiPoints[i][1] / 16)
+        #     ptsInnerConners[i][0]= int(ptsInnerConners[i][0] / 16)
+        #     ptsInnerConners[i][1] = int(ptsInnerConners[i][1] / 16)
+
+    # cv2.polylines(im, [ptsRoiPoints], True, (0,255,0) , 2)
+    # cv2.polylines(im, [ptsInnerConners], True, (0,255,0) , 2)
+    # cv2.imshow("HQImage", msg.im2D)
+    # cv2.waitKey(1)
+    return msg
+
+def doDetectionProcessing(msg):
+    if msg is None:
+        return msg
+    if msg.im2D is not None:
+        im = cv2.resize(msg.im2D, (int(msg.im2D.shape[1]/16), int(msg.im2D.shape[0]/16)))
+        record = msg.record
+        ptsRoiPoints = None
+        ptsInnerConners = None
+        ptsInnerConners3D = None
+        for i in range(record.roi_size):
+            roi = record.subRois[i]
+            roiPoints = roi.mRoiPoints
+            innerConners = roi.mInnerConners
+            innerConners3D = roi.mInnerConners3D
+            ptsRoiPoints = np.array([
+                [roiPoints[0],roiPoints[1]],
+                [roiPoints[2],roiPoints[3]],
+                [roiPoints[4],roiPoints[5]],
+                [roiPoints[6],roiPoints[7]]], dtype=np.int32)
+            
+            ptsInnerConners = np.array([
+                [innerConners[0],innerConners[1]],
+                [innerConners[2],innerConners[3]],
+                [innerConners[4],innerConners[5]],
+                [innerConners[6],innerConners[7]]], dtype=np.int32)
+            
+            ptsInnerConners3D = np.array([
+                [innerConners3D[0],innerConners3D[1],innerConners3D[2]],
+                [innerConners3D[3],innerConners3D[4],innerConners3D[5]],
+                [innerConners3D[6],innerConners3D[7],innerConners3D[8]],
+                [innerConners3D[9],innerConners3D[10],innerConners3D[11]]])
+            
+            for i in range(4):
+                ptsRoiPoints[i][0] = int(ptsRoiPoints[i][0] / 16)
+                ptsRoiPoints[i][1] = int(ptsRoiPoints[i][1] / 16)
+                ptsInnerConners[i][0]= int(ptsInnerConners[i][0] / 16)
+                ptsInnerConners[i][1] = int(ptsInnerConners[i][1] / 16)
+
+        cv2.polylines(im, [ptsRoiPoints], True, (0,255,0) , 2)
+        cv2.polylines(im, [ptsInnerConners], True, (0,255,0) , 2)
+        # cv2.imshow("HQImage", im)
+        # cv2.waitKey(1)
     return msg

widget/task_run.py

@@ -25,6 +25,8 @@ class TaskRunDialog(QDialog):
         self.check_widget = None
         self.embed_widgets = []
 
+        # 广角镜头预览区
+        self.view_widget = None
         self.view_label = None
         self.picture_label = None
 
@@ -41,23 +43,29 @@ class TaskRunDialog(QDialog):
             lambda data: self.image_result(data))
 
     def image_result(self, msg):
-        if msg.msg_type == MSG_LOCATION_RECORD:
+        qt_image = None
-            if msg.im2D is None:
+        if msg.im2D is not None:
-                return
             rgb_frame = cv2.cvtColor(msg.im2D, cv2.COLOR_BGR2RGB)
-            try:
+            height, width, channels = rgb_frame.shape
-                # 转换为 QImage
+            bytes_per_line = channels * width
-                height, width, channels = rgb_frame.shape
+            qt_image = QImage(rgb_frame.data, width, height, bytes_per_line, QImage.Format_RGB888)
-                bytes_per_line = channels * width
-                qt_image = QImage(rgb_frame.data, width, height, bytes_per_line, QImage.Format_RGB888)
 
-                self.view_label.setPixmap(QPixmap.fromImage(qt_image))
+        if msg.msg_type == MSG_LOCATION_RECORD:
+            if qt_image is None:
+                return
+            try:
+                view_pixmap = QPixmap.fromImage(qt_image)
+                sc = view_pixmap.height() / 450
+                self.view_label.setFixedWidth(view_pixmap.width() / sc)
+                self.view_label.setPixmap(view_pixmap)
+                self.view_label.setGeometry((self.view_widget.width() - self.view_label.width()) / 2, 0, self.view_label.width(), self.view_label.height())
             except Exception as e:
                 dd = 0
         elif msg.msg_type == MSG_DETECTION_RECORD:
             if msg.record.code < 0:
-                self.set_button_default()
                 QMessageBox.warning(self, '错误信息', msg.record.errorInfo.decode('utf-8'))
+                self.set_button_default()
+                AppContext.get_edge_context().get_component('image-framework').start_location()
             elif msg.record.code == 1008:
                 self.start_adjust_button.setEnabled(False)
                 self.start_check_button.setEnabled(True)
@@ -67,6 +75,16 @@ class TaskRunDialog(QDialog):
                 QMessageBox.warning(self, '成功信息', "检测结束")
                 self.set_button_default()
                 AppContext.get_edge_context().get_component('image-framework').start_location()
+            else:
+                dddd = 0
+
+            if qt_image is None:
+                return
+            try:
+                view_pixmap = QPixmap.fromImage(qt_image)
+                self.picture_label.setPixmap(view_pixmap)
+            except Exception as e:
+                dd = 0
         else:
             ddd = 0
 
@@ -158,24 +176,24 @@ class TaskRunDialog(QDialog):
         self.picture_label.setFixedWidth(450)
         self.picture_label.setFixedHeight(450)
         self.picture_label.setScaledContents(True)
-        picture_pixmap = QPixmap("assets/img2.png")
+        # picture_pixmap = QPixmap("assets/img2.png")
-        self.picture_label.setPixmap(picture_pixmap)
+        # self.picture_label.setPixmap(picture_pixmap)
 
-        view_widget = QWidget()
+        self.view_widget = QWidget()
-        view_widget.setObjectName("viewWidget")
+        self.view_widget.setObjectName("viewWidget")
-        view_widget.setFixedHeight(450)
+        self.view_widget.setFixedHeight(450)
 
-        self.view_label = QLabel(view_widget)
+        self.view_label = QLabel(self.view_widget)
         self.view_label.setObjectName("viewLabel")
         self.view_label.setFixedHeight(450)
         self.view_label.setScaledContents(True)
-        view_pixmap = QPixmap("assets/img1.jpg")
+        # view_pixmap = QPixmap("assets/img1.jpg")
-        sc = view_pixmap.height() / 450
+        # sc = view_pixmap.height() / 450
-        self.view_label.setFixedWidth(view_pixmap.width() / sc)
+        # self.view_label.setFixedWidth(view_pixmap.width() / sc)
-        self.view_label.setPixmap(view_pixmap)
+        # self.view_label.setPixmap(view_pixmap)
-        self.view_label.setGeometry((view_widget.width() - self.view_label.width() / 2), 0, self.view_label.width(), self.view_label.height())
+        # self.view_label.setGeometry((view_widget.width() - self.view_label.width() / 2), 0, self.view_label.width(), self.view_label.height())
 
-        view_check_widget = QWidget(view_widget)
+        view_check_widget = QWidget(self.view_widget)
         view_check_widget.setObjectName("viewCheckWidget")
         view_check_widget.setGeometry(self.view_label.geometry().x() + 145, 170, 240, 240)
 
@@ -238,7 +256,7 @@ class TaskRunDialog(QDialog):
         content_layout = QHBoxLayout()
         content_layout.setContentsMargins(0, 0, 0, 20)
         content_layout.setSpacing(0)
-        content_layout.addWidget(view_widget)
+        content_layout.addWidget(self.view_widget)
         content_layout.addSpacing(20)
         content_layout.addWidget(self.picture_label)
         content_layout.addSpacing(20)