HYTOS

import sys

import cv2

import numpy as np

import matplotlib.pyplot as plt

import math

import imutils

from shapely.geometry import LineString

from shapely.ops import linemerge

class LineVector:

    def __init__(self, x1, y1, x2, y2):

        self.x1 = x1

        self.y1 = y1

        self.x2 = x2

        self.y2 = y2

        dx = x2 - x1

        dy = y2 - y1

        self.Length = math.sqrt(dx*dx + dy*dy)

        self.dx = dx/self.Length

        self.dy = dy/self.Length

        self.DrawFlag = True

    """

    두 직선이 평행한지 판별한다.

    """

    def IsParallel(self, rhs):

        dx = math.fabs(self.dx) - math.fabs(rhs.dx)

        dy = math.fabs(self.dy) - math.fabs(rhs.dy)

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

        cross = []

        dx1 = rhs.x1 - self.x1

        dy1 = rhs.y1 - self.y1

        dx2 = rhs.x1 - self.x2

        dy2 = rhs.y1 - self.y2

        cross.append(dx1*dy1 - dy1*dx2)

        dx1 = rhs.x2 - self.x1

        dy1 = rhs.y2 - self.y1

        dx2 = rhs.x2 - self.x2

        dy2 = rhs.y2 - self.y2

        cross.append(dx1*dy1 - dy1*dx2)

        if cross[0] > 0 and cross[1] > 0: return False

        return Length < 0.0001

    """

    두 직선의 거리를 구한다.

    """

    def DistanceTo(self, rhs):

        dx = rhs.x1 - self.x1

        dy = rhs.y1 - self.y1

        dot = self.dx*dx + self.dy*dy

        tmp = dot

        x1 = self.x1 + tmp*self.dx

        y1 = self.y1 + tmp*self.dy

        dx = x1 - rhs.x1

        dy = y1 - rhs.y1

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

    '''

    두 직선의 사이를 가로지르는 직선을 구한다.

    '''

    def Merge(self, rhs):

        dx1 = rhs.x1 - self.x1

        dy1 = rhs.y1 - self.y1

        dx2 = rhs.x1 - self.x2

        dy2 = rhs.y1 - self.y2

        candidates = []

        candidates.append((self.x1, self.y1))

        candidates.append((self.x2, self.y2))

        Dir = []

        cross = dx1*dy2 - dy1*dx2

        if cross > 0:

            dot = dx1*self.dx + dy1*self.dy

            tmp = (self.x1 + dot*self.dx, self.y1 + dot*self.dy)

            candidates.append(tmp)

            Dir.append((rhs.x1 - tmp[0], rhs.y1 - tmp[1]))

        dx1 = rhs.x2 - self.x1

        dy1 = rhs.y2 - self.y1

        dx2 = rhs.x2 - self.x2

        dy2 = rhs.y2 - self.y2

        cross = dx1*dy2 - dy1*dx2

        if cross > 0:

            dot = dx1*self.dx + dy1*self.dy

            tmp = (self.x1 + dot*self.dx, self.y1 + dot*self.dy)

            candidates.append(tmp)

            Dir.append((rhs.x2 - tmp[0], rhs.y2 - tmp[1]))

        MaxLength = None

        Points = []

        for i in range(len(candidates) - 1):

            for j in range(i+1, len(candidates)):

                dx = candidates[i][0] - candidates[j][0]

                dy = candidates[i][1] - candidates[j][1]

                Length = dx*dx + dy*dy

                if MaxLength == None:

                    MaxLength = Length

                    Points.append(candidates[i])

                    Points.append(candidates[j])

                elif MaxLength < Length:

                    MaxLength = Length

                    Points[0] = candidates[i]

                    Points[1] = candidates[j]

        if len(Points) == 2 and len(Dir) > 0:

            x1 = Points[0][0] + Dir[0][0]*0.5

            y1 = Points[0][1] + Dir[0][1]*0.5

            x2 = Points[1][0] + Dir[0][0]*0.5

            y2 = Points[1][1] + Dir[0][1]*0.5

            return LineVector(x1, y1, x2, y2)

        else:

            dx1 = rhs.x1 - self.x1

            dy1 = rhs.y1 - self.y1

            dot = dx1*self.dx + dy1*self.dy

            tmp = (self.x1 + dot*self.dx, self.y1 + dot*self.dy)

            Dir.append((rhs.x1 - tmp[0], rhs.y1 - tmp[1]))

            x1 = Points[0][0] + Dir[0][0]*0.5

            y1 = Points[0][1] + Dir[0][1]*0.5

            x2 = Points[1][0] + Dir[0][0]*0.5

            y2 = Points[1][1] + Dir[0][1]*0.5

            return LineVector(x1, y1, x2, y2)

        return LineVector(self.x1, self.y1, self.x2, self.y2)

    def Draw(self, img, r, g, b):

        cv2.line(img, (int(self.x1), int(self.y1)), (int(self.x2), int(self.y2)), (r, g, b), 1)

class LineDetector():

    def __init__(self, image):

        thresh = 127

        self.image = cv2.threshold(image, thresh, 255, cv2.THRESH_BINARY)[1]

        self.width, self.height = self.image.shape[::-1]

        self.Result = np.zeros((self.width, self.height, 3), np.uint8)

    '''

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

        @author humkyung

        @date   2018.04.??

    '''

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

        res = []

        try:

            pool = []

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

                right = int(symbol.rect().right())

                left = int(symbol.rect().left())

                pt = [right - offsetX, int(symbol.center.y()) - offsetY]

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

                pt = [left - offsetX, int(symbol.center.y()) - offsetY]

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

            elif (1.57 == symbol.angle) or (4.71 == symbol.angle):  # rotated by 90 or 270 degree

                bottom = int(symbol.rect().bottom())

                top = int(symbol.rect().top())

                pt = [int(symbol.center.x()) - offsetX, bottom - offsetY]

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

                pt = [int(symbol.center.x()) - offsetX, top - offsetY]

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

            while len(pool) > 0:

                dir, pt = pool.pop()

                line = self.detectLine(pt,dir)

                if line is not None:

                    res.append(line)

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

                        pt[0] = line[1][0]

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

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

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

                        pt[1] = line[1][1]

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

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

            return res

        except Exception as ex:

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

    '''

        @brief  detect a line along given direction

        @author humkyung

        @date   2018.04

    '''

    def detectLine(self, pt, dir):

        from AppDocData import AppDocData

        white = [255]

        windowSize = AppDocData.instance().getSlidingWindowSize()

        xHalf = int(windowSize[0]*0.5)

        yHalf = int(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]

            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

            if i > windowSize[0]:

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

                return [(pt[0], pt[1]), (pt[0] + i, pt[1])]

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

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

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

            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

            if abs(pt[0] - i) > windowSize[0]: 

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

                return [(pt[0], pt[1]), (i+windowSize[0], pt[1])]

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

            windowSize.reverse()

            xHalf = int(windowSize[0]*0.5)

            yHalf = int(windowSize[1]*0.5)

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

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

            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

            if i > windowSize[1]:

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

                return [(pt[0], pt[1]), (pt[0], pt[1] + i)]

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

            windowSize.reverse()

            xHalf = int(windowSize[0]*0.5)

            yHalf = int(windowSize[1]*0.5)

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

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

            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

            if abs(pt[1] - i) > windowSize[1]:

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

                return [(pt[0], pt[1]), (pt[0], i+windowSize[1])]

        return None

    def save(self):

        cv2.imwrite('d:\\test.png', self.image)