Esempio n. 1
0
def keypoints_censure(img):
    """Detect key points using CENSURE."""
    censure = CENSURE(mode='STAR')
    censure.detect(img)
    keypoints = censure.keypoints

    return keypoints
def selectFeatures(useList):
    DataSet = []
    LabelSet = []
    lengthV = []
    trainPaths = ['./fruit/' + c + '_train/' for c in classes]
    testPaths = ['./fruit/' + c + ' test/' for c in classes]
    for c in range(len(classes)):
        className = classes[c]
        path = trainPaths[c]
        detector = CENSURE()
        detector2 = ORB(n_keypoints=50)
        detector3 = BRIEF(patch_size=49)
        files = os.listdir(path)
        #sample
        files = random.sample(files, 100)
        nfiles = len(files)
        for i in range(nfiles):
            featureVector = []
            infile = files[i]
            img = io.imread(path + infile, as_grey=True)
            hist = np.histogram(img, bins=256)
            img = resize(img, (400, 400))
            detector2.detect_and_extract(img)
            detector.detect(img)
            a = fd = hog(img,
                         orientations=9,
                         pixels_per_cell=(32, 32),
                         cells_per_block=(1, 1),
                         visualise=False)
            for h in hist:
                fd = np.append(fd, h)
            if (useList[0]):
                fd = np.append(fd, [np.array(detector.keypoints).flatten()])
            if (useList[1]):
                fd = np.append(fd, detector2.keypoints)
            if (useList[2]):
                fd = np.append(fd, edgeExtract(img, 100))
            l1 = len(fd)
            corners = corner_peaks(corner_harris(img), min_distance=1)
            if (useList[3]):
                fd = np.append(fd, corners)
            lengthV.append(len(fd))
            DataSet.append(fd)
            ind = classes.index(className)
            LabelSet.append(ind)
    max = np.amax(lengthV)
    lengthV = []
    DataSet2 = []
    for d in DataSet:
        d = np.pad(d, (0, max - len(d)), 'constant')
        DataSet2.append(d)
        lengthV.append(len(d))
    DataSet = DataSet2
    res = 0
    #perform gridsearch with one thread
    if __name__ == '__main__':
        res = gridSearch(DataSet, LabelSet, False)
        return res
Esempio n. 3
0
 def __init__(self):
     self.heatmapper = Heatmapper(
         point_diameter=15,
         point_strength=0.05,
         opacity=3,
         colours='reveal',
     )
     self.heatmap_name = 'heatmap.png'
     self.detector = CENSURE()
def get_CENSURE_kp(img):
    img = rgb2gray(img)

    censure = CENSURE(mode="star")

    censure.detect(img)

    kp = censure.keypoints
    
    return kp
Esempio n. 5
0
def censure(img):
    img = color.rgb2gray(img)
    # tform = tf.AffineTransform(scale=(1.5, 1.5), rotation=0.5,
    #                            translation=(150, -200))
    # img_warp = tf.warp(img, tform)
    detector = CENSURE()
    detector.detect(img)

    # return detector.keypoints, detector.scales
    return detector.scales
Esempio n. 6
0
def test_keypoints_censure_moon_image_dob():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for DoB filter."""
    detector = CENSURE()
    detector.detect(img)
    expected_keypoints = np.array([[21, 497], [36, 46], [119, 350], [185, 177],
                                   [287, 250], [357, 239], [463, 116],
                                   [464, 132], [467, 260]])
    expected_scales = np.array([3, 4, 4, 2, 2, 3, 2, 2, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 7
0
def test_keypoints_censure_moon_image_octagon():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for Octagon filter."""

    detector = CENSURE(mode="octagon")
    detector.detect(img)
    expected_keypoints = np.array([[21, 496], [35, 46], [287, 250], [356, 239], [463, 116]])

    expected_scales = np.array([3, 4, 2, 2, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 8
0
def test_keypoints_censure_moon_image_dob():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for DoB filter."""
    detector = CENSURE()
    detector.detect(img)
    expected_keypoints = np.array(
        [[21, 497], [36, 46], [119, 350], [185, 177], [287, 250], [357, 239], [463, 116], [464, 132], [467, 260]]
    )
    expected_scales = np.array([3, 4, 4, 2, 2, 3, 2, 2, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 9
0
def test_keypoints_censure_moon_image_star():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for STAR filter."""
    detector = CENSURE(mode='star')
    detector.detect(rescale(img, 0.25))  # quarter scale image for speed
    expected_keypoints = np.array([[23, 27], [29, 89], [30, 86], [107, 59],
                                   [109, 64], [111, 67], [113, 70]])

    expected_scales = np.array([3, 2, 4, 2, 5, 3, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 10
0
def test_keypoints_censure_moon_image_octagon():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for Octagon filter."""

    detector = CENSURE(mode='octagon')
    detector.detect(rescale(img, 0.25))  # quarter scale image for speed
    expected_keypoints = np.array([[23, 27], [29, 89], [31, 87], [106, 59],
                                   [111, 67]])

    expected_scales = np.array([3, 2, 5, 2, 4])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 11
0
def test_keypoints_censure_moon_image_star():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for STAR filter."""
    detector = CENSURE(mode='star')
    detector.detect(img)
    expected_keypoints = np.array([[21, 497], [36, 46], [117, 356], [185, 177],
                                   [260, 227], [287, 250], [357, 239],
                                   [451, 281], [463, 116], [467, 260]])

    expected_scales = np.array([3, 3, 6, 2, 3, 2, 3, 5, 2, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 12
0
def test_keypoints_censure_moon_image_octagon():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for Octagon filter."""

    detector = CENSURE(mode='octagon')
    detector.detect(img)
    expected_keypoints = np.array([[21, 496], [35, 46], [287, 250], [356, 239],
                                   [463, 116]])

    expected_scales = np.array([3, 4, 2, 2, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
def calc_CENSURE_score(dose_dataset):
    dose_score = 0
    frame_no = len(dose_dataset.pixel_array)
    frames = dose_dataset.pixel_array.copy()
    #pseudo_gray_frames = np.interp(frames, (frames.min(), frames.max()), (0, 255))
    for i in range(0, frame_no):
        im = frames[i] * 255 / frames.max()
        #im *= 255/frames.max()
        censure = CENSURE()
        censure.detect(im)
        key_points = censure.keypoints
        dose_score += len(key_points)
    normal_dose = dose_score / frame_no
    return normal_dose
Esempio n. 14
0
    def motionVectors(self, detectedObjects, currentFrame, nextFrame):

        censure = CENSURE()
        keypoints = np.array([]).reshape(-1, 2)
        nkps = {}
        arrowDict = {}

        for num, region in enumerate(detectedObjects):
            x0, y0, w, h = region
            roi = rgb2gray(currentFrame[int(y0 - 5):int(y0 + h + 5),
                                        int(x0 - 5):int(x0 + w + 5)])
            try:
                censure.detect(roi)
                kps = censure.keypoints
                kps[:, 1] += int(x0)
                kps[:, 0] += int(y0)
                # kps = np.c_[kps,num*np.ones(kps.shape[0])]
                nkps[num] = kps.shape[0]
                keypoints = np.append(keypoints, kps, axis=0)
            except:
                print('Skipped ROI')
                return nextFrame, arrowDict

        # print(keypoints.shape)

        try:
            flow_vectors = pyramid_lucas_kanade(rgb2gray(currentFrame),
                                                rgb2gray(nextFrame),
                                                keypoints,
                                                window_size=9)
        except:
            return nextFrame, arrowDict

        counter = 0
        aggregate_vectors = np.hstack((keypoints, flow_vectors))

        for k in nkps.keys():
            if nkps[k] != 0:
                vec = np.sum(aggregate_vectors[counter:counter + nkps[k], :],
                             axis=0)
                avgY = vec[0] / nkps[k]
                avgX = vec[1] / nkps[k]
                p1 = (int(avgX), int(avgY))
                p2 = (int(avgX + vec[3]), int(avgY + vec[2]))
                arrowDict[k] = (p1, (int(vec[3]), int(vec[2])))
                cv2.arrowedLine(nextFrame, p1, p2, (225, 32, 33), 3)
                counter += nkps[k]

        return nextFrame, arrowDict
Esempio n. 15
0
def extract_by_brief(img1, img2, min_distance=1):
    extractor = BRIEF()
    detector = CENSURE(mode='STAR')
    detector.detect(img1)
    keyp1 = detector.keypoints

    detector.detect(img2)
    keyp2 = detector.keypoints

    extractor.extract(img1, keyp1)
    desc1 = extractor.descriptors

    extractor.extract(img1, keyp2)
    desc2 = extractor.descriptors

    return [keyp1, keyp2, desc1, desc2]
Esempio n. 16
0
def test_keypoints_censure_moon_image_octagon():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for Octagon filter."""

    detector = CENSURE(mode='octagon')
    detector.detect(rescale(img, 0.25))     # quarter scale image for speed
    expected_keypoints = np.array([[ 23,  27],
                                   [ 29,  89],
                                   [ 31,  87],
                                   [106,  59],
                                   [111,  67]])

    expected_scales = np.array([3, 2, 5, 2, 4])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 17
0
def test_keypoints_censure_moon_image_star():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for STAR filter."""
    detector = CENSURE(mode='star')
    detector.detect(rescale(img, 0.25))     # quarter scale image for speed
    expected_keypoints = np.array([[ 23,  27],
                                   [ 29,  89],
                                   [ 30,  86],
                                   [107,  59],
                                   [109,  64],
                                   [111,  67],
                                   [113,  70]])

    expected_scales = np.array([3, 2, 4, 2, 5, 3, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 18
0
def getFeatures(slice, mels=256):
    '''
    Helper function to get the features of a song. It first computes the spectrogram and performs the CENSURE
    image algorithm on it to return the features scatterplot.

    :param slice: (Slice)        | slice to find features for
    :param mels: (int)           | 'resolution' of the spectrogram
    :return: detector: (CENSURE) | CENSURE image detector
    :return: kp: (numpy.ndarray) | feature scatterplot
    '''
    y, sr = tuple(slice)
    # y = effects.percussive(y)
    S = feature.melspectrogram(y, sr=sr, n_mels=mels)
    log_S = logamplitude(S, ref_power=np.max)

    detector = CENSURE()
    detector.detect(log_S)
    kp = detector.keypoints
    return detector, kp
Esempio n. 19
0
def test_keypoints_censure_moon_image_star():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for STAR filter."""
    detector = CENSURE(mode='star')
    detector.detect(img)
    expected_keypoints = np.array([[ 21, 497],
                                  [ 36,  46],
                                  [117, 356],
                                  [185, 177],
                                  [260, 227],
                                  [287, 250],
                                  [357, 239],
                                  [451, 281],
                                  [463, 116],
                                  [467, 260]])

    expected_scales = np.array([3, 3, 6, 2, 3, 2, 3, 5, 2, 2])

    assert_array_equal(expected_keypoints, detector.keypoints)
    assert_array_equal(expected_scales, detector.scales)
Esempio n. 20
0
def feature_detectors(img_grey):
    """
    Extracts features from raw 3d tensor/grayscaled/filtered
    images.

    """
    # feature detectors:
    censure_detector = CENSURE(mode='Octagon')
    censure_detector.detect(img_grey)
    censure_keypoints = censure_detector.keypoints
    censure_vec = np.ravel(censure_keypoints)

    orb_descriptor_extractor = ORB(n_keypoints=200)
    orb_descriptor_extractor.detect_and_extract(img_grey)
    orb_keypoints = np.ravel(orb_descriptor_extractor.keypoints)
    orb_descriptors = np.ravel(orb_descriptor_extractor.descriptors)
    orb_vec = np.concatenate((orb_keypoints, orb_descriptors), axis=0)
    feat_det_vec = np.concatenate((censure_vec, orb_vec), axis=0)

    return feat_det_vec
Esempio n. 21
0
def warp_censure(image, map_args={}, output_shape=None, order=1, mode='constant', cval=0.0, clip=True,
                 preserve_range=False):

    #img_orig = imageGlobal
    tform = tf.AffineTransform(scale=(1.5, 1.5), rotation=0.5,
                               translation=(150, -200))
    img_warp = tf.warp(image, tform)

    detector = CENSURE()

    fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))

    detector.detect(image)

    ax[0].imshow(image, cmap=plt.cm.gray)
    ax[0].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
                  2 ** detector.scales, facecolors='none', edgecolors='r')
    ax[0].set_title("Original Image")

    detector.detect(img_warp)

    ax[1].imshow(img_warp, cmap=plt.cm.gray)
    ax[1].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
                  2 ** detector.scales, facecolors='none', edgecolors='r')
    ax[1].set_title('Transformed Image')

    for a in ax:
        a.axis('off')

    plt.tight_layout()
    plt.show()
Esempio n. 22
0
def CENSURETransform(img1, img2, fp1, fp2):
    bw_img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY).astype("double")
    bw_img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY).astype("double")
    cen = CENSURE()
    cen.detect(bw_img1)
    kp1 = cen.keypoints
    cen.detect(bw_img2)
    kp2 = cen.keypoints

    kp1 = np.append(kp1, fp1, axis=0)
    kp2 = np.append(kp2, fp2, axis=0)

    matches = match_descriptors(kp1, kp2, cross_check=True)

    # fig, ax = plt.subplots(nrows=1, ncols=1)
    # plot_matches(ax, img1, img2, kp1, kp2, matches)
    # plt.show()

    points1 = kp1[matches[:, 0]]
    points2 = kp2[matches[:, 1]]

    M, mask = cv2.findHomography(points1, points2, cv2.RANSAC)
    if M is None:
        return
    else:
        dst = cv2.warpPerspective(img1, M, (img1.shape[1], img1.shape[0]))

    return dst
Esempio n. 23
0
class CENSUREClassifier(LocalFeatures):
    """
    CenSurE feature detector [2]. SURF [4, 5] as feature descriptor.
    Censure implementation from skimage
    """


    def __init__(self, testDataObj, svmType=None, name="", description=""):         
        super(CENSUREClassifier, self).__init__(Settings.C_TESTDATA_SEGMENTS, svmType, Settings.C_SVM_PARAMS, testDataObj, name, True, description)            
        self.detector = None
        self.bow = BagOfWords(Settings.C_BOW_DIMENSION, "SURF")    
        self.descriptor = cv.SURF()
        self.detector = CENSURE(non_max_threshold=0.01)

    def detect_keypoints(self, image):
        self.detector.detect(image)
        keypointList = self.detector.keypoints

        # convert coordinate keypoints to opencv keypoints
        # regarding class_id and size values see http://stackoverflow.com/questions/17981126/what-is-the-meaning-and-use-of-class-member-class-id-of-class-cvkeypoint-in-op and http://stackoverflow.com/questions/34104297/how-to-convert-given-coordinates-to-kaze-keypoints-in-python-with-opencv 
        return [cv.KeyPoint(p[0], p[1], 5, _class_id=0) for p in keypointList]

    def descibe_keypoints(self, image, keypoints):
        return self.descriptor.compute(image, keypoints)




    def __getstate__(self):
        result = self.__dict__.copy()
        del result['detector']
        return result 

    def __setstate__(self, dict):
        self.__dict__ = dict
        self.detector = cv.SURF()

    def __str__(self):
        return "CENSURE"
Esempio n. 24
0
def censure_feature(im):
    """
        CENSURE Feature Extraction
    :param im: image
    :return: image keypoints
    """
    # convert rgb to grayscale if needed
    if im.ndim == 3:
        image = rgb2gray(im)
    else:
        image = np.atleast_2d(im)

    censure = CENSURE()
    censure.detect(image)
    # censure.scales
    # Fetch only 10 keypoints
    censure_array = np.zeros(10)
    if len(censure.keypoints.ravel()) > 10:
        censure_array = censure.keypoints.ravel()[:10]
    else:
        censure_array[:len(censure.keypoints.ravel()
                           )] = censure.keypoints.ravel()
    return censure_array
Esempio n. 25
0
def censure_features(img_filepath):

    img_orig = cv2.imread(img_filepath, 0)

    tform = tf.AffineTransform(scale=(1.5, 1.5),
                               rotation=0.5,
                               translation=(150, -200))
    img_warp = tf.warp(img_orig, tform)
    detector = CENSURE()
    fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))

    ax1.imshow(img_orig, cmap=plt.cm.gray)
    ax1.set_title("Original Image")

    detector.detect(img_orig)

    ax2.imshow(img_orig, cmap=plt.cm.gray)
    ax2.scatter(detector.keypoints[:, 1],
                detector.keypoints[:, 0],
                2**detector.scales,
                facecolors='none',
                edgecolors='r')
    ax2.set_title("Censure features")
    plt.show()
Esempio n. 26
0
# - And - of course - I'm yet to find and quantify meaningful and generic features.
# 
# And a funny thought - what if I cut each sample into half along the symmetry axis and treat them as two samples? How shameless would that be? I get double sample size, I generalize better, I simplify and reduce the features I work with... 
# 
# ![Evil genius laughter][1]
# 
#   [1]: http://www.jimbowley.com/wp-content/uploads/2011/06/DrEvilPinky.jpg

# In[ ]:


# check a few scikitlearn image feature extractions, if they can help us

from skimage.feature import corner_harris, corner_subpix, corner_peaks, CENSURE

detector = CENSURE()
detector.detect(img)

coords = corner_peaks(corner_harris(img), min_distance=5)
coords_subpix = corner_subpix(img, coords, window_size=13)

plt.subplot(121)
plt.title('CENSURE feature detection')
plt.imshow(img, cmap='Set3')
plt.scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
              2 ** detector.scales, facecolors='none', edgecolors='r')

plt.subplot(122)
plt.title('Harris Corner Detection')
plt.imshow(img, cmap='Set3')  # show me the leaf
plt.plot(coords[:, 1], coords[:, 0], '.b', markersize=5)
      print("The folder name provided wasn't: sample, train, or test; using sample folder.")
      folder1  = "sample"
except:
    print("Didn't give me a folder; using sample folder.")
    folder1 = "sample"


file_names = os.listdir("/home/dick/Documents/Kaggle/" + folder1)
N = len(file_names)
print("Progress: 0 %"),
for i in range(N):
	img = cv2.imread(folder1 + "/" + file_names[i],1)
	gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

	censure = CENSURE()

	censure.detect(gray)
	kp = censure.keypoints
	scales = censure.scales
	print(len(kp))

	plt.imshow(img)
	plt.axis('off')
	plt.scatter(censure.keypoints[:, 1], censure.keypoints[:, 0],
	              2 ** censure.scales, facecolors='none', edgecolors='r')
	plt.show()

	#Store and Retrieve keypoint features 
	temp_array = []
	temp = pickle_keypoints(kp, scales) 
Esempio n. 28
0
class LogoFinder:
    def __init__(self):
        self.heatmapper = Heatmapper(
            point_diameter=15,
            point_strength=0.05,
            opacity=3,
            colours='reveal',
        )
        self.heatmap_name = 'heatmap.png'
        self.detector = CENSURE()

    @staticmethod
    def read_image(image_path):
        image = cv2.imread(image_path)
        bgr = image
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        return bgr, rgb, gray

    def make_heatmap(self, image_path):
        bgr_heatmap, rgb_heatmap, gray_heatmap = self.read_image(image_path)

        # Find contours and edges
        contours = find_contours(gray_heatmap,
                                 100,
                                 fully_connected='high',
                                 positive_orientation='high')
        edge_roberts = roberts(gray_heatmap)
        edge_sobel = sobel(gray_heatmap)

        self.detector.detect(gray_heatmap)
        thresh = threshold_otsu(gray_heatmap)
        bw = closing(gray_heatmap > thresh, square(3))
        cleared = clear_border(bw)
        label_image = label(cleared)
        image_label_overlay = label2rgb(label_image, image=gray_heatmap)

        edges = edge_roberts / 2 + edge_sobel / 2
        dots = list()

        for x in range(edges.shape[1]):
            for y in range(edges.shape[0]):
                for i in range(int(edges[y][x] * 2)):
                    dots.append([x, y])

        for n, point in enumerate(self.detector.keypoints):
            for i in range(self.detector.scales[n] * 10):
                dots.append([
                    point[1] + (random.random() - 0.5) * 10,
                    point[0] + (random.random() - 0.5) * 10
                ])

        for n, contour in enumerate(contours):
            if len(contour) > 50:
                for dot in contour:
                    dots.append([dot[1], dot[0]])

        for region in regionprops(label_image):
            # take regions with large enough areas
            if region.area >= 100:
                # draw rectangle around segmented coins
                minr, minc, maxr, maxc = region.bbox
                for x in range(minc, maxc):
                    for y in range(minr, maxr, 8):
                        dots.append([x, y])

        heatmap = self.heatmapper.heatmap_on_img_path(dots, image_path)
        heatmap.save(self.heatmap_name)

        bgr_heatmap, rgb_heatmap, gray_heatmap = self.read_image(
            self.heatmap_name)

        thresh = threshold_otsu(gray_heatmap)
        bw = closing(gray_heatmap > thresh, square(3))
        cleared = clear_border(bw)
        label_image = label(cleared)
        image_label_overlay = label2rgb(label_image, image=gray_heatmap)
        for n, region in enumerate(regionprops(label_image)):
            minr, minc, maxr, maxc = region.bbox
            if maxr - minr > 30 and maxc - minc > 30:
                yield minr, minc, maxr, maxc
Esempio n. 29
0
        gray1 = gray_.copy()

        # Read the values of the sliderbars and save them to variables
        min_scale = cv2.getTrackbarPos('min_scale', 'censure')
        max_scale = cv2.getTrackbarPos('max_scale', 'censure')
        if min_scale is 0:
        	min_scale = 1
    	if min_scale + max_scale < 3:
    		max_scale = min_scale + 2
        mode = mode_dict[str(cv2.getTrackbarPos('mode', 'censure'))]
        non_max_threshold = float(cv2.getTrackbarPos('non_max_threshold', 'censure'))/1000
        line_threshold = cv2.getTrackbarPos('line_threshold', 'censure')


        # Create a CENSURE feature detector
        censure = CENSURE(min_scale=min_scale, max_scale=max_scale, mode=mode, 
        					non_max_threshold=non_max_threshold, line_threshold=line_threshold)

        # Obtain the CENSURE features
        censure.detect(blue1)
        kp_blue, scale_blue = censure.keypoints, censure.scales
        censure.detect(green1)
        kp_green, scale_green = censure.keypoints, censure.scales
        censure.detect(red1)
        kp_red, scale_red = censure.keypoints, censure.scales
        censure.detect(gray1)
        kp_gray, scale_gray = censure.keypoints, censure.scales

        # Print the # of features if it has changed between iterations
        num_kp[0] = len(kp_blue)
        num_kp[1] = len(kp_green)
        num_kp[2] = len(kp_red)
Esempio n. 30
0
edge_sobel.shape

# In[15]:

# CENSURE feature detector
import skimage.transform as tf
from skimage.feature import CENSURE
tform = tf.AffineTransform(scale=(1.5, 1.5),
                           rotation=0.5,
                           translation=(0, -100))

# tf.AffineTransform(scale=(1.2, 1.2), translation=(0, -100))
img1 = color.rgb2gray(resize(image, (250, 250)))
img2 = tf.warp(img1, tform)

detector = CENSURE(mode='Octagon')

fig, ax = plt.subplots(nrows=1, ncols=2)

plt.gray()

detector.detect(image_grey)

ax[0].imshow(image_grey)
ax[0].axis('off')
ax[0].scatter(detector.keypoints[:, 1],
              detector.keypoints[:, 0],
              2**detector.scales,
              facecolors='none',
              edgecolors='r')
def main():
    DataSet = []
    LabelSet = []
    lengthV = []
    trainPaths = ['./fruit/' + c + '_train/' for c in classes]
    testPaths = ['./fruit/' + c + ' test/' for c in classes]

    resList = []
    boolList = []
    pos = 0
    ind = 0
    #if you wish to automatically perform both feature selection optimzation and svm optimization at the same time
    #comment out next line and comment in section above
    #Warning: Very long runtime for algorithm because of grid search
    useList = [True, True, True, True]
    #print(useList)

    for c in range(len(classes)):
        #get label for features to be added
        className = classes[c]
        #get file path for folder with images
        path = trainPaths[c]
        #initialize feature detectors/extractors
        #Censure extractor
        detector = CENSURE()
        #ORB extractor
        detector2 = ORB(n_keypoints=50)
        #get all file names from the folder
        files = os.listdir(path)
        nfiles = len(files)
        #repeat for each file
        for i in range(nfiles):
            #initialize feature vector as empty list
            featureVector = []
            infile = files[i]
            #read image as grayscale numpy.ndarray
            img = io.imread(path + infile, as_grey=True)
            #get histogram for grayscale value intensity
            hist = np.histogram(img, bins=256)
            #resize image
            img = resize(img, (400, 400))
            #extract features but do not yet add them to feature vector
            detector2.detect_and_extract(img)
            #extract HOG features, add them to featurevector
            a = fd = hog(img,
                         orientations=9,
                         pixels_per_cell=(32, 32),
                         cells_per_block=(1, 1),
                         visualise=False)
            #add histogramm to featurevector
            for h in hist:
                fd = np.append(fd, h)
            #if corresponding boolean in uselist is true add features to featureVector --> Feature selection happens here
            if (useList[0]):
                detector.detect(img)
                fd = np.append(fd, [np.array(detector.keypoints).flatten()])
            if (useList[1]):
                fd = np.append(fd, detector2.keypoints)
            if (useList[2]):
                fd = np.append(fd, edgeExtract(img, 100))
            if (useList[3]):
                corners = corner_peaks(corner_harris(img), min_distance=1)
                fd = np.append(fd, corners)
            #get length of featurevector for later operations
            lengthV.append(len(fd))
            #add featureVector list to dataset that is fed into svm
            DataSet.append(fd)
            #get label name
            ind = classes.index(className)
            #add label to label dataset that is fed into svm
            LabelSet.append(ind)
    #get length of biggest sized featurevector
    max = np.amax(lengthV)
    lengthV = []
    DataSet2 = []
    #pad dataset with zeroes so that all featurevectors have the same length --> important for svm
    for d in DataSet:
        d = np.pad(d, (0, max - len(d)), 'constant')
        DataSet2.append(d)
        lengthV.append(len(d))
    DataSet = DataSet2
    #perform a grid search with maximum number of possible threads (usually 4)
    if __name__ == '__main__':
        gridSearch(DataSet, LabelSet)
    #train and examine svm with default values for comparison later
    clf = svm.SVC(kernel='rbf', C=10.0, gamma=1.0000000000000001e-09)
    clf.fit(DataSet, LabelSet)
    joblib.dump(clf, classes[0] + ' ' + classes[1] + '.pk1')
    scores = cross_val_score(clf, DataSet, LabelSet, cv=10)
    #print results of default svm
    print(scores)
    print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
Esempio n. 32
0
from skimage.color import rgb2gray
from skimage.color import rgb2gray
from skimage.io import imread

import matplotlib.pyplot as plt

img1 = rgb2gray(
    imread(
        '/home/dek/makerfaire-booth/2018/burger/experimental/dek/train_object_detector/images/bottombun.0.00.27.34.-24.61.0.81.png'
    ))
img2 = rgb2gray(
    imread(
        '/home/dek/makerfaire-booth/2018/burger/experimental/dek/train_object_detector/images/bottombun.0.02.-49.74.26.68.1.83.png'
    ))

detector = CENSURE()

fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))

detector.detect(img1)
ax[0].imshow(img1, cmap=plt.cm.gray)
ax[0].scatter(detector.keypoints[:, 1],
              detector.keypoints[:, 0],
              2**detector.scales,
              facecolors='none',
              edgecolors='r')
ax[0].set_title("Original Image")

detector.detect(img2)

ax[1].imshow(img2, cmap=plt.cm.gray)
Esempio n. 33
0
 def __init__(self, testDataObj, svmType=None, name="", description=""):         
     super(CENSUREClassifier, self).__init__(Settings.C_TESTDATA_SEGMENTS, svmType, Settings.C_SVM_PARAMS, testDataObj, name, True, description)            
     self.detector = None
     self.bow = BagOfWords(Settings.C_BOW_DIMENSION, "SURF")    
     self.descriptor = cv.SURF()
     self.detector = CENSURE(non_max_threshold=0.01)
Esempio n. 34
0
implementation.
"""

from skimage import data
from skimage import transform as tf
from skimage.feature import CENSURE
from skimage.color import rgb2gray

import matplotlib.pyplot as plt

img_orig = rgb2gray(data.astronaut())
tform = tf.AffineTransform(scale=(1.5, 1.5), rotation=0.5,
                           translation=(150, -200))
img_warp = tf.warp(img_orig, tform)

detector = CENSURE()

fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))
plt.tight_layout()

detector.detect(img_orig)

ax[0].imshow(img_orig, cmap=plt.cm.gray)
ax[0].axis('off')
ax[0].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
              2 ** detector.scales, facecolors='none', edgecolors='r')
ax[0].set_title("Original Image")

detector.detect(img_warp)

ax[1].imshow(img_warp, cmap=plt.cm.gray)
for i in range(N):
    # Read image from file, then inspect the image dimensions
    img = cv2.imread(folder1 + "/" + file_names[i],1)
    height, width, channels = img.shape

    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    del img
    # Make a PIL image so we can use PIL.Image.thumbnail to resize if needed
    gray_ = Image.fromarray(gray)

    # Check if dimensions are above desired, if so then resize keepig aspect ratio
    m, n = 512, 512
    if height > m or width > n:
        gray_.thumbnail((m,n), Image.ANTIALIAS)

    censure = CENSURE(min_scale=min_scale, max_scale=max_scale, mode=mode, 
                            non_max_threshold=non_max_threshold, line_threshold=line_threshold)

    censure.detect(gray_)
    kp = censure.keypoints
    scales = censure.scales
    # print(len(scales))

    #Store keypoint features 
    temp_array = []
    temp = pickle_keypoints(kp, scales) 
    temp_array.append(temp)
    pickle.dump(temp_array, open("features/" + folder1 + "/censure/gray/" + file_names[i][:-5] + "_censure.pkl", "wb"))

    temp = str(float((i+1)*100/N))
    print("Progress: " + temp + " %")
Esempio n. 36
0
def test_keypoints_censure_mode_validity_error():
    """Mode argument in keypoints_censure can be either DoB, Octagon or
    STAR."""
    with pytest.raises(ValueError):
        CENSURE(mode='dummy')
Esempio n. 37
0
def test_keypoints_censure_scale_range_error():
    """Difference between the the max_scale and min_scale parameters in
    keypoints_censure should be greater than or equal to two."""
    with pytest.raises(ValueError):
        CENSURE(min_scale=1, max_scale=2)
Esempio n. 38
0
from skimage.feature import CENSURE
from skimage.color import rgb2gray
from skimage.color import rgb2gray
from skimage.io import imread

import matplotlib.pyplot as plt

img1 = rgb2gray(imread('/home/dek/makerfaire-booth/2018/burger/experimental/dek/train_object_detector/images/bottombun.0.00.27.34.-24.61.0.81.png'))
img2 = rgb2gray(imread('/home/dek/makerfaire-booth/2018/burger/experimental/dek/train_object_detector/images/bottombun.0.02.-49.74.26.68.1.83.png'))

detector = CENSURE()

fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))

detector.detect(img1)
ax[0].imshow(img1, cmap=plt.cm.gray)
ax[0].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
              2 ** detector.scales, facecolors='none', edgecolors='r')
ax[0].set_title("Original Image")

detector.detect(img2)

ax[1].imshow(img2, cmap=plt.cm.gray)
ax[1].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
              2 ** detector.scales, facecolors='none', edgecolors='r')
ax[1].set_title('Transformed Image')

for a in ax:
    a.axis('off')

plt.tight_layout()
Esempio n. 39
0
def test_censure_on_rectangular_images():
    """Censure feature detector should work on 2D image of any shape."""
    rect_image = np.random.rand(300, 200)
    square_image = np.random.rand(200, 200)
    CENSURE().detect((square_image))
    CENSURE().detect((rect_image))
Esempio n. 40
0
#!/usr/bin/env python3
#-*- Skimage Gallery -- CENSURE feature detector -*-
# CENSURE检测算子(尺度不变量,旋转不变量)
from skimage import data
from skimage import transform as tf
from skimage.feature import CENSURE
from skimage.color import rgb2gray
import matplotlib.pyplot as plt

img_orig = rgb2gray(data.astronaut())
tform = tf.AffineTransform(scale=(1.5, 1.5), rotation=0.5, translation=(150, -200))
img_warp = tf.warp(img_orig, tform)

detector = CENSURE()
fig,ax = plt.subplots(1,2, figsize=(12,6))

detector.detect(img_orig)
ax[0].imshow(img_orig, cmap=plt.cm.gray)
ax[0].scatter(detector.keypoints[:,1], detector.keypoints[:,0],
                2**detector.scales, facecolors='none', edgecolors='r')
ax[0].set_title('Original Image')

detector.detect(img_warp)
ax[1].imshow(img_warp, cmap=plt.cm.gray)
ax[1].scatter(detector.keypoints[:,1], detector.keypoints[:,0],
                2**detector.scales, facecolors='none', edgecolors='r')

for a in ax:
    a.axis('off')
plt.tight_layout()
plt.show()
Esempio n. 41
0
def test_keypoints_censure_color_image_unsupported_error():
    """Censure keypoints can be extracted from gray-scale images only."""
    with pytest.raises(ValueError):
        CENSURE().detect(np.zeros((20, 20, 3)))