HYTOS

import sys

import cv2

import numpy as np

import math

import shapely

class LineDetector():

    def __init__(self, image):

        try:

            thresh = 127

            self._image = image

            self.width = self._image.shape[::-1][0] if self._image is not None else None

            self.height = self._image.shape[::-1][1] if self._image is not None else None

            self.Result = np.zeros((self.width, self.height, 3), np.uint8) if self._image is not None else None

        except Exception as ex:

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

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

    '''

        @brief  dot product of given two vectors

        @author humkyung

        @date   2018.04.14

    '''

    def dotProduct(self, lhs, rhs):

        return sum([lhs[i] * rhs[i] for i in range(len(lhs))])

    '''

        @brief  get length of given vector

        @author humkyung

        @date   2018.04.14

    '''

    def getLength(self, lhs):

        return math.sqrt(self.dotProduct(lhs, lhs))

    '''

        @brief  get angle between given two vectors

        @author humkyung

        @date   2018.04.14

        @history    2018.05.29  Jeongwoo    Add try-exception

        @TODO : Need to modify case - Exception

    '''

    def getAngle(self, lhs, rhs):

        try:

            return math.acos(self.dotProduct(lhs, rhs) / (self.getLength(lhs) * self.getLength(rhs)))

        except Exception as ex:

            return sys.float_info.max

    """

        @brief  get distance between given two points

        @author humkyung

        @date   2018.04.13

    """

    def distanceTo(self, lhs, rhs):

        dx = rhs[0] - lhs[0]

        dy = rhs[1] - lhs[1]

        return math.sqrt(dx * dx + dy * dy)

    '''

        @brief  rotate given point about origin by angle

        @author humkyung

        @date   2018.04.12

    '''

    def rotatePoint(self, point, origin, angle):

        dx = point[0] - origin[0]

        dy = point[1] - origin[1]

        qx = origin[0] + math.cos(angle) * dx - math.sin(angle) * dy

        qy = origin[1] + math.sin(angle) * dx + math.cos(angle) * dy

        return [qx, qy]

    '''

        @brief  check if given two lines are connected

        @author humkyung

        @date   2018.04.11

    '''

    def isConnected(self, lhs, rhs, toler=0):

        length = []

        try:

            # check if share one point

            dx = (lhs[0][0] - rhs[0][0])

            dy = (lhs[0][1] - rhs[0][1])

            length.append(math.sqrt(dx * dx + dy * dy))

            dx = (lhs[1][0] - rhs[0][0])

            dy = (lhs[1][1] - rhs[0][1])

            length.append(math.sqrt(dx * dx + dy * dy))

            dx = (lhs[0][0] - rhs[1][0])

            dy = (lhs[0][1] - rhs[1][1])

            length.append(math.sqrt(dx * dx + dy * dy))

            dx = (lhs[1][0] - rhs[1][0])

            dy = (lhs[1][1] - rhs[1][1])

            length.append(math.sqrt(dx * dx + dy * dy))

            matches = [len for len in length if len < toler]

            # up to here

            return (len(matches) == 1)

        except Exception as ex:

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

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

        return False

    """

        @brief  check if given two lines lie on one line and share one point

        @author humkyung

        @date   2018.04.11

    """

    def isCollinear(self, lhs, rhs, toler):

        try:

            # print(lhs)

            # print(rhs)

            if self.isConnected(lhs, rhs, toler):

                dx1 = lhs[1][0] - lhs[0][0]

                dy1 = lhs[1][1] - lhs[0][1]

                length = math.sqrt(dx1 * dx1 + dy1 * dy1)

                dx1 /= length

                dy1 /= length

                dx2 = rhs[1][0] - rhs[0][0]

                dy2 = rhs[1][1] - rhs[0][1]

                length = math.sqrt(dx2 * dx2 + dy2 * dy2)

                dx2 /= length

                dy2 /= length

                dx = math.fabs(dx1) - math.fabs(dx2)

                dy = math.fabs(dy1) - math.fabs(dy2)

                return (math.sqrt(dx * dx + dy * dy) < 0.00001)

        except Exception as ex:

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

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

        return False

    '''

        @brief  connect given lines

        @author humkyung

        @date   2018.04.11

        @history    2018.05.16  Jeongwoo    Connect Lines with long distance points

    '''

    def connectLines(self, lines, toler):

        res = []

        pts = []

        # print(lines)

        maxthickness = 0

        for line in lines:

            pts.append(line[0])

            pts.append(line[1])

            maxthickness = line[2] if maxthickness < line[2] else maxthickness

        maxLength = None

        for lpt in pts:

            for rpt in pts:

                if lpt != rpt:

                    dx = rpt[0] - lpt[0]

                    dy = rpt[1] - lpt[1]

                    length = math.sqrt(dx * dx + dy * dy)

                    if maxLength is None or maxLength < length:

                        maxLength = length

                        res.clear()

                        res.append(lpt)

                        res.append(rpt)

                        res.append(maxthickness)

        # print(res)

        return res

    '''

        @brief      adjust start point

        @author     humkyung

        @date       2018.06.21

        @history    humkyung 2018.07.31 return -1 thickness tuple if near point is not black

    '''

    def adjustStartPoint(self, pt, dir):

        from AppDocData import AppDocData

        docData = AppDocData.instance()

        windowSize = docData.getSlidingWindowSize()

        try:

            white = 255

            black = 0

            norm = [-dir[1], dir[0]]

            if black == self._image[pt[1] + round(dir[1] * windowSize[1]), pt[0] + round(dir[0] * windowSize[1])]:

                _pt = [pt[0] + round(dir[0] * windowSize[1]), pt[1] + round(dir[1] * windowSize[1])]

            else:

                found = False

                for step in [1, 2, -1, -2]:

                    if black == self._image[pt[1] + round(dir[1] * windowSize[1] + norm[1] * step), pt[0] + round(

                            dir[0] * windowSize[1] + norm[0] * step)]:

                        _pt = [pt[0] + round(dir[0] * windowSize[1] + norm[0] * step),

                               pt[1] + round(dir[1] * windowSize[1] + norm[1] * step)]

                        found = True

                        break

                if not found: return (pt, -1)

            color = black

            lhs = [_pt[0], _pt[1]]

            lhscount = 1

            while color != white:

                lhs[0] = _pt[0] + round(norm[0] * lhscount)

                lhs[1] = _pt[1] + round(norm[1] * lhscount)

                color = self._image[lhs[1], lhs[0]]

                lhscount += 1

            color = black

            rhs = [_pt[0], _pt[1]]

            rhscount = 1

            while color != white:

                rhs[0] = _pt[0] - round(norm[0] * rhscount)

                rhs[1] = _pt[1] - round(norm[1] * rhscount)

                color = self._image[rhs[1], rhs[0]]

                rhscount += 1

            size = lhscount + rhscount

            offset = round((lhscount - rhscount) * 0.5) if size < windowSize[1] else 0

            # print(size)

            return (

                [pt[0] + norm[0] * offset, pt[1] + norm[1] * offset],

                size)  # if size > windowSize[1] else windowSize[1])

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message) if not 'is out of bounds' in message else ''

            return (pt, -1)

        return (pt, windowSize[1])

    '''

        @brief      symbol을 기준으로 양쪽으로 이미지에서 직선을 검출한다.

        @author     humkyung

        @date       2018.04.??

        @history    humkyung 2018.04.11 merge lines which are collinear or connected    

                    humkyung 2018.04.12 rotate connection points by symbol angle

                    humkyung 2018.04.12 use connection points without rotating(already rotated)

                    humkyung 2018.09.01 use connector's direction for detecting line

    '''

    def detectConnectedLine(self, symbol, offsetX, offsetY):

        res = []

        try:

            pool = []

            if (0 == symbol.angle) or (1.57 == symbol.angle) or (3.14 == symbol.angle) or (4.71 == symbol.angle):

                for connector in symbol.connectors:

                    ## get direction of connector

                    direction = connector.dir()

                    if direction is None:

                        dx = connector.sceneConnectPoint[0] - symbol.origin[0]

                        dy = connector.sceneConnectPoint[1] - symbol.origin[1]

                    else:

                        dx, dy = direction[0], direction[1]

                    # print('dx : ' + str(dx) + ', dy : ' + str(dy))

                    ## up to here

                    length = math.sqrt(dx * dx + dy * dy)

                    if length > 0:

                        dx /= length

                        dy /= length

                        if abs(dx) < 0.1:  # vertical line

                            dir = [0, 1 if dy > 0 else -1]

                            pt = [round(connector.sceneConnectPoint[0] - offsetX),

                                  round(connector.sceneConnectPoint[1] - offsetY)]

                            pt, thickness = self.adjustStartPoint(pt, dir)

                            if thickness != -1: pool.append([dir, pt, thickness, True if not pool else False])

                            # print("v")

                        elif abs(dy) < 0.1:  # horizontal line

                            dir = [1 if dx > 0 else -1, 0]

                            pt = [round(connector.sceneConnectPoint[0] - offsetX),

                                  round(connector.sceneConnectPoint[1] - offsetY)]

                            pt, thickness = self.adjustStartPoint(pt, dir)

                            if thickness != -1: pool.append([dir, pt, thickness, True if not pool else False])

                            # print("h")

                    # print(thickness)

                # print(pool)

            # print(len(pool))

            while len(pool) > 0:

                dir, pt, thickness, forward = pool.pop()

                line = self.detectLine(pt, dir, thickness, forward)

                if line is not None:

                    line.append(thickness)

                    # print(line)

                    res.append(line if forward else [line[1], line[0], thickness])

                    if ([1, 0] == dir) or ([-1, 0] == dir):  # turn up/down

                        connectedPt = [line[1][0], pt[1]]

                        pt, thickness = self.adjustStartPoint(connectedPt, [0, 1])

                        if thickness != -1: pool.append([[0, 1], pt, thickness, forward])

                        pt, thickness = self.adjustStartPoint(connectedPt, [0, -1])

                        if thickness != -1: pool.append([[0, -1], pt, thickness, not forward])

                    elif ([0, 1] == dir) or ([0, -1] == dir):  # turn left/right

                        connectedPt = [pt[0], line[1][1]]

                        pt, thickness = self.adjustStartPoint(connectedPt, [1, 0])

                        if thickness != -1: pool.append([[1, 0], pt, thickness, forward])

                        pt, thickness = self.adjustStartPoint(connectedPt, [-1, 0])

                        if thickness != -1: pool.append([[-1, 0], pt, thickness, not forward])

            # print(res)

            return res

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @breif      merge lines(1.connect collinear lines 2.connect lines)

        @author     humkyung

        @date       2018.04.11

        @history    humkyung 2018.04.12 continue loop if line is not in connectedLines

                    Jeongwoo 2018.05.16 Make comments if-statement

    '''

    def mergeLines(self, connectedLines, toler):

        try:

            for line in connectedLines[:]:

                if line not in connectedLines: continue

                matches = [param for param in connectedLines if

                           (line != param) and self.isCollinear(line, param, toler)]

                if len(matches) > 0:

                    # print(len(matches))

                    matches.append(line)

                    # if len(matches) > 2: matches = matches[0:2] # pick last two objects

                    mergedLine = self.connectLines(matches, toler)

                    if mergedLine is not None and len(mergedLine) > 0:

                        connectedLines.append(mergedLine)

                        for match in matches: connectedLines.remove(match)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief  connect line to nearest connection point of symbol

        @author humkyung

        @date   2018.04.13

    '''

    def connectLineToSymbol(self, line, symbol, toler):

        startPt = list(line.startPoint())

        distStart = [(self.distanceTo(startPt, (connector.sceneConnectPoint[0], connector.sceneConnectPoint[1])),

                      (connector.sceneConnectPoint[0], connector.sceneConnectPoint[1])) for connector in

                     symbol.connectors]

        distStart.sort()

        endPt = list(line.endPoint())

        distEnd = [(self.distanceTo(endPt, (connector.sceneConnectPoint[0], connector.sceneConnectPoint[1])),

                    (connector.sceneConnectPoint[0], connector.sceneConnectPoint[1])) for connector in

                   symbol.connectors]

        distEnd.sort()

        if distStart[0][0] < distEnd[0][0]:

            dx = distStart[0][1][0] - startPt[0]

            dy = distStart[0][1][1] - startPt[1]

            dir = (endPt[0] - startPt[0], endPt[1] - startPt[1])

            if abs(dir[0]) > abs(dir[1]):

                endPt[1] += dy

            else:

                endPt[0] += dx

            res = line.connect_if_possible(symbol, toler)

            if res:

                line.set_line([res[1], res[2]])

        else:

            dx = distEnd[0][1][0] - endPt[0]

            dy = distEnd[0][1][1] - endPt[1]

            dir = (endPt[0] - startPt[0], endPt[1] - startPt[1])

            if abs(dir[0]) > abs(dir[1]):

                startPt[1] += dy

            else:

                startPt[0] += dx

            res = line.connect_if_possible(symbol, toler)

            if res:

                line.set_line([res[1], res[2]])

    '''

        @brief  extend line to intersection point

        @author humkyung

        @date   2018.04.14

    '''

    def connectLineToLine(self, lhs, rhs, toler=20):

        try:

            res = lhs.connect_if_possible(rhs, toler)

            if not res:

                return

            lhs_start = list(lhs.startPoint())

            lhs_end = list(lhs.endPoint())

            rhs_start = list(rhs.startPoint())

            rhs_end = list(rhs.endPoint())

            dx = rhs_end[0] - rhs_start[0]

            dy = rhs_end[1] - rhs_start[1]

            length = math.sqrt(dx * dx + dy * dy)

            if length == 0: return

            dx /= length

            dy /= length

            rightLine = [(rhs_start[0] - dx * toler, rhs_start[1] - dy * toler),

                         (rhs_end[0] + dx * toler, rhs_end[1] + dy * toler)]

            shapelyRightLine = shapely.geometry.LineString(rightLine)

            dx = lhs_end[0] - lhs_start[0]

            dy = lhs_end[1] - lhs_start[1]

            length = math.sqrt(dx * dx + dy * dy)

            if length == 0: return

            dx /= length

            dy /= length

            line = [(lhs_start[0] - dx * toler, lhs_start[1] - dy * toler),

                    (lhs_end[0] + dx * toler, lhs_end[1] + dy * toler)]

            shapelyLine = shapely.geometry.LineString(line)

            pt = shapelyRightLine.intersection(shapelyLine)

            if (pt is not None) and (type(pt) == shapely.geometry.point.Point):

                if lhs.is_external_point(pt):

                    if self.distanceTo(lhs_start, (pt.x, pt.y)) < self.distanceTo(lhs_end, (pt.x, pt.y)):

                        lhs_start[0] = pt.x

                        lhs_start[1] = pt.y

                    else:

                        lhs_end[0] = pt.x

                        lhs_end[1] = pt.y

                    lhs.set_line([lhs_start, lhs_end])

                else:

                    if self.distanceTo(lhs_start, (pt.x, pt.y)) < toler:

                        lhs_start[0] = pt.x

                        lhs_start[1] = pt.y

                    elif self.distanceTo(lhs_end, (pt.x, pt.y)) < toler:

                        lhs_end[0] = pt.x

                        lhs_end[1] = pt.y

                    lhs.set_line([lhs_start, lhs_end])

                if rhs.is_external_point(pt):

                    if self.distanceTo(rhs_start, (pt.x, pt.y)) < self.distanceTo(rhs_end, (pt.x, pt.y)):

                        rhs_start[0] = pt.x

                        rhs_start[1] = pt.y

                    else:

                        rhs_end[0] = pt.x

                        rhs_end[1] = pt.y

                    rhs.set_line([rhs_start, rhs_end])

                else:

                    if self.distanceTo(rhs_start, (pt.x, pt.y)) < toler:

                        rhs_start[0] = pt.x

                        rhs_start[1] = pt.y

                    elif self.distanceTo(rhs_end, (pt.x, pt.y)) < toler:

                        rhs_end[0] = pt.x

                        rhs_end[1] = pt.y

                    rhs.set_line([rhs_start, rhs_end])

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief  detech line thickness

        @author humkyung

        @date   2018.05.18

    '''

    def detectLineThickness(self, pt, dir):

        import math

        from AppDocData import AppDocData

        docData = AppDocData.instance()

        windowSize = docData.getSlidingWindowSize()

        white = 255

        black = 0

        color = white

        norm = [-dir[1], dir[0]]

        if black == self._image[pt[1] + round(dir[1] * windowSize[1]), pt[0] + round(dir[0] * windowSize[1])]:

            _pt = [pt[0] + round(dir[0] * windowSize[1]), pt[1] + round(dir[1] * windowSize[1])]

        else:

            return windowSize[1]

        color = black

        lhs = [pt[0], pt[1]]

        count = 1

        while color != white:

            lhs[0] = pt[0] + round(norm[0] * count)

            lhs[1] = pt[1] + round(norm[1] * count)

            color = self._image[lhs[1], lhs[0]]

            count += 1

        color = black

        rhs = [pt[0], pt[1]]

        count = 1

        while color != white:

            rhs[0] = pt[0] - round(norm[0] * count)

            rhs[1] = pt[1] - round(norm[1] * count)

            color = self._image[rhs[1], rhs[0]]

            count += 1

        dx = rhs[0] - lhs[0]

        dy = rhs[1] - lhs[1]

        return math.sqrt(dx * dx + dy * dy)

    def detectLine(self, pt, dir, thickness, forward):

        """detect a line along given direction"""

        from AppDocData import AppDocData

        lineLengthConfigs = AppDocData.instance().getConfigs('Small Line Minimum Length', 'Min Length')

        lineMinLength = int(lineLengthConfigs[0].value) if 1 == len(lineLengthConfigs) else 10

        try:

            white = [255]

            windowSize = AppDocData.instance().getSlidingWindowSize()

            xHalf = round(windowSize[0] * 0.5)

            yHalf = round(windowSize[1] * 0.5)

            if ([1, 0] == dir):

                image = self._image[(pt[1] - yHalf):(pt[1] + yHalf), pt[0]:self.width]

                imgWidth, imgHeight = image.shape[::-1]

                index = 0

                for i in range(imgWidth - windowSize[0]):

                    window = image[0:windowSize[1], i:i + windowSize[0]]

                    if (white == window[0:windowSize[1], 0:windowSize[0]]).all(): break

                    index += 1

                if index > lineMinLength:

                    # self._image[(pt[1]-yHalf):(pt[1]+yHalf), pt[0]:(pt[0]+i)] = white

                    cv2.line(self._image, (pt[0], pt[1]), (pt[0] + i, pt[1]), 255, thickness)

                    return [[pt[0], pt[1]], [pt[0] + i - round(thickness * 0.5), pt[1]]]

            elif ([-1, 0] == dir):

                image = self._image[(pt[1] - yHalf):(pt[1] + yHalf), 0:pt[0]]

                imgWidth, imgHeight = image.shape[::-1]

                index = 0

                for i in range(imgWidth - windowSize[0], -1, -1):

                    window = image[0:windowSize[1], i:i + windowSize[0]]

                    if (white == window[0:windowSize[1], 0:windowSize[0]]).all(): break

                    index += 1

                if index > lineMinLength:

                    # self._image[int(pt[1]-yHalf):int(pt[1]+yHalf), (i+windowSize[0]+yHalf):pt[0]] = white

                    cv2.line(self._image, (i + windowSize[0], pt[1]), (pt[0], pt[1]), 255, thickness)

                    return [[pt[0], pt[1]], [i + windowSize[0] + round(thickness * 0.5), pt[1]]]

            elif ([0, 1] == dir):

                windowSize.reverse()

                xHalf = round(windowSize[0] * 0.5)

                yHalf = round(windowSize[1] * 0.5)

                image = self._image[pt[1]:self.height, int(pt[0] - xHalf):int(pt[0] + xHalf)]

                imgWidth, imgHeight = image.shape[::-1]

                index = 0

                for i in range(imgHeight - windowSize[1]):

                    window = image[i:i + windowSize[1], 0:windowSize[0]]

                    if (white == window[0:windowSize[1], 0:windowSize[0]]).all(): break

                    index += 1

                if index > lineMinLength:

                    # self._image[(pt[1]):(pt[1]+i), (pt[0]-xHalf):(pt[0]+xHalf)] = white

                    cv2.line(self._image, (pt[0], pt[1]), (pt[0], pt[1] + i), 255, thickness)

                    return [[pt[0], pt[1]], [pt[0], pt[1] + i - round(thickness * 0.5)]]

            elif ([0, -1] == dir):

                windowSize.reverse()

                xHalf = round(windowSize[0] * 0.5)

                yHalf = round(windowSize[1] * 0.5)

                image = self._image[0:pt[1], (pt[0] - xHalf):(pt[0] + xHalf)]

                imgWidth, imgHeight = image.shape[::-1]

                index = 0

                for i in range(imgHeight - windowSize[1], -1, -1):

                    window = image[i:i + windowSize[1], 0:windowSize[0]]

                    if (white == window[0:windowSize[1], 0:windowSize[0]]).all(): break

                    index += 1

                if index > lineMinLength:

                    # self._image[(i+windowSize[1]):pt[1], (pt[0]-xHalf):(pt[0]+xHalf)] = white

                    cv2.line(self._image, (pt[0], i + windowSize[1]), (pt[0], pt[1]), 255, thickness)

                    return [[pt[0], pt[1]], [pt[0], i + windowSize[1] + round(thickness * 0.5)]]

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return None

    def detectLineWithoutSymbol(self, area):  # path, offsetX, offsetY):

        '''

            @brief  detect remain line after detection using symbol info

            @author euisung

            @date   2019.03.28

        '''

        import os

        from AppDocData import AppDocData

        from HoughBundler import HoughBundler

        docData = AppDocData.instance()

        img = area.img

        if True:

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

            imgNot = cv2.bitwise_xor(self._image, imgNot)

            imgNot = cv2.erode(imgNot, np.ones((2, 2), np.uint8))

            contours, hierarchy = cv2.findContours(imgNot, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

            if len(contours) is 0:

                return []

            smallContours = []

            minimumSize = docData.getConfigs('Filter', 'MinimumSize') * 3

            lineLengthConfigs = docData.getConfigs('Small Line Minimum Length', 'Min Length')

            lineMinLength = int(lineLengthConfigs[0].value) if 1 == len(lineLengthConfigs) else 30

            for contour in contours:

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

                # remove too small one

                if len(minimumSize) is 1:

                    if (w * h < int(minimumSize[0].value) * int(minimumSize[0].value)):

                        smallContours.append(contour)

            imgNotRemoveSmall = cv2.drawContours(imgNot, smallContours, -1, 0, -1)

            # detect line

            edged = cv2.Canny(imgNotRemoveSmall, 100, 200)

            rate = 25

            lines = cv2.HoughLinesP(image=edged, rho=1, theta=np.pi / 180, threshold=rate,

                                    minLineLength=lineMinLength * 3, maxLineGap=25)

            if lines is None:

                return []

            houghBundler = HoughBundler().process_lines(lines, None)

            remainLines = []

            for line in houghBundler:

                remainLines.append([[line[0][0], line[0][1]], [line[1][0], line[1][1]]])

            # border line check

            borderRate = 0.07

            borderY, borderX = round(imgNot.shape[0] * borderRate), round(imgNot.shape[1] * borderRate)

            for index in range(len(remainLines) - 1, -1, -1):

                if remainLines[index][0][0] < borderX and remainLines[index][1][0] < borderX:

                    remainLines.pop(index)

                elif remainLines[index][0][0] > self._image.shape[1] - borderX and remainLines[index][1][0] > \

                        self._image.shape[1] - borderX:

                    remainLines.pop(index)

                elif remainLines[index][0][1] < borderY and remainLines[index][1][1] < borderY:

                    remainLines.pop(index)

                elif remainLines[index][0][1] > self._image.shape[0] - borderY and remainLines[index][1][1] > \

                        self._image.shape[0] - borderY:

                    remainLines.pop(index)

            return remainLines

    '''

        @brief  save the result of image

        @author humkyung

        @date   2018.04.14

    '''

    def saveImage(self):

        import datetime

        from AppDocData import AppDocData

        try:

            nowDate = datetime.datetime.now()

            path = AppDocData.instance().getCurrentProject().getTempPath() + '/{}_{}_line_detector.png'.format(

                nowDate.strftime('%Y-%m-%d'), nowDate.strftime('%H %M %S'))

            cv2.imwrite(path, self._image)

        except Exception as ex:

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

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