HYTOS

                        Worker.changeVisualLineType(app_doc_data.lines, worker)

                        #pass

    def changeVisualLineType(lines, worker):

        try:

            app_doc_data = AppDocData.instance()

            image = app_doc_data.activeDrawing.image_origin

            imgNot = np.ones(image.shape, np.uint8) * 255

            image = cv2.bitwise_xor(image, imgNot)

            #electric = [137, [1,1,1,1,1,1,1,1,1], sys.maxsize]

            #software = [187, [0.948,1.081,0.932,1.081,0.932,1.068,0.932,1.081,0.929], sys.maxsize]

            #line_patterns = {'Electric':electric, 'Software':software }

            line_patterns = {}

            line_shapes = {}

            line_names = app_doc_data.getSymbolListByType('type', 'Line')

            if len(line_names) != 0:

                for line_name in line_names:

                    line = line_name

                    line_path = line.getPath()

                    if not os.path.isfile(line_path):

                        continue

                    line_img = cv2.cvtColor(cv2.imread(line_path), cv2.COLOR_BGR2GRAY)

                    imgNot = np.ones(line_img.shape, np.uint8) * 255

                    line_img = cv2.bitwise_xor(line_img, imgNot)

                    contours, _ = cv2.findContours(line_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

                    if len(contours) < 3:

                        max_x, max_y, min_x, min_y = 0, 0, sys.maxsize, sys.maxsize

                        for rect in [cv2.boundingRect(contour) for contour in contours]:

                            if rect[0] < min_x:

                                min_x = rect[0]

                            if rect[0] + rect[2] > max_x:

                                max_x = rect[0] + rect[2]

                            if rect[1] < min_y:

                                min_y = rect[1]

                            if rect[1] + rect[3] > max_y:

                                max_y = rect[1] + rect[3]

                        line_shapes[line.getBaseSymbol()] = [line_img[min_y:max_y, min_x:max_x], sys.maxsize]

                        continue

                    i = 1 if line_img.shape[0] > line_img.shape[1] else 0

                    boundingBoxes = [cv2.boundingRect(contour) for contour in contours]

                    (contours, boundingBoxes) = zip(*sorted(zip(contours, boundingBoxes), key=lambda b:b[1][i], reverse=False))

                    avg_area = sum([cv2.contourArea(contour) for contour in contours]) / len(contours)

                    ratio_area = [cv2.contourArea(contour) / avg_area for contour in contours]

                    line_patterns[line.getBaseSymbol()] = [avg_area, ratio_area, sys.maxsize]

            else:

                return

            lines_found = []

            lines_shape = []

            # detemine line type : broken

            for line in lines:

                rect = line.boundingRect()

                image_line = image[round(rect.y() - 3):round(rect.y() + rect.height() + 3), round(rect.x() - 3):round(rect.x() + rect.width() + 3)]

                contours, _ = cv2.findContours(image_line, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

                # skip piping line

                    for rect in [cv2.boundingRect(contour) for contour in contours]:

                    lines_shape.append([line, image_line[min_y:max_y, min_x:max_x]])

                vertical = LineDetector.is_vertical([line.start_point()[0], line.start_point()[1], line.end_point()[0], line.end_point()[1]])

                i = 1 if vertical else 0

                for line_type, line_pattern in line_patterns.items():

                    line_pattern[2] = sys.maxsize

                    ratio_area_cal = [ratio * avg_area / line_pattern[0] for ratio in ratio_area]

                    long_line = ratio_area_cal if len(ratio_area_cal) > len(line_pattern[1]) else line_pattern[1]

                    short_line = line_pattern[1] if len(ratio_area_cal) > len(line_pattern[1]) else ratio_area_cal

                    min_error = sys.maxsize

                    for offset in range(len(long_line) - len(short_line) + 1):

                        error = 0

                        for index in range(len(short_line)):

                            error += abs(short_line[index] - long_line[index + offset])

                        error = error / len(short_line)

                        if error < min_error:

                            min_error = error

                    line_pattern[2] = min_error

                line_type_found = sorted([(line_type, line_pattern[2]) for line_type, line_pattern in line_patterns.items()], key=lambda error:error[1])[0]

                if line_type_found[1] < 0.4:

                    lines_found.append([line, line_type_found])

                '''

                # feature matching not work

                orb = cv2.ORB_create()

                kp1, des1 = orb.detectAndCompute(image_line, None)

                kp2, des2 = orb.detectAndCompute(image_line, None)

                bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

                matches = bf.match(des1, des2)

                matches = sorted(matches, key=lambda x: x.distance)

                good = []

                for m, n in matches:

                    if m.distance < 0.75 * n.distance:

                        good.append([m])

                sift = cv2.xfeatures2d.SIFT_create()

                kp1, des1 = sift.detectAndCompute(image_line, None)

                kp2, des2 = sift.detectAndCompute(image_line, None)

                bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)

                matches = bf.match(des1, des2)

                matches = sorted(matches, key=lambda x: x.distance)

                good = []

                for m, n in matches:

                    if m.distance < 0.75 * n.distance:

                        good.append([m])

                '''

            # determine line type : solid

            for line, image_line in lines_shape:

                for line_type, line_shape in line_shapes.items():

                    shape = line_shape[0].copy()

                    line_shape[1] = sys.maxsize

                    big = shape if max(shape.shape) > max(image_line.shape) else image_line

                    small = image_line if max(shape.shape) > max(image_line.shape) else shape

                    if big.shape[0] == max(max(big.shape), max(small.shape)):

                        mask = np.zeros([big.shape[0], max(big.shape[1], max(small.shape))], np.uint8)

                    else:

                        mask = np.zeros([max(big.shape[0], max(small.shape)), big.shape[1]], np.uint8)

                    mask[0:big.shape[0], 0:big.shape[1]] = big

                    big = mask

                    searchedInfos = []

                    steps = [False, True]

                    for flipped in steps:

                        symGray = small.copy()

                        if flipped:

                            symGray = cv2.flip(symGray, 1)

                        symbolRotatedAngle = 0

                        for rc in range(4):

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

                            r_w, r_h = big.shape[::-1]

                            if r_w < sw or r_h < sh:

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

                                symbolRotatedAngle = (symbolRotatedAngle + 90) % 360

                                continue

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

                            _, max_val, __, max_loc = cv2.minMaxLoc(tmRes)

                            if max_val > 0.6:

                                searchedInfos.append(1 - max_val)

                    if searchedInfos:

                        line_shape[1] = sorted(searchedInfos)[0]

                line_type_founds = sorted([(line_type, line_shape[1]) for line_type, line_shape in line_shapes.items()], key=lambda error: error[1])

                if line_type_founds and line_type_founds[0][1] < 0.4:

                    if line_type_founds[0] == 'Secondary' or line_type_founds[0] == 'Primary' and len(line_type_founds) > 1:

                        if line_type_founds[1][1] < 0.4:

                            lines_found.append([line, line_type_founds[1]])

                        else:

                            lines_found.append([line, line_type_founds[0]])

                    else:

                        lines_found.append([line, line_type_founds[0]])

            line_runs = []

            for line_found in lines_found:

                inserted = False

                for line_run in line_runs:

                    if line_found[0] in line_run:

                        inserted = True

                        break

                if inserted:

                    continue

                else:

                    run = [line_found[0]]

                    Worker.find_connected_line(run, line_found[0])

                    line_runs.append(run)

                _lines_found = []

                for _line in line_run:

                    _lines = [line_found[0] for line_found in lines_found]

                    if _line in _lines:

                        index = _lines.index(_line)

                        _lines_found.append(lines_found[index])

                _line_found = sorted(_lines_found, key=lambda param:param[1][1])[0]

                Worker.changeConnectedLineType(_line_found[0], _line_found[1][0])

        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.emit(MessageType.Error, message)

            return None