Exemple #1
0
def contours_detector(frame, typeBinariz=0, binarizParams=(9, 2.5),
                      minSizeObj=(24, 24), maxSizeObj=(144, 144),
                      aspectRatioObjInterval=(0.6, 1.3), compactObjInterval=(0.01, 0.2)):
    # cut left and right parts
    fr_cut_main = cv.GaussianBlur(frame, (5, 5), 0)
    fr_cut_left = frproc.cut_frame(fr_cut_main, (0, 0), (int(0.3 * fr_cut_main.shape[1]), fr_cut_main.shape[0]))
    fr_cut_right = frproc.cut_frame(fr_cut_main, (int(0.7 * fr_cut_main.shape[1]), 0),
                                    (fr_cut_main.shape[1], fr_cut_main.shape[0]))

    # equalize histogram for left and right parts of frame
    fr_cut_left = cv.createCLAHE(2.0, (5, 5)).apply(fr_cut_left)
    fr_cut_left = cv.GaussianBlur(fr_cut_left, (5, 5), 0)
    fr_cut_right = cv.createCLAHE(2.0, (5, 5)).apply(fr_cut_right)
    fr_cut_right = cv.GaussianBlur(fr_cut_right, (5, 5), 0)

    # binarization type
    if typeBinariz == 0:
        tr_left = cv.adaptiveThreshold(fr_cut_left, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY_INV,
                                       binarizParams[0], binarizParams[1])
        tr_main = cv.adaptiveThreshold(fr_cut_main, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY_INV,
                                       binarizParams[0], binarizParams[1])
        tr_right = cv.adaptiveThreshold(fr_cut_right, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY_INV,
                                        binarizParams[0], binarizParams[1])
    elif typeBinariz == 1:
        tr_left = cv.Canny(fr_cut_left, binarizParams[0], binarizParams[1])
        tr_main = cv.Canny(fr_cut_main, binarizParams[0], binarizParams[1])
        tr_right = cv.Canny(fr_cut_right, binarizParams[0], binarizParams[1])
    elif typeBinariz == 2:
        tr_left = imu.auto_canny(fr_cut_left)
        tr_main = imu.auto_canny(fr_cut_main)
        tr_right = imu.auto_canny(fr_cut_right)
    else:
        return

    # concatenate parts in full frame
    tr_main[0:fr_cut_main.shape[0], 0:(int(0.3 * fr_cut_main.shape[1]))] = tr_left[::]
    tr_main[0:fr_cut_main.shape[0], int(0.7 * fr_cut_main.shape[1]):fr_cut_main.shape[1]] = tr_right[::]
    cv.imshow("Test contours", tr_main)

    _, contours, _ = cv.findContours(tr_main, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)
    # sorting contours
    contours = [c for c in contours
                if maxSizeObj[0] >= cv.boundingRect(c)[2] >= minSizeObj[0]  # width
                and maxSizeObj[1] >= cv.boundingRect(c)[3] >= minSizeObj[1]  # height
                and (aspectRatioObjInterval[0] <=
                     (float(cv.boundingRect(c)[2]) / cv.boundingRect(c)[3]) <= aspectRatioObjInterval[1])  # aspect
                and ((cv.arcLength(c, True) != 0) and
                     (compactObjInterval[0] <=
                      (float(cv.contourArea(c)) / (cv.arcLength(c, True) ** 2)) <= compactObjInterval[1]))]  # compact

    rects_signs = [cv.boundingRect(c) for c in contours]
    return rects_signs
Exemple #2
0
def verif():
    with picamera.PiCamera() as camera:
        camera.resolution = (
            2592, 1944
        )  #défini la résolution de la caméra (max :(2592, 1944); min :(64,64))
        camera.framerate = 15  #défini la fréuence d'image de la caméra (défini à 15 pour la résolution max)
        camera.exposure_mode = 'auto'  #mode d'exposition de la caméra (par défault : 'auto')
        camera.start_preview(
        )  #ouverture de l'aperçu de la caméra (pas nécessaire dans notre cas mais pratiquepour le tests)
        sleep(
            2
        )  #ouverture de l'objectif pendant 5s (pour réglage luminosité ...)
        camera.capture('/home/pi/varroasVerif.jpg'
                       )  #capture de l'image et lien de stockage
        camera.stop_preview()  #fermeture de l'apercu
        print('Vérification effectué')
    sleep(2)
    image = cv2.imread('varroasVerif.jpg')
    gray = cv2.cvtColor(image,
                        cv2.COLOR_BGR2GRAY)  #met l'image en noir et blanc
    flougaussien = cv2.bilateralFilter(
        gray, 6, 157, 157)  #floûte l'image -> faire une moyenne des pixels
    edge = imutils.auto_canny(flougaussien)  #détermine les contours
    (cnts, _) = cv2.findContours(
        edge, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
    )  #ajoute dans une liste les contours qu'ils trouvent suivant les méthodes de recherche
    compteurVerif = 0  #initialisation de la variable compteur

    for c in cnts:
        if (120 > cv2.contourArea(c) > 85
            ):  #calcule le périmètre des contours trouvés (non fermé)
            compteurVerif += 1
    return compteurVerif
    def preprocessing(self):
        img1 = self.img[0:400, :]
        _, img1 = cv2.threshold(img1, 25, 255, cv2.THRESH_TOZERO)
        _, img1 = cv2.threshold(img1, 25, 255, cv2.THRESH_BINARY)
        kernel = np.ones((9, 9), np.uint8)
        img1 = cv2.morphologyEx(img1, cv2.MORPH_CLOSE, kernel)
        img1 = cv2.erode(img1, (7, 7), iterations=1)
        img1 = cv2.morphologyEx(img1, cv2.MORPH_OPEN, kernel)

        img2 = self.img[400:500, :]
        img2 = cv2.GaussianBlur(img2, (5, 5), np.sqrt(16))
        _, img2 = cv2.threshold(img2, 1, 255, cv2.THRESH_BINARY)

        img3 = self.img[500::, :]
        kernel1 = np.ones((5, 5), np.uint8)
        _, img3 = cv2.threshold(img3, 50, 255, cv2.THRESH_BINARY)
        img3 = cv2.morphologyEx(img3, cv2.MORPH_CLOSE, kernel1)
        img3 = cv2.erode(img3, (7, 7), iterations=3)
        img3 = cv2.morphologyEx(img3, cv2.MORPH_OPEN, kernel1)

        hold = np.zeros((self.img.shape[0], self.img.shape[1]), dtype=np.uint8)
        hold[0:400, :] = img1
        hold[400:500, :] = img2
        hold[500::, :] = img3
        hold = imu.auto_canny(hold)
        hold = cv2.dilate(hold, (3, 3), iterations=3)
        return hold
Exemple #4
0
def scan(img):
    # preprocess image
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    gray = cv2.bilateralFilter(gray, FILTER[0], FILTER[1], FILTER[2])
    ret, gray = cv2.threshold(gray, THRESHOLD[0], THRESHOLD[1], 0)
    edges = imutils.auto_canny(gray)

    # extract contours
    _, cnts, _ = cv2.findContours(edges.copy(), cv2.RETR_TREE,
                                  cv2.CHAIN_APPROX_SIMPLE)
    cnts = [c for c in cnts if cv2.contourArea(c) >= MIN_CARD_AREA]

    card, c = None, None
    if cnts:
        # get largest contour
        c = sorted(cnts, key=cv2.contourArea, reverse=True)[0]

        # approximate the contour
        peri = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.05 * peri, True)
        pts = np.float32(approx)

        x, y, w, h = cv2.boundingRect(c)

        # Find center point of card by taking x and y average of the four corners.
        # average = np.sum(pts, axis=0)/len(pts)
        # cent_x = int(average[0][0])
        # cent_y = int(average[0][1])
        # center = [cent_x, cent_y]

        # Warp card into 200x300 flattened image using perspective transform
        card = util.flattener(img, pts, w, h)
        card = util.cv2_to_pil(card).rotate(ROTATION)
    return card, c, gray, edges
Exemple #5
0
def read_test(image_path):

    resp = urllib.request.urlopen(image_path)
    image = np.asarray(bytearray(resp.read()), dtype="uint8")
    image = cv2.imdecode(image, cv2.IMREAD_COLOR)

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edged = imutils.auto_canny(gray)
    '''
        Find contours in the edge map, keeping only the largest one which 
        is presmumed to be the nail.
    '''
    cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
                            cv2.CHAIN_APPROX_SIMPLE)
    cnts = cnts[0] if imutils.is_cv2() else cnts[1]
    c = max(cnts, key=cv2.contourArea)

    # --- Extract the nail and resize it to a canonical width and height ---
    (x, y, w, h) = cv2.boundingRect(c)
    nail = gray[y:y + h, x:x + w]
    nail = cv2.resize(nail, (200, 100))

    fd = hog(nail,
             orientations=9,
             pixels_per_cell=(10, 10),
             cells_per_block=(2, 2),
             transform_sqrt=True,
             block_norm="L1")

    return fd.reshape(1, -1)
Exemple #6
0
def process_markers(img):
    hi, wi, _ = img.shape
    blur = cv2.medianBlur(img, 31)
    edge = imutils.auto_canny(blur)
    edge = cv2.dilate(edge, np.ones((5, 5)), iterations=2)
    _, contours, hierarchy = cv2.findContours(np.copy(edge), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    img_tmp = np.copy(img)
    cv2.drawContours(img_tmp, contours, -1, (100, 0, 0), 2)
    cv2.drawContours(edge, contours, -1, 100, 2)
    cnt = 0
    roi_ptr = []
    padding = 10
    for i in range(len(hierarchy[0])):
        if hierarchy[0][i][3] == -1:
            x, y, w, h = cv2.boundingRect(contours[i])
            if 2500 < w * h < 5e4 and h < 200 and w < 200:
                roi_ptr.append(
                    (max(x - padding, 0), max(0, y - padding), min(w + 2 * padding, wi), min(hi, h + 2 * padding)))
                cnt += 1
                cv2.rectangle(img_tmp, (x - padding, y - padding), (x + w + padding, y + w + padding), (0, 0, 255), 2)
    # for x, y, w, h in roi_ptr:
    #     print find_markers(img[y:y + w, x:x + w])
    if len(roi_ptr) == 0:
        return None, None, None
    x, y, w, h = roi_ptr[0]
    color, shape = find_markers(img[y:y + w, x:x + w])
    return color, shape, len(roi_ptr)
 def LabelDetector(self, AreaValue=2000, extendHeight=10, extendWight=10):
     th = cv2.adaptiveThreshold(self.img, 255,
                                cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                cv2.THRESH_BINARY_INV, 11, 2)
     kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
     mol = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel, iterations=1)
     mol = cv2.morphologyEx(mol, cv2.MORPH_CLOSE, kernel, iterations=7)
     edge = imu.auto_canny(mol)
     edge = cv2.morphologyEx(edge, cv2.MORPH_DILATE, kernel)
     cnts = cv2.findContours(edge, cv2.RETR_EXTERNAL,
                             cv2.CHAIN_APPROX_SIMPLE)
     cnts = imu.grab_contours(cnts)
     if len(cnts) != 0:
         (cnts, _) = contours.sort_contours(cnts)
         for cnt in cnts:
             area = cv2.contourArea(cnt)
             if area > AreaValue:
                 box = cv2.minAreaRect(cnt)
                 box = cv2.boxPoints(box)
                 box = perspective.order_points(box)
                 box = np.array(box, dtype="int")
                 [tl, bl, br, tr] = self.cal_bouding_box(box)
                 maxWidth, maxHeight = self.getOjectSize(tl, bl, br, tr)
                 ratio = round(maxWidth / maxHeight, 4)
                 return box, ratio, edge, area
     else:
         pass
Exemple #8
0
 def auto_canny(self, sigma=0.33):
     """compute the median of the single channel pixel intensities"""
     self.mat = imutils.auto_canny(
         image=self.mat,
         sigma=sigma,
     )
     return self
    def get_contours(self, base_img):
        """得到图片四角"""
        # 处理优化图片
        h = cv2.Sobel(base_img, cv2.CV_32F, 0, 1, -1)
        v = cv2.Sobel(base_img, cv2.CV_32F, 1, 0, -1)
        img = cv2.add(h, v)
        img = cv2.convertScaleAbs(img)
        img = cv2.GaussianBlur(img, (3, 3), 0)
        ret, img = cv2.threshold(img, 120, 255, cv2.THRESH_BINARY)
        kernel = np.ones((3, 3), np.uint8)
        # 膨胀
        img = cv2.dilate(img, kernel, iterations=2)
        img = auto_canny(img)
        # 获取最大轮廓和轮廓周长
        cnt, cnt_perimeter = self.get_max_area_cnt(img)
        base_img_perimeter = (base_img.shape[0] + base_img.shape[1]) * 2

        # 答题卡框与整个图片周长比的阈值
        CNT_PERIMETER_THRESHOLD = 0.35
        if not cnt_perimeter > CNT_PERIMETER_THRESHOLD * base_img_perimeter:
            logger.error("[get_contours] 获取答题卡失败,请重新上传图片")
            raise ImageException("获取答题卡失败,请重新上传图片")

        # 10%,即0.1的精确度,忽略细节
        epsilon = 0.1 * cv2.arcLength(cnt, True)
        # 计算多边形的顶点,并看是否是四个顶点
        poly_node_list = cv2.approxPolyDP(cnt, epsilon, True)
        if not poly_node_list.shape[0] == 4:
            logger.error("[get_contours] 不支持该答题卡,请重新上传图片")
            raise ImageException("不支持该答题卡,请重新上传图片")
        return poly_node_list
Exemple #10
0
def canny(mat):
    img = imutils.auto_canny(image=mat, sigma=0.3)
    img = add_frame_labels(
        frame=img,
        labels=[f"canny cost: {canny.cost:6.3f}s"],
        color=colors.get("WHITE"),
    )
    return img
Exemple #11
0
def load_template(image, load_type):
    try:
        template = cv2.imread(f"{directory}/data/templates/{image}", load_type)
        template = imutils.auto_canny(template)
    except cv2.error:
        print("Input one of the names in the 'data/templates' folder in order to detect")
        return None
    return template
Exemple #12
0
 def canny(self, visualization=False):
     from imutils import auto_canny
     # 보통은 영상처리전 원본이미지를 src(source), 목표로 하는 영상처리 결과이미지를 dst(destination)라고 네이밍해
     src = self.get_image()
     dst = auto_canny(src)
     if visualization:
         cv2.imshow("Canny", dst)
         cv2.waitKey(1)
     return dst
Exemple #13
0
def extract_hog_histogram(image, bins=(8, 8, 8)):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edged = imutils.auto_canny(gray)
    H = feature.hog(edged,
                    orientations=9,
                    pixels_per_cell=(10, 10),
                    cells_per_block=(2, 2),
                    normalise=True)
    return H
Exemple #14
0
def canny_edge_detection(frame: np.array, sigma=33) -> np.array:
    """
    Automatic edge detection from the imutils library.
    :param frame: A frame.
    :param sigma: A magic number. Shouldn't be changed without testing.
    :return: A black and white image of the edges in the frame.
    """
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    return imutils.auto_canny(gray, sigma=sigma)
Exemple #15
0
 def _reset(self):
     self.cost_matrix = None
     self.contours = []
     self.paths = []
     self.count = 0  # number of closed nodes
     self.max_level = 0  # maximum level of nodes, used in displaying path tree
     self.seed = None
     self.pq = None
     self.pixel_map = None
     self.edges = imutils.auto_canny(self.img)
Exemple #16
0
def grab_screen():
    try:
        screenshot(f"{directory}/data/screenshots/screen_shot.JPG")
        image = cv2.imread(f"{directory}/data/screenshots/screen_shot.JPG")
        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        image = imutils.auto_canny(image)
        return image
    except cv2.error:
        print("Make sure you have 'data/screenshots' folder")
        return None
    return image
Exemple #17
0
def get_err(frame):
    # frame[-speed_patch.shape[0]:, -speed_patch.shape[1]:] = speed_patch
    frame[-250:, :250] = map_patch
    frame = frame[int(frame.shape[0] / 1.6):-130, 400:-400]
    h, w, _ = frame.shape
    frame = cv2.GaussianBlur(frame, initial_blur_kernel, 0)
    frame = imutils.auto_canny(frame)
    frame = er_cycle(frame, 5)

    # cv2.imshow("w",frame)
    def foo(r):
        tmp = np.where(r > 0)
        if tmp[0].shape[0] == 0:
            return 0
        else:
            return int(np.mean(tmp))

    centers = np.apply_along_axis(foo, 1, frame)
    new_frame = np.copy(frame)
    new_frame.fill(0)
    for y in range(centers.shape[0]):
        if centers[y] != 0:
            cv2.circle(new_frame, (centers[y], y), 1, 255, -1)
    kernel = np.ones((5, 5), np.uint8)
    new_frame = cv2.dilate(new_frame, kernel, iterations=1)
    new_frame = cv2.erode(new_frame, kernel, iterations=1)
    frame = new_frame
    points = list(zip(*np.where(frame > 0)[::-1]))
    # print(len(points))
    if len(points) < 2:
        err = 0
        frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
    else:
        [vx, vy, x, y] = cv2.fitLine(np.array(points), cv2.DIST_WELSCH, 0,
                                     0.01, 0.01)
        m = 100
        x0, y0 = int(x[0] - m * vx[0]), int(y[0] - m * vy[0])
        x1, y1 = int(x[0] + m * vx[0]), int(y[0] + m * vy[0])
        err_y = h - 1
        if y1 == y0:
            err_x = x1
        else:
            err_x = x1 + (err_y - y1) * (x0 - x1) / (y0 - y1)
        err = err_x - w // 2
        frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
        frame = cv2.line(frame, (x0, y0), (x1, y1), (255, 0, 0), 5)
    cv2.putText(frame, 'key: %s' % key, (10, h - 50), cv2.FONT_HERSHEY_SIMPLEX,
                1, (255, 255, 255), 2)
    cv2.putText(frame, 'err: %d' % err, (10, h - 25), cv2.FONT_HERSHEY_SIMPLEX,
                1, (255, 255, 255), 2)
    out.write(frame)
    return err
def Contours(gray_image, print_true=True, test=False):
    #temp = cv2.Canny(gray_image, 50, 100)
    temp = imutils.auto_canny(gray_image)
    if test: cv2.imshow("Canny A", temp)
    else:
        temp = cv2.dilate(temp, None, iterations=1)
        temp = cv2.erode(temp, None, iterations=1)
    if test: cv2.imshow("Canny B", temp)
    if (print_true): cv2.imshow("EdgeDETECT", temp)
    cnts = cv2.findContours(temp.copy(), cv2.RETR_EXTERNAL,
                            cv2.CHAIN_APPROX_SIMPLE)
    cnts = imutils.grab_contours(cnts)
    (cnts, _) = contours.sort_contours(cnts)
    return cnts
Exemple #19
0
def process_image(raw, mark_image=False):
    cannyd = imutils.auto_canny(raw)

    height, width = cannyd.shape

    marker_width = coords['width']
    marker_halfwidth = int(marker_width * .5)

    font = cv2.FONT_HERSHEY_SIMPLEX
    fontScale = .5
    color = (255, 0, 0)
    thickness = 2
    spaces_left = len(coords['coords'])

    for coord in coords['coords']:
        x = int(coord['x']) - marker_width
        y = int(coord['y']) - marker_halfwidth
        x_max = x + marker_width
        y_max = y + marker_width

        if x_max > width:
            x_max = width
        if y_max > height:
            y_max = height

        if y < 0:
            y = 0
        if x < 0:
            x = 0

        box = cannyd[y:y_max, x:x_max]

        n_white_pix = np.sum(box == 255)
        percent_white = round(n_white_pix / marker_halfwidth**2, 2)

        if percent_white > .1:
            spaces_left -= 1

        if mark_image:
            start_point = (x, y)
            end_point = (x_max, y_max)
            cannyd = cv2.rectangle(cannyd, start_point, end_point, (255, 0, 0),
                                   2)

            cannyd = cv2.putText(cannyd, str(percent_white),
                                 (x, y - marker_halfwidth), font, fontScale,
                                 color, thickness, cv2.LINE_AA)

    return cannyd, spaces_left
Exemple #20
0
def auto_canny(img_path):
    img = cv2.imread(img_path, 0)
    img_canny = imutils.auto_canny(img)
    img_skeleton = imutils.skeletonize(img, size=(3, 3))

    plt.subplot(131)
    plt.imshow(imutils.opencv2matplotlib(img_canny))
    plt.axis('off')
    plt.subplot(132)
    plt.imshow(imutils.opencv2matplotlib(img))
    plt.axis('off')
    plt.subplot(133)
    plt.imshow(imutils.opencv2matplotlib(img_skeleton))
    plt.axis('off')
    plt.show()
def apply_filter(img, select="Gray"):
    filters = {}
    output = img.copy()

    filters["Original"] = output
    filters["Blur"] = cv2.GaussianBlur(output, (3, 3), 0)
    filters["Gray"] = cv2.cvtColor(filters["Blur"], cv2.COLOR_BGR2GRAY)
    filters["Thresh"] = cv2.threshold(
        filters["Gray"], 113, 255, cv2.THRESH_BINARY)[1]  # 60
    filters["Thresh-Adaptive"] = cv2.adaptiveThreshold(
        filters["Gray"], 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
    filters["Canny"] = cv2.Canny(filters["Blur"], 100, 200)
    filters["Canny-Auto"] = imutils.auto_canny(filters["Blur"])

    return filters[select]
def lane_detection_pipeline(img,
                            gaussian_kernel_size=3,
                            rho=1,
                            theta=np.pi / 180.0,
                            threshold=40,
                            min_line_len=40,
                            max_line_gap=80):
    result = grayscale(img)
    result = gaussian_blur(result, gaussian_kernel_size)
    result = auto_canny(result)
    result = region_of_interest(result, create_region_of_interest(img.shape))
    result = cv2.equalizeHist(result)
    lines_image = hough_lines(result, rho, theta, threshold, min_line_len,
                              max_line_gap)
    return weighted_img(lines_image, img)
Exemple #23
0
    def extract_image_features(self, data):
        # Please do not modify the header above

        # extract feature vector from image data

        feature_data = []
        
        for img in data:
            #gray = color.rgb2gray(img)
            edged = imutils.auto_canny(img)    
            (H, hogImage) = feature.hog(edged, orientations=9, pixels_per_cell=(90, 90), cells_per_block=(2, 2), transform_sqrt=True, visualise=True)
        
            #viewer = ImageViewer(hogImage)
            #viewer.show()    
            feature_data.append(H)        
        return(feature_data)
Exemple #24
0
    def _create_edge_map(self, sigma=0.33, dilate_kernel_size=7):
        """Convert image into dilated edge map

        :param sigma: value to be passed to imutils.auto_canny
        :param dilate_kernel_size: kernel radius to be used during dilation step
        :return: numpy array/opencv gray image containing dilated edge map
        """
        edge_map = imutils.auto_canny(self._background, sigma=sigma)
        if dilate_kernel_size > 2:
            if dilate_kernel_size % 2 == 0:
                dilate_kernel_size -= 1
            kernel = cv2.getStructuringElement(
                cv2.MORPH_ELLIPSE, (dilate_kernel_size, dilate_kernel_size))
            edge_map = cv2.dilate(edge_map, kernel)

        return edge_map
Exemple #25
0
    def displayFilters(self, select="Gray"):
        filters = {}
        output = self.frame

        filters["Original"] = output
        filters["Blur"] = cv2.GaussianBlur(output, (7, 7), 0)
        filters["Gray"] = cv2.cvtColor(filters["Blur"], cv2.COLOR_BGR2GRAY)
        filters["Thresh"] = cv2.threshold(filters["Gray"], 145, 255,
                                          cv2.THRESH_BINARY)[1]  # 60
        filters["Thresh-Adaptive"] = cv2.adaptiveThreshold(
            filters["Gray"], 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
            cv2.THRESH_BINARY, 5, 1)
        #filters["Thresh-Adaptive"] = cv2.dilate(filters["Thresh-Adaptive"], None, iterations=0)
        filters["Canny"] = cv2.Canny(filters["Blur"], 100, 200)
        filters["Canny-Auto"] = imutils.auto_canny(filters["Blur"])

        cv2.imshow("Camera view:", filters[select])
def canny_edge(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)

    cv2.imshow("Gray", gray)
    cv2.imshow("Blurred", blurred)

    # compute a "wide", "mid-range", and "tight" threshold for the edges
    wide = cv2.Canny(blurred, 10, 200)
    mid = cv2.Canny(blurred, 30, 150)
    tight = cv2.Canny(blurred, 245, 250)
    auto_range = imutils.auto_canny(blurred)

    cv2.imshow("Wide Edge Map", wide)
    cv2.imshow("Mid Edge Map", mid)
    cv2.imshow("Tight Edge Map", tight)
    cv2.imshow("Auto canny", auto_range)
def canny_edge(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)

    cv2.imshow("Gray", gray)
    cv2.imshow("Blurred", blurred)

    # compute a "wide", "mid-range", and "tight" threshold for the edges
    wide = cv2.Canny(blurred, 10, 200)
    mid = cv2.Canny(blurred, 30, 150)
    tight = cv2.Canny(blurred, 245, 250)
    auto_range = imutils.auto_canny(blurred)

    cv2.imshow("Wide Edge Map", wide)
    cv2.imshow("Mid Edge Map", mid)
    cv2.imshow("Tight Edge Map", tight)
    cv2.imshow("Auto canny", auto_range)
def trainData():
    print('training Started...')
    data = []
    labels = []
    count = 0
    dataFile = open('data.txt', 'w')
    labelFile = open('labels.txt', 'w')

    for car in vehicleList[:40000]:
        # extract the make of the car
        make = car.get('carType')
        imagePath = car.get('imagePath')

        # load the image, convert it to grayscale, and detect edges
        image = cv2.imread(imagePath)
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        edged = imutils.auto_canny(gray)

        # find contours in the edge map, keeping only the largest one which
        # is presmumed to be the car logo
        cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
                                cv2.CHAIN_APPROX_SIMPLE)
        cnts = cnts[0] if imutils.is_cv2(cnts) else cnts[1]
        c = max(cnts, key=cv2.contourArea)

        # extract the logo of the car and resize it to a canonical width
        # and height
        (x, y, w, h) = cv2.boundingRect(c)
        logo = gray[y:y + h, x:x + w]
        logo = cv2.resize(logo, (200, 100))

        # extract Histogram of Oriented Gradients from the logo
        H = feature.hog(logo, orientations=9, pixels_per_cell=(10, 10),
                        cells_per_block=(2, 2), transform_sqrt=True, block_norm="L1")

        # update the data and labels
        data.append(H)
        dataFile.write(str(H))
        dataFile.write("\n")
        labels.append(make)
        labelFile.write(str(make))
        labelFile.write("\n")

        count += 1
    return data, labels
def Predict(image, model):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edge = imutils.auto_canny(gray)
    resized = cv2.resize(gray, image_resize)
    H, hogImage = feature.hog(resized,
                              orientations=9,
                              pixels_per_cell=ppc,
                              cells_per_block=cpb,
                              transform_sqrt=True,
                              block_norm="L1",
                              visualize=True)
    pred = model.predict(H.reshape(1, -1))[0]
    hogImage = exposure.rescale_intensity(hogImage, out_range=(0, 255))
    hogImage = hogImage.astype("uint8")
    #cv2.imshow("Hog Image No. {}".format(i+1), hogImage)
    cv2.putText(image, pred.title(), (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 1.0,
                (110, 34, 59), 3)
    cv2.imshow("Test Image No. {}".format(i + 1), image)
Exemple #30
0
    def edges(self, frame=None, **params):
        rs = None
        image = self.frame(frame, **params)
        if not image is None:
            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            blurred = cv2.GaussianBlur(gray, (3, 3), 0)

            # apply Canny edge detection using a wide threshold, tight
            # threshold, and automatically determined threshold
            #			edged = cv2.Canny(blurred, 10, 200)
            #			edged = cv2.Canny(blurred, 225, 250)
            edged = imutils.auto_canny(blurred)
            rs = {
                'frame': image,
                'iframe': gray,
                'oframe': edged,
            }
        return rs
    def Edge_Canny_auto(self):
        # read image
        im = cv2.imread(self.Image)
        gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (3, 3), 0)

        # apply Canny edge detection using a wide threshold, tight
        # threshold, and automatically determined threshold
        wide = cv2.Canny(blurred, 10, 200)
        tight = cv2.Canny(blurred, 225, 250)
        auto = imutils.auto_canny(blurred)

        # show the images
        cv2.imshow("Original", im)
        cv2.imshow("Wide", wide)
        cv2.imshow("Tight", tight)
        cv2.imshow("Auto", auto)
        cv2.waitKey(0)
Exemple #32
0
    def Edge_Canny_auto(self):
        # read image
        im = cv2.imread(self.Image)
        gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (3, 3), 0)

        # apply Canny edge detection using a wide threshold, tight
        # threshold, and automatically determined threshold
        wide = cv2.Canny(blurred, 10, 200)
        tight = cv2.Canny(blurred, 225, 250)
        auto = imutils.auto_canny(blurred)

        # show the images
        cv2.imshow("Original", im)
        cv2.imshow("Wide", wide)
        cv2.imshow("Tight", tight)
        cv2.imshow("Auto", auto)
        cv2.waitKey(0)
def approx_realworld():
    image = cv2.imread("../img/receipt.png")

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edged = imutils.auto_canny(gray, 3.33)

    cv2.imshow("Original", image)
    cv2.imshow("Edge", edged)

    (_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:7]

    for c in cnts:
        peri = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.01 * peri, True)

        print("original: {}, approx: {}".format(len(c), len(approx)))

        if len(approx) == 4:
            cv2.drawContours(image, [approx], -1, (0, 255, 0), 3)

    cv2.imshow("Image", image)
cv2.imshow("Skeleton", skeleton)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 5. MATPLOTLIB
# INCORRECT: show the image without converting color spaces
plt.figure("Incorrect")
plt.imshow(cactus)

# CORRECT: convert color spaces before using plt.imshow
plt.figure("Correct")
plt.imshow(imutils.opencv2matplotlib(cactus))
plt.show()

# 6. URL TO IMAGE
# load an image from a URL, convert it to OpenCV, format, and
# display it
url = "http://pyimagesearch.com/static/pyimagesearch_logo_github.png"
logo = imutils.url_to_image(url)
cv2.imshow("URL to Image", logo)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 7. AUTO CANNY
# convert the logo to grayscale and automatically detect edges
gray = cv2.cvtColor(logo, cv2.COLOR_BGR2GRAY)
edgeMap = imutils.auto_canny(gray)
cv2.imshow("Original", logo)
cv2.imshow("Automatic Edge Map", edgeMap)
cv2.waitKey(0)
Exemple #35
0
image = ndimage.imread( "..\\Exemple-annonces\\ordi7.jpg")
plt.imshow(image)
plt.show()

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

lower = np.array([115, 135, 135]) #RGB
upper = np.array([125, 255, 255]) #RGB
red = cv2.inRange(hsv, lower, upper)

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
plt.imshow(gray,cmap='gray')
plt.show()

edged = imutils.auto_canny(red)
plt.imshow(edged,cmap='gray')
plt.show()

im2,contours, hierarchy = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)

contours.sort(key=cv2.contourArea,reverse=True )
area = [cv2.contourArea(contours[i]) for i in range(len(contours)) ]
(x, y, w, h) = cv2.boundingRect(contours[1])
logo = gray[y:y + h, x:x + w]

 
plt.imshow(logo)
plt.show()

H = feature.hog(logo, orientations=9, pixels_per_cell=(10, 10),
Exemple #36
0
# USAGE
# BE SURE TO INSTALL 'imutils' PRIOR TO EXECUTING THIS COMMAND
# python sorting_contours.py

# import the necessary packages
from imutils import contours
import imutils
import cv2

# load the shapes image clone it, convert it to grayscale, and
# detect edges in the image
image = cv2.imread("../demo_images/shapes.png")
orig = image.copy()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
edged = imutils.auto_canny(gray)

# find contours in the edge map
(cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
    cv2.CHAIN_APPROX_SIMPLE)

# loop over the (unsorted) contours and label them
for (i, c) in enumerate(cnts):
    orig = contours.label_contour(orig, c, i, color=(240, 0, 159))

# show the original image
cv2.imshow("Original", orig)

# loop over the sorting methods
for method in ("left-to-right", "right-to-left", "top-to-bottom", "bottom-to-top"):
    # sort the contours