HYTOS

    '''

        @brief      Get Detecting Target Symbol List (Field 'isExceptDetect' == False(0))

        @author     Jeongwoo

        @date       18.04.24

        @history    humkyung 2018.06.28 select symbol order by threshold descending

    '''

            sql = """SELECT a.UID,a.Name,b.Type,a.Threshold,a.MinMatchPoint,a.IsDetectOrigin,a.RotationCount,a.OCROption,a.IsContainChild,a.OriginalPoint,a.ConnectionPoint,

                    a.BaseSymbol,a.AdditionalSymbol,a.IsExceptDetect,a.HasInstrumentLabel,a.flip,a.TextArea,\

                        b.UID FROM Symbol a inner join SymbolType b on a.SymbolType_UID=b.UID WHERE 

                        a.IsExceptDetect = 0 order by width * height desc"""

                    # detect equipments

                    pool = futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER)

                    for symbol in targetSymbolList[0]:

                        pool.submit(Worker.detectEquipmentOnPid, mainRes, symbol, listWidget, worker)

                    pool.shutdown(wait=True)

                    #pool = futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER)

                        #pool.submit(Worker.remove_detected_symbol_image, sym, app_doc_data.imgSrc)

                    #pool.shutdown(wait=True)

                    #cv2.imwrite('c:\\temp\\imgSrc.png', area.img)

                Worker.drawFoundSymbolsOnCanvas(mainRes, textInfoList, listWidget)

                area = AppDocData.instance().getArea('Drawing')

                if area is not None:

                    area.img = app_doc_data.imgSrc[round(area.y + 1):round(area.y + area.height),

                               round(area.x + 1):round(area.x + area.width)]

                cv2.imwrite(os.path.join(project.getTempPath(), "RECT_" + os.path.basename(mainRes)),

                            app_doc_data.imgSrc)

                # get difference between original and recognized image

                foundFilePath = os.path.join(project.getTempPath(), "FOUND_" + os.path.basename(mainRes))

                Worker.getDifference(mainRes, foundFilePath)

                # up to here

    def detectEquipmentOnPid(mainRes, targetSymbol, listWidget, worker):

            equipments = Worker.detectSymbolOnPid(mainRes, targetSymbol, listWidget, worker)

                # detect nozzles around equimpent

                for nozzle in targetSymbolList[1]:

                    Worker.detectNozzleOnPid(equipment, nozzle, listWidget, worker)

                # up to here

    '''

        @brief      detect nozzlez

        @author     humkyung

        @date       2018.07.07

        @history    humkyhung 2018.07.17 pass equpment as parameter instead of image

    '''

    @staticmethod

    def detectNozzleOnPid(equipment, nozzle, listWidget, worker):

        global src

        global threadLock

        global maxProgressValue

        try:

            symbolName = nozzle.getName()

            symbolType = nozzle.getType()

            symbolPath = nozzle.getPath()

            symbolThreshold = nozzle.getThreshold()

            symbolMinMatchCount = nozzle.getMinMatchCount()

            isDetectOnOrigin = nozzle.getIsDetectOnOrigin()

            symbolRotateCount = nozzle.getRotationCount()

            symbolOcrOption = nozzle.getOcrOption()

            isContainChild = nozzle.getIsContainChild()

            symbolOriginalPoint = nozzle.getOriginalPoint()

            symbolConnectionPoint = nozzle.getConnectionPoint()

            baseSymbol = nozzle.getBaseSymbol()

            additionalSymbol = nozzle.getAdditionalSymbol()

            isExceptDetect = nozzle.getIsExceptDetect()

            text_area = text_area

            foundSymbolCount = 0

            # check if symbol file exists

            if not os.path.isfile(symbolPath):

                item = QListWidgetItem('{} file not found'.format(os.path.split(os.path.basename(symbolPath))[0]))

                item.setBackground(QColor('red'))

                listWidget.addItem(item)

                return

            # up to here

            symGray = Worker.cvtGrayImage(cv2.imread(symbolPath, 1))

            sow, soh = symGray.shape[::-1]  # symbol original w, h

            # get image of equipment with offset of nozzle size

            appDocData = AppDocData.instance()

            pt = equipment.getSp()

            nozzleSize = max(sow, soh)

            sx = round(pt[0]) - nozzleSize

            sy = round(pt[1]) - nozzleSize

            ex = round(pt[0] + equipment.getWidth()) + nozzleSize

            ey = round(pt[1] + equipment.getHeight()) + nozzleSize

            offset = (sx, sy)

            eqpSize = (pt[0], pt[1], equipment.getWidth(), equipment.getHeight())

            img = appDocData.imgSrc[sy:ey, sx:ex]

            srcWidth, srcHeight = img.shape[::-1]

            # up to here

            roiItemSp = (0, 0)

            roiItemEp = (srcWidth, srcHeight)

            roiItem = img

            symbolAngle = 0

            for rc in range(symbolRotateCount + 1):  # Rotation Count를 사용자 기준으로 받아서 1을 더한 후 사용

                sw, sh = symGray.shape[::-1]

                roiw = (roiItemEp[0] - roiItemSp[0])

                roih = (roiItemEp[1] - roiItemSp[1])

                # get Rotated Original Point

                originalPoint = Worker.getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint, symbolAngle,

                                                                  sw, sh, sow, soh)

                connectionPoint = Worker.getCalculatedConnectionPoint(symbolConnectionPoint, symbolAngle, sw, sh, sow,

                                                                      soh)

                dx = connectionPoint[0][0] - originalPoint[0]

                dy = connectionPoint[0][1] - originalPoint[1]

                # Template Matching

                tmRes = cv2.matchTemplate(roiItem, symGray, cv2.TM_CCOEFF_NORMED)

                loc = np.where(tmRes >= symbolThreshold)

                for pt in zip(*loc[::-1]):

                    mpCount = 0  # Match Point Count

                    symbolIndex = -1

                    roi = roiItem[pt[1]:pt[1] + sh, pt[0]:pt[0] + sw]

                    if symbolMinMatchCount > 0:

                        mpCount = Worker.getMatchPointCount(roi, symGray)

                        if not (mpCount >= symbolMinMatchCount):

                            continue

                    mid = (offset[0] + pt[0] + (originalPoint[0] + connectionPoint[0][0]) * 0.5,

                           offset[1] + pt[1] + (originalPoint[1] + connectionPoint[0][1]) * 0.5)

                    searchedItemSp = (roiItemSp[0] + pt[0] + offset[0], roiItemSp[1] + pt[1] + offset[1])

                    # check searched nozzle location

                    if abs(dx) > abs(dy):

                        if dx > 0:

                            if mid[0] < eqpSize[0] + eqpSize[2] * 0.5: continue

                        else:

                            if mid[0] > eqpSize[0] + eqpSize[2] * 0.5: continue

                    else:

                        if dy > 0:

                            if mid[1] < eqpSize[1] + eqpSize[3] * 0.5: continue

                        else:

                            if mid[1] > eqpSize[1] + eqpSize[3] * 0.5: continue

                    # up to here

                    overlapArea = 0

                    nozzles = [symbol for symbol in searchedSymbolList if symbol.getType() == 'Nozzles']

                    for i in range(len(nozzles)):

                        _pt = nozzles[i].getSp()

                        rect = QRectF(_pt[0], _pt[1], nozzles[i].getWidth(), nozzles[i].getHeight())

                        _rect = QRectF(searchedItemSp[0], searchedItemSp[1], sw, sh)

                        if rect.intersects(_rect):

                            intersect = rect.intersected(_rect)

                            overlapArea = intersect.width() * intersect.height()

                            if overlapArea > ACCEPT_OVERLAY_AREA:

                                symbolIndex = i

                                break

                    hitRate = tmRes[pt[1], pt[0]]

                    ## 겹치는 영역이 기준값보다 작을 경우

                    if overlapArea <= ACCEPT_OVERLAY_AREA:

                        threadLock.acquire()

                        foundSymbolCount = foundSymbolCount + 1

                        searched = Worker.addSearchedSymbol(symbolName, symbolType

                                                            , searchedItemSp, sw, sh, symbolThreshold,

                                                            symbolMinMatchCount, hitRate, symbolAngle

                                                            , isDetectOnOrigin, symbolRotateCount, symbolOcrOption,

                                                            isContainChild

                                                            , originalPoint, connectionPoint, baseSymbol,

                                                            additionalSymbol, isExceptDetect, text_area)

                        searched.owner = equipment

                        threadLock.release()

                    ## 겹치는 영역이 기준값보다 클 경우

                    else:

                        if symbolIndex != -1 and symbolIndex < len(nozzles):

                            searchedSymbol = nozzles[symbolIndex]

                            ## 현재 심볼과 검출된 심볼이 같을 경우 Match Point가 더 높은 정보로 교체

                            if symbolName == searchedSymbol.getName():

                                symbolHitRate = searchedSymbol.getHitRate()

                                if symbolHitRate < hitRate:

                                    threadLock.acquire()

                                    nozzles[symbolIndex] = symbol.Symbol(symbolName, symbolType,

                                                                         searchedItemSp, sw, sh, symbolThreshold,

                                                                         symbolMinMatchCount, hitRate, symbolAngle,

                                                                         isDetectOnOrigin, symbolRotateCount,

                                                                         symbolOcrOption, isContainChild,

                                                                         ','.join(str(x) for x in originalPoint),

                                                                         '/'.join(

                                                                             '{},{},{},{}'.format(param[0], param[1],

                                                                                                  param[2], param[3])

                                                                             for param in connectionPoint),

                                                                         baseSymbol, additionalSymbol, isExceptDetect, text_area)

                                    threadLock.release()

                            ## 현재 심볼과 검출된 심볼이 같지 않을 경우 (포함)

                            elif appDocData.isEquipmentType(searchedSymbol.getType()):

                                threadLock.acquire()

                                foundSymbolCount = foundSymbolCount + 1

                                searched = Worker.addSearchedSymbol(symbolName, symbolType

                                                                    , searchedItemSp, sw, sh, symbolThreshold, hitRate,

                                                                    hitRate, symbolAngle

                                                                    , isDetectOnOrigin, symbolRotateCount,

                                                                    symbolOcrOption, isContainChild

                                                                    , originalPoint, connectionPoint, baseSymbol,

                                                                    additionalSymbol, isExceptDetect, text_area)

                                searched.owner = equipment

                                threadLock.release()

                ## Rotate Symbol

                symGray = cv2.rotate(symGray, cv2.ROTATE_90_COUNTERCLOCKWISE)

                symbolAngle = symbolAngle + 90

                if additionalSymbol is not None:

                    additionalSymbol = Worker.getRotatedChildInfo(additionalSymbol)

            threadLock.acquire()

            listWidget.addItem('Found Symbol   : ' + os.path.splitext(os.path.basename(symbolPath))[0] + ' - (' + str(

                foundSymbolCount) + ')')

            threadLock.release()

            worker.updateProgress.emit(maxProgressValue, symbolPath)

            return [symbol for symbol in searchedSymbolList if symbol.getName() == symbolName]

        except Exception as ex:

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            worker.displayLog(MessageType.Error, message)

        return []

                Worker.detectSymbolOnPid(mainRes, detailTarget, listWidget, updateProgressSignal)

            Worker.detectSymbolOnPid(mainRes, targetSymbols, listWidget, updateProgressSignal)

    '''

        @brief  draw found symbols and texts

        @author Jeongwoo

    '''

    def drawFoundSymbolsOnCanvas(drawingPath, textInfos, listWidget):

        appDocData = AppDocData.instance()

        canvas = np.zeros(appDocData.imgSrc.shape, np.uint8)

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            for symbol in searchedSymbolList:

                canvas[top:bottom, left:right] = appDocData.imgSrc[top:bottom, left:right]

            appDocData = AppDocData.instance()

                configs = appDocData.getConfigs('Filter', 'DilateSize')

                configs = appDocData.getConfigs('{} Equipment Desc Area'.format(appDocData.imgName))

                configs = appDocData.getConfigs('{} Typical Area'.format(appDocData.imgName))

                noteArea = appDocData.getArea('Note')

                    noteArea.img = appDocData.imgSrc[round(noteArea.y):round(noteArea.y + noteArea.height),

                area = AppDocData.instance().getArea('Drawing')

                appDocData = AppDocData.instance()

                project = appDocData.getCurrentProject()