HYTOS

import sys

import cv2

import numpy as np

import math

import shapely

__author__ = "humkyung <humkyung.doftech.co.kr>"

__version__ = '1.0.0'

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]

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

        """check if given two lines are connected"""

        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:

            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 False

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

        """check if given two lines are connected and collinear"""

        try:

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

                dx = lhs[1][0] - lhs[0][0]

                dy = lhs[1][1] - lhs[0][1]

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

                vec1 = np.array([(lhs[1][0] - lhs[0][0]) / length, (lhs[1][1] - lhs[0][1]) / length, 0])

                dx = rhs[1][0] - rhs[0][0]

                dy = rhs[1][1] - rhs[0][1]

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

                vec2 = np.array([(rhs[1][0] - rhs[0][0]) / length, (rhs[1][1] - rhs[0][1]) / length, 0])

                area = np.cross(vec1, vec2)

                magnitude = math.sqrt(area[0] * area[0] + area[1] * area[1] + area[2] * area[2])

                return magnitude < 0.00001

        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 False

    '''

        @brief  connect given lines

        @author humkyung

        @date   2018.04.11

        @history    2018.05.16  Jeongwoo    Connect Lines with long distance points

    '''

    def connect_lines(self, lines, toler):

        res = []

        pts = []

        max_thickness = 0

        for line in lines:

            pts.append(line[0])

            pts.append(line[1])

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

        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(max_thickness)

        return res

    def adjust_start_point(self, pt, dir):

        """adjust start point of line and then return start point and thickness of line

        return -1 for thickness if fail to calculate thickness

        """

        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

            return (

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

                size if size < windowSize[1] else windowSize[1])  # 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]

                    # 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.adjust_start_point(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.adjust_start_point(pt, dir)

                            if thickness != -1:

                                pool.append([dir, pt, thickness, True if not pool else False])

            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.adjust_start_point(connectedPt, [0, 1])

                        if thickness != -1:

                            pool.append([[0, 1], pt, thickness, forward])

                        pt, thickness = self.adjust_start_point(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.adjust_start_point(connectedPt, [1, 0])

                        if thickness != -1:

                            pool.append([[1, 0], pt, thickness, forward])

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

                        if thickness != -1:

                            pool.append([[-1, 0], pt, thickness, not forward])

            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)

    def mergeLines(self, connectedLines, toler):

        """merge lines(1.connect collinear lines 2.connect lines)"""

        try:

            for line in connectedLines:

                matches = [param for param in connectedLines

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

                if len(matches) > 0:

                    matches.append(line)

                    mergedLine = self.connect_lines(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(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)

    '''

        @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):  # 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()

        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))