HYTOS

                        remainLineNos.append(lineno)

                ## lineIndicator

                for lineIndicator in self._lineIndicator:

                    maxOverLap = 0

                    matchLineNo = None

                                if x1 - x2 is 0:

                                    xOverlap = True

                                    w += 1

                        for y1 in range(reNoRect[1], reNoRect[3] + 1):

                            for y2 in range(liInRect[1], liInRect[3] + 1):

                                if y1 - y2 is 0:

                        if not xOverlap or not yOverlap:

                            continue

                        overLapRate = (w / lineIndicator.boundingRect().width() * 100) if lineIndicator.boundingRect().width() > lineIndicator.boundingRect().height() else (h / lineIndicator.boundingRect().height() * 100)

                        if maxOverLap < overLapRate:

                            maxOverLap = overLapRate

                            matchLineNo = remainLineNo

                    if matchLineNo is not None:

                        matchLine = None

                        fXorY = []

                        for dXOrdY in range(startXorY, endXorY + 1): # if horizontal -> Y, if vertical -> X

                            if lineIndicator.isVH == 'V':

                            else:

                        for line in self._lines:

                            axis1Overlap = False

                            if lineIndicator.isVH == 'V':

                                range11 = range(startXorY, endXorY + 1)

                                range21 = fXorY

                            else:

                                range11 = range(startXorY, endXorY + 1)

                                range21 = fXorY

                            for axis11 in range11:

                                for axis12 in range12:

                                        axis1Overlap = True

                                        break

                                if axis1Overlap: break

                            for axis21 in range21:

                                for axis22 in range22:

                                    if axis21 - axis22 is 0:

                                break

                        if matchLine is not None:

                            matchLineNo.conns.append(matchLine)

                ## up to here

                # set start line's owner

                    approx = cv2.approxPolyDP(contour, epsilon, True)

                    approx = [pt[0] for pt in approx]

                    isLineNoInd, isVH, otherLine = self.isLineNoIndicator(idx, contours, imgNot)

                        docData.lineIndicators.append(item)

                    else:

                        docData.unknowns.append(item)

                    item.area = 'Drawing'

                    docData.allItems.append(item)

        import math

        [x, y, w, h] = cv2.boundingRect(contours[idx])

        if (w < 250 and h < 250):

        fLines = []

        mask = np.zeros_like(imgNot)

        cv2.drawContours(mask, contours, idx, 123, -1) # Draw filled contour in mask

        out = np.zeros_like(imgNot) # Extract out the object and place into output image

        edged2 = cv2.Canny(out, 100, 200)

        lines = cv2.HoughLines(edged2, 1, np.pi/180, 60)

        if lines is None:

        for line in lines:

            r, theta = line[0]

            a, b = np.cos(theta), np.sin(theta)

            x0, y0 = a * r, b * r

            x1, y1 = int(x0 + 1000 * (-b)), int(y0 + 1000 * a)

            x2, y2 = int(x0 - 1000 * (-b)), int(y0 - 1000 * a)

            degree = math.atan2(y2 - y1, x2 - x1) * 180 / math.pi

            fLine = [x1, y1, x2, y2, degree]

            fLines.append(fLine)

        isVH = None

        for fLine in fLines:

            degree = math.fabs(fLine[4])

                verLines.append(fLine)

                horLines.append(fLine)

            else:

                otherLines.append(fLine)

        if (len(horLines) > 0 and len(verLines) > 0) or len(otherLines) is 0 or (len(horLines) == 0 and len(verLines) == 0):

        baseLines = []

        baseDifV = 0

            baseDifV = maxDifW

            for verLine in verLines:

                x1, y1, x2, y2 = verLine[0], verLine[1], verLine[2], verLine[3]

                verLine.append(x)

            baseLines = verLines

            isVH = 'V'

                j += 1

            i += 1

        if not isSameLine:

        isSameLine = True

        i = 0

                    j += 1

                    continue

                difV = math.fabs(otherLine[4] - otherLinee[4])

                   isSameLine = False

                   break

                j += 1

            i += 1

        if not isSameLine:

        isSameLine = True

        mergedOtherLine = [0, 0, 0, 0]

            mergedOtherLine[2] += otherLine[2]

            mergedOtherLine[3] += otherLine[3]

        if not isSameLine:

        # Show the output image

        #print('line no indicator')

        #cv2.imshow('Output', out)

        #cv2.waitKey(0)

        #cv2.destroyAllWindows()

    '''

        @brief      load recognition result

        self.setZValue(QEngineeringUnknownItem.ZVALUE)

        self.setPen(QPen(Qt.red, 1, Qt.DashDotLine))

        else:

            self.setBrush(QBrush(QColor(255, 255, 0, 127)))

            points = [[int(float(coord)) for coord in pt.split(',')] for pt in node.find('POINTS').text.split('\n')]

            lineIndicator = node.find('LINEINDICATOR').text.split('#')

            if lineIndicator[0] == 'True':

            else:

            if node.find('AREA') is None:

                appDocData = AppDocData.instance()

            node.append(ptNode)

            lINode = Element('LINEINDICATOR')

                lINode.text = 'True' + '#' + self.isVH + '#' + str(self.otherLine[0]) + '#' + str(self.otherLine[1]) + '#' + str(self.otherLine[2]) + '#' + str(self.otherLine[3])

            else:

                lINode.text = 'False' + '#' + 'None' + '#' + 'None'

            node.append(lINode)