RAU6 Dokuwiki

gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) 
blur = cv2.GaussianBlur(gray, (5, 5), 0) 
thresh = cv2.adaptiveThreshold(blur, 255, 1, 1, 11, 2)

W wyniku czego uzyskujemy:

image, contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
    if cv2.contourArea(cnt) > 20:
        [x, y, w, h] = cv2.boundingRect(cnt)
        if h > 10:
            im = copy.copy(im_copy)
            cv2.rectangle(im, (x, y), (x + w, y + h), (0, 0, 255), 2)
            roi = thresh[y:y + h, x:x + w]
            roismall = cv2.resize(roi, (20, 20))

W wyniku czego otrzymujemy obraz znaku 20×20:

np.savetxt('generalsamples.data', samples)
np.savetxt('generalresponses.data', responses)

self.samples = np.loadtxt("generalsamples.data", np.float32)
self.responses = np.loadtxt("generalresponses.data", np.float32)
self.model = cv2.ml.KNearest_create()
self.model.train(self.samples, cv2.ml.ROW_SAMPLE, self.responses)

ef extract_lines(self, image):
    line_list = {}
    # dilation
    cv2.imshow('input extract_line', image)
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (10, 1))
    img_dilation = cv2.dilate(image, kernel, iterations=3)
    # find contours
    image, contours, _ = cv2.findContours(img_dilation.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    for cnt in contours:
        [x, y, w, h] = cv2.boundingRect(cnt)
        # ic contour is big enough
        #print w * h
        if w * h > 5000: # wszystko co jest poniżej 5000 ignorujemy
            line_list[y] = [x, y, w, h]
    # sort contours
    print "Liczba Linii %s" % len(line_list)
    if len(line_list) == 3:
        return sorted(line_list.items())
    else:
        print "Read Error, Detected Lines Count Error ! -> %s" % len(line_list)
        return None

def decode(self, image):
    if len(image) > 0 and image is not None:
        contours = self.extract_lines(image)
        MZR_lines = []
        if contours is not None:
            for key, value in contours:
                # Get bounding box
                x, y, w, h = value
                line_image = image[y:y + h, x:x + w]
                MZR_lines.append(self.ocr(line_image))
                cv2.imshow("linie", line_image)
            return MZR_lines
    return None

def extract_chars_from_line(self, image):
    image, contours, _ = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    char_list = []
    i = 0
    lista_rect = {}
    for cnt in contours:
        [x, y, w, h] = cv2.boundingRect(cnt)
        if cv2.contourArea(cnt) > 10:
            char_list.append([x, y, w, h])
            lista_rect[x] = [x, y, w, h]
    return sorted(lista_rect.items())

Następnie na podstawie zwróconych parametrów znaku funkcja OCR wycina obrazek, skaluje do rozmiaru 20×20 i przekazuje do Sieci KNN jako dane wejściowe. Jako informacje zwrotną sieć KNN zwraca kod rozpoznanego znaku.

def validate(self, read_data):
    print "Read Data: %s" % read_data
    print "Test Data: %s" % self.test_lines
    read_line_count = len(read_data)
    test_line_count = len(self.test_lines)
    PASS_COUNT = 0;
    FAIL_COUNT = 0;
    if (test_line_count == read_line_count):
        for i in xrange(read_line_count):
            read_line_data = read_data[i]
            test_line_data = self.test_lines[i]
            if (len(read_line_data) == len(test_line_data)):
                for x in xrange(len(read_line_data)):
                    if read_line_data[x] == test_line_data[x]:
                        PASS_COUNT += 1
                    else:
                        FAIL_COUNT += 1
            else:
                return None
    else:
        return None
    print "Validation Summary: PASS: %s, FAIL: %s" % (PASS_COUNT, FAIL_COUNT)
    Accuracy = float(float(PASS_COUNT) / float(PASS_COUNT + FAIL_COUNT)) * 100
    return Accuracy

def validate(self, read_data):
    print "Read Data: %s" % read_data
    print "Test Data: %s" % self.test_lines
    read_line_count = len(read_data)
    test_line_count = len(self.test_lines)
    PASS_COUNT = 0;
    FAIL_COUNT = 0;
    if (test_line_count == read_line_count):
        for i in xrange(read_line_count):
            read_line_data = read_data[i]
            test_line_data = self.test_lines[i]
            if (len(read_line_data) == len(test_line_data)):
                for x in xrange(len(read_line_data)):
                    if read_line_data[x] == test_line_data[x]:
                        PASS_COUNT += 1
                    else:
                        FAIL_COUNT += 1
            else:
                return None
    else:
        return None
    print "Validation Summary: PASS: %s, FAIL: %s" % (PASS_COUNT, FAIL_COUNT)
    Accuracy = float(float(PASS_COUNT) / float(PASS_COUNT + FAIL_COUNT)) * 100
    return Accuracy

def capture_process(self, cam):
    cap = cv2.VideoCapture(cam)
    while (True):
        ret, frame = cap.read()
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        cv2.imshow('Camera data input', gray)
        key = cv2.waitKey(1)
        if chr(key & 255) == ' ':
            thresh = self.filtr(gray)
            text = self.locate_MZR(thresh, gray)
            print text
 
        if chr(key & 255) == 'q':
            break