예제 #1
1
def getHOG3(imgs, ori=8, ppc=(4, 4), cpb=(4, 4)):
    # determine the shape of the output
    fd = hog(imgs[0, :, :, 0], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=False)
    # print fd.shape
    hogs = np.zeros((imgs.shape[0], fd.shape[0] * 3))
    # HOG
    for i in range(imgs.shape[0]):
        # zimgs[i,:] = exposure.equalize_hist(imgs[i,:])
        # imgs[i,:] = rank.equalize(imgs[i,:]/255,selem=disk(0))
        # plt.imshow(imgs[i,:]),plt.show()
        hogs[i, 0 : fd.shape[0]] = hog(
            imgs[i, :, :, 0], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=False
        )
        hogs[i, fd.shape[0] : (2 * fd.shape[0])] = hog(
            imgs[i, :, :, 1], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=False
        )
        hogs[i, 2 * fd.shape[0] : (3 * fd.shape[0])] = hog(
            imgs[i, :, :, 2], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=False
        )
        sys.stdout.write("\rIteration {0}/{1}".format((i + 1), imgs.shape[0]))
        sys.stdout.flush()

    mean = np.mean(hogs, axis=0)
    hogs -= mean
    return hogs
예제 #2
0
def extract_features():
    des_type = 'HOG'

    # If feature directories don't exist, create them
    if not os.path.isdir(pos_feat_ph):
        os.makedirs(pos_feat_ph)

    # If feature directories don't exist, create them
    if not os.path.isdir(neg_feat_ph):
        os.makedirs(neg_feat_ph)

    print "Calculating the descriptors for the positive samples and saving them"
    for im_path in glob.glob(os.path.join(pos_im_path, "*")):
        #print im_path
        
        im = imread(im_path, as_grey=True)
        if des_type == "HOG":
            fd = hog(im, orientations, pixels_per_cell, cells_per_block, visualize, normalize)
        fd_name = os.path.split(im_path)[1].split(".")[0] + ".feat"
        fd_path = os.path.join(pos_feat_ph, fd_name)
        joblib.dump(fd, fd_path)
    print "Positive features saved in {}".format(pos_feat_ph)

    print "Calculating the descriptors for the negative samples and saving them"
    for im_path in glob.glob(os.path.join(neg_im_path, "*")):
        im = imread(im_path, as_grey=True)
        if des_type == "HOG":
            fd = hog(im,  orientations, pixels_per_cell, cells_per_block, visualize, normalize)
        fd_name = os.path.split(im_path)[1].split(".")[0] + ".feat"
        fd_path = os.path.join(neg_feat_ph, fd_name)
    
        joblib.dump(fd, fd_path)
    print "Negative features saved in {}".format(neg_feat_ph)

    print "Completed calculating features from training images"
def SingleDecisionTreeClassifier(pix):
	print "\nCreating HOG Dataset from MNIST Data"
	start_time = time.time()
	training_image_data_hog = [hog(img, orientations=9, pixels_per_cell=(pix,pix), cells_per_block=(3, 3))
					for img in training_image_data]
	testing_image_data_hog = [hog(img, orientations=9, pixels_per_cell=(pix, pix), cells_per_block=(3, 3))
					for img in testing_image_data]
	end_time = time.time() - start_time
	print "It took "+ str(end_time) + " to make the HOG Images"

	print '\nTraining data'
	start_time = time.time()
	single_decision_tree_classifier = DecisionTreeClassifier()
	single_decision_tree_classifier.fit(training_image_data_hog, training_label_data)
	end_time = time.time() - start_time
	print "It took "+ str(end_time) + " to train the classifier"
	print 'Training Completed'

	print '\nTesting data '
	start_time = time.time()
	single_decision_tree_classifier_accuracy = single_decision_tree_classifier.score(testing_image_data_hog, testing_label_data)
	end_time = time.time() - start_time
	print "It took "+ str(end_time) + " to test the data "
# 
	print '\n# printing Accuracy'
	print "\nTesting for Single Decision Tree Classifier with pixels per cell = ("+str(pix)+','+str(pix)+') :'
	print "-------------------------------------------------"
	print "\nSingleDecisionTreeClassifier accuracy for ("+str(pix)+','+str(pix)+") : "+ str(single_decision_tree_classifier_accuracy)

	return single_decision_tree_classifier_accuracy
예제 #4
0
    def extract(self, image):
        features = np.array([])
        vec = []
        if 'raw' in self.features:
            vec = image.flatten()
        features = np.append(features, vec)
        vec = []
        if 'textons' in self.features:
            import gen_histogram as tx
            vec = np.array(tx.histogram(image, self.centers))
        features = np.append(features, vec)
        vec = []
        if 'hog' in self.features:
            vec = hog(image, cells_per_block=(3, 3))
            vec = np.append(vec, hog(image, cells_per_block=(4, 4)))
            vec = np.append(vec, hog(image, cells_per_block=(1, 1)))
            vec = np.append(vec, hog(image, cells_per_block=(2, 2)))
        features = np.append(features, vec)
        vec = []
        if 'lbp' in self.features:
            vec = local_binary_pattern(image, 24, 3).flatten()
        features = np.append(features, vec)
        vec = []
        if 'daisy' in self.features:
            vec = daisy(image).flatten()
        features = np.append(features, vec)

        return features
예제 #5
0
def classifier():
	train_images,train_labels = processData('train')
	test_images,test_labels   = processData('test')
	# sss = StratifiedShuffleSplit(train_labels, 3, test_size=0.5, random_state=0)
	# print sss
	# raw_input()
	# for train_index, test_index in sss:
	# 	print train_labels[train_index]
	# 	raw_input()


	train_images, train_labels = refineSets(train_images, train_labels, 1111)
	test_images, test_labels = refineSets(test_images, test_labels, 111)
	
	hog_train_images = [ hog(image) for image in train_images]
	hog_test_images = [ hog(image) for image in test_images]

	print 'Accuracy on test data : '
		#DistanceMetric.get_metric(metric)

	forest_sizes = [100,200,300,400,500]
	for size in forest_sizes:
		clf = RandomForestClassifier(n_estimators=size,criterion='entropy',n_jobs=-1)
		clf.fit(hog_train_images,train_labels)

		print size,"->",clf.score(hog_test_images,test_labels)
예제 #6
0
def extractHOG(inputimg, showHOG=False):

    # convert image to single-channel, grayscale
    image = color.rgb2gray(inputimg)

    #extract HOG features
    if showHOG:
        fd, hog_image = feature.hog(image, orientations=36,
                                    pixels_per_cell=(16, 16),
                                    cells_per_block=(2, 2),
                                    visualise=showHOG)
    else:
        fd = feature.hog(image, orientations=8, pixels_per_cell=(16, 16),
                         cells_per_block=(1, 1), visualise=showHOG)
    if(showHOG):
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)
        ax1.axis('off')
        ax1.imshow(image, cmap=plt.cm.gray)
        ax1.set_title('Input image')
        ax1.set_adjustable('box-forced')
        # Rescale histogram for better display
        hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 0.02))
        ax2.axis('off')
        ax2.imshow(hog_image_rescaled, cmap=plt.cm.gray)
        ax2.set_title('Histogram of Oriented Gradients')
        ax1.set_adjustable('box-forced')
        plt.show()
    return fd
예제 #7
0
def getHOG(imgs, ori=8, ppc=(4, 4), cpb=(4, 4), vis=True):
    # determine the shape of the output
    if vis:
        fd, im = hog(imgs[0, :], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=vis)
        imgs2 = imgs
    else:
        fd = hog(imgs[0, :], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=vis)

    hogs = np.zeros((imgs.shape[0], fd.shape[0]))
    # HOG
    for i in range(imgs.shape[0]):
        # zimgs[i,:] = exposure.equalize_hist(imgs[i,:])
        # imgs[i,:] = rank.equalize(imgs[i,:]/255,selem=disk(0))
        # plt.imshow(imgs[i,:]),plt.show()
        if vis:
            hogs[i, :], imgs2[i] = hog(
                imgs[i, :], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=vis
            )
        else:
            hogs[i, :] = hog(imgs[i, :], orientations=ori, pixels_per_cell=ppc, cells_per_block=cpb, visualise=vis)
        sys.stdout.write("\rIteration {0}/{1}".format((i + 1), imgs.shape[0]))
        sys.stdout.flush()
    mean = np.mean(hogs, axis=0)
    hogs -= mean

    if vis:
        return hogs, imgs2
    else:
        return hogs
def get_hog_features(img, orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True):
    """
    Extract the HOG features from the input image.
        Parameters:
            img: Input image.
            orient: Number of orientation bins.
            pix_per_cell: Size (in pixels) of a cell.
            cell_per_block: Number of cells in each block.
            vis: Visualization flag.
            feature_vec: Return the data as a feature vector.
    """
    if vis == True:
        features, hog_image = hog(img, orientations=orient, 
                                  pixels_per_cell=(pix_per_cell, pix_per_cell),
                                  cells_per_block=(cell_per_block, cell_per_block), 
                                  transform_sqrt=True, 
                                  visualise=vis, feature_vector=feature_vec)
        return features, hog_image
    else:
        features = hog(img, orientations=orient, 
                       pixels_per_cell=(pix_per_cell, pix_per_cell),
                       cells_per_block=(cell_per_block, cell_per_block), 
                       transform_sqrt=True, 
                       visualise=vis, feature_vector=feature_vec)
        return features
예제 #9
0
def transfer_to_hog(file_name):
	if file_name =='train':
		csv_file_object = csv.reader(open('train.csv', 'rb'))
		hog_write = csv.writer(open('hog.csv', 'wb'))      
		header = csv_file_object.next()
		imsize=(28,28)                                                                                  
		for row in csv_file_object:
			hogr=[]
			hogr.append(int(row[0]))
			image=map(int,row[1:])
			image=np.reshape(image, imsize)
			fd= hog(image, orientations=8, pixels_per_cell=(4, 4),
                    cells_per_block=(1, 1))
			hogr.extend(fd)
			fd= hog(image[2:26,2:26], orientations=8, pixels_per_cell=(4, 4),
                    cells_per_block=(1, 1))
			hogr.extend(fd)
			hog_write.writerow(hogr)
	if file_name =='test':
		csv_file_object = csv.reader(open('test.csv', 'rb'))
		hog_write = csv.writer(open('hog_test.csv', 'wb'))      
		header = csv_file_object.next()
		imsize=(28,28)                                                                                  
		for row in csv_file_object:
			hogr=[]
			image=map(int,row)
			image=np.reshape(image, imsize)
			fd= hog(image, orientations=8, pixels_per_cell=(4, 4),
                    cells_per_block=(1, 1))
			hogr.extend(fd)
			fd= hog(image[2:26,2:26], orientations=8, pixels_per_cell=(4, 4),
                    cells_per_block=(1, 1))
			hogr.extend(fd)
			hog_write.writerow(hogr)
예제 #10
0
 def ComputeDescriptors(self,RGB,Depth,dep_mask,h):
     dep = np.float32(Depth)
     dep_mask =cv2.bitwise_not(dep_mask)
     ret, mask = cv2.threshold(dep, 1.7, 1, cv2.THRESH_BINARY_INV)
     mask = np.uint8(mask)
     ret, mask2 = cv2.threshold(dep, 0.01, 1, cv2.THRESH_BINARY)
     mask2 = np.uint8(mask2)
     mask = cv2.bitwise_and(mask,mask2)
     mask = cv2.bitwise_and(mask,dep_mask)
     if h:
         masked_data = cv2.bitwise_and(RGB, RGB, mask=mask)
         masked_data = cv2.bitwise_and(masked_data, masked_data, mask=mask2)
         sp = cv2.cvtColor(masked_data, cv2.COLOR_RGB2GRAY)
         sp = cv2.GaussianBlur(sp, (5, 5),10)
         fd, imn = hog(dep, self.orientations, self.pixels_per_cell, self.cells_per_block,
                       self.visualize, self.normalize)
         if self.HogDepth:
             fdn,im = hog(sp, self.orientations, self.pixels_per_cell, self.cells_per_block,
                   self.visualize, self.normalize)
             fd = np.concatenate((fd, fdn))
     else:
         fd = []
     fgrid = np.array([])
     for i in xrange(4):
         for j in xrange(4):
             sub = RGB[25*i:25*(i+1),25*j:25*(j+1)]
             sub_mask = mask[25*i:25*(i+1),25*j:25*(j+1)]
             fsub = self.ComputeHC(sub,sub_mask)
             fgrid = np.concatenate((fgrid,fsub))
     fd2 = fgrid.copy()
     return fd,fd2,masked_data
예제 #11
0
def test_img(svm, img_path, scales, subwindow=None):
    base_img = cv2.imread(img_path)

    prev_img_path = utils.get_prev_img(img_path)
    base_prev_img = cv2.imread(prev_img_path)

    windows = []
    windows_features = []
    sc = []

    for scale in scales:
        img = cv2.resize(base_img, (0, 0), fx=scale, fy=scale)
        img_bw = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

        prev_img = cv2.resize(base_prev_img, (0, 0), fx=scale, fy=scale)
        prev_img_bw = cv2.cvtColor(prev_img, cv2.COLOR_BGR2GRAY)

        height, width, _ = img.shape

        flow = cv2.calcOpticalFlowFarneback(prev_img_bw, img_bw, 0.5, 3, 15, 3, 5, 1.2, 0)

        hsv = np.zeros_like(img)
        hsv[..., 1] = 255

        mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
        hsv[..., 0] = ang * 180/ np.pi / 2
        hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
        flowRGB = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
        flow_bw = cv2.cvtColor(flowRGB, cv2.COLOR_BGR2GRAY)

        if subwindow == None:
            nsx, nsy, nw, nh = 0, 0, width, height
        else:
            nsx, nsy, nw, nh = utils.getDetectionWindow(subwindow, width, height, scale)

        for x in range(nsx, nsx + nw - 64, 16):
            for y in range(nsy, nsy + nh - 128, 16):
                img_crop = img_bw[y:y + 128, x:x + 64]
                hog_gray = hog(img_crop, orientations=9, pixels_per_cell=(8, 8),
                         cells_per_block=(2, 2), visualise=False)

                flow_crop = flow_bw[y:y + 128, x:x + 64]
                fd_flow = hog(flow_crop, orientations=9, pixels_per_cell=(8, 8),
                              cells_per_block=(2, 2), visualise=False)
                fd = hog_gray + fd_flow

                windows.append((x, y))
                windows_features.append(fd)
                sc.append(scale)

    classes = svm.predict(windows_features)

    results = []
    for i in range(0, len(windows)):
            if classes[i] == 1:
                scale = sc[i]
                results.append((int(windows[i][0] / scale), int(windows[i][1] / scale), int(64 / scale), int(128 / scale)))
    return results
예제 #12
0
def test_hog_output_equivariance_multichannel():
    img = data.astronaut()
    img[:, :, (1, 2)] = 0
    hog_ref = feature.hog(img, multichannel=True, block_norm='L1')

    for n in (1, 2):
        hog_fact = feature.hog(np.roll(img, n, axis=2), multichannel=True,
                               block_norm='L1')
        assert_almost_equal(hog_ref, hog_fact)
def get_spat_arrng_ftrs(gray_img):
	# resize img to 600 * 600
	resized_img = transform.resize(gray_img, (600,600))
	left = resized_img.transpose()[:300].transpose()
	right = resized_img.transpose()[300:].transpose()

	I_anti = np.identity(600)[::-1] # anti - diagonal identity matrix
	inner = feature.hog(left) - feature.hog(I_anti.dot(right))

	return dict(symmetry = np.linalg.norm(inner))
예제 #14
0
def get_set(metadataFile, classType):
    set = []

    with open(metadataFile, "r") as f:
        entries = f.readlines()

    for entry in entries:
        entry = entry.split()
        filePath = entry[0]
        x, y, scale = int(entry[1]), int(entry[2]), float(entry[3])

        img = cv2.imread(filePath)
        img = cv2.resize(img, (0, 0), fx=scale, fy=scale)
        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        img_gray_crop = img_gray[y:y+128, x:x+64]

        hog_gray = hog(img_gray_crop, orientations=9, pixels_per_cell=(8, 8),
                         cells_per_block=(2, 2), visualise=False)

        prevFilePath = utils.get_prev_img(filePath)


        prev_img = cv2.imread(prevFilePath)
        prev_img = cv2.resize(prev_img, (0, 0), fx=scale, fy=scale)
        prev_img_gray = cv2.cvtColor(prev_img, cv2.COLOR_BGR2GRAY)

        flow = cv2.calcOpticalFlowFarneback(prev_img_gray, img_gray, 0.5, 3, 15, 3, 5, 1.2, 0)


        # flowx, flowy = flow[..., 0], flow[..., 1]
        # flowx_crop, flowy_crop = flowx[y:y+128, x:x+64], flowy[y:y+128, x:x+64]
        #
        # hog_flow_x = hog(flowx_crop, orientations=9, pixels_per_cell=(8, 8),
        #                  cells_per_block=(2, 2), visualise=False)
        # hog_flow_y = hog(flowy_crop, orientations=9, pixels_per_cell=(8, 8),
        #                  cells_per_block=(2, 2), visualise=False)

        hsv = numpy.zeros_like(img)
        hsv[..., 1] = 255

        mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
        hsv[..., 0] = ang * 180/ numpy.pi / 2
        hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
        flowRGB = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
        flow_gray = cv2.cvtColor(flowRGB, cv2.COLOR_BGR2GRAY)

        flow_gray_crop = flow_gray[y:y+128, x:x+64]

        hog_flow = hog(flow_gray_crop, orientations=9, pixels_per_cell=(8, 8),
                         cells_per_block=(2, 2), visualise=False)

        desc = hog_gray + hog_flow

        set.append(desc)
    return set, [classType] * len(entries)
예제 #15
0
def test_img_new(svm, img_path, scales, subwindow=None):
    base_img = cv2.imread(img_path)

    prev_img_path = utils.get_prev_img(img_path)
    base_prev_img = cv2.imread(prev_img_path)

    windows = []
    windows_features = []
    sc = []

    for scale in scales:
        img = cv2.resize(base_img, (0, 0), fx=scale, fy=scale)
        img_bw = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

        prev_img = cv2.resize(base_prev_img, (0, 0), fx=scale, fy=scale)
        prev_img_bw = cv2.cvtColor(prev_img, cv2.COLOR_BGR2GRAY)

        height, width, _ = img.shape

        flow = cv2.calcOpticalFlowFarneback(prev_img_bw, img_bw, 0.5, 3, 15, 3, 5, 1.2, 0)

        flowx, flowy = flow[..., 0], flow[..., 1]

        if subwindow == None:
            nsx, nsy, nw, nh = 0, 0, width, height
        else:
            nsx, nsy, nw, nh = utils.getDetectionWindow(subwindow, width, height, scale)

        for x in range(nsx, nsx + nw - 64, 16):
            for y in range(nsy, nsy + nh - 128, 16):
                img_crop = img_bw[y:y + 128, x:x + 64]
                hog_gray = hog(img_crop, orientations=9, pixels_per_cell=(8, 8),
                         cells_per_block=(2, 2), visualise=False)

                flowx_crop, flowy_crop = flowx[y:y+128, x:x+64], flowy[y:y+128, x:x+64]

                hog_flow_x = hog(flowx_crop, orientations=9, pixels_per_cell=(8, 8),
                                 cells_per_block=(2, 2), visualise=False)
                hog_flow_y = hog(flowy_crop, orientations=9, pixels_per_cell=(8, 8),
                                 cells_per_block=(2, 2), visualise=False)

                fd = numpy.concatenate((hog_gray, hog_flow_x, hog_flow_y))

                windows.append((x, y))
                windows_features.append(fd)
                sc.append(scale)

    classes = svm.predict(windows_features)

    results = []
    for i in range(0, len(windows)):
            if classes[i] == 1:
                scale = sc[i]
                results.append((int(windows[i][0] / scale), int(windows[i][1] / scale), int(64 / scale), int(128 / scale)))
    return results
예제 #16
0
def get_hog_features(img, params):
    if params['vis'] == True:
        features, hog_image = hog(img, orientations=params['n_orient_bins'], pixels_per_cell=params['pixels_per_cell'],
                                  cells_per_block=params['cell_per_block'], transform_sqrt=False, 
                                  visualise=params['vis'], feature_vector=params['collapse_feat'])
        return features, hog_image
    else:      
        features =  hog(img, orientations=params['n_orient_bins'], pixels_per_cell=params['pixels_per_cell'],
                                  cells_per_block=params['cell_per_block'], transform_sqrt=False, 
                                  visualise=params['vis'], feature_vector=params['collapse_feat'])
        return features        
예제 #17
0
    def extract_features(self, sample):
        kwargs = dict(normalize=self.normalize,
                      orientations=self.orientations,
                      pixels_per_cell=self.pixels_per_cell,
                      cells_per_block=self.cells_per_block)

        features = hog(sample[:, :, 0], **kwargs)
        features += hog(sample[:, :, 1], **kwargs)
        features += hog(sample[:, :, 2], **kwargs)

        return features
예제 #18
0
def calculate_hog_features(raw_training_data):
    num_train = len(raw_training_data)
    test = raw_training_data[0]
    test = test.reshape((28,28))
    fd = hog(test, orientations=12, pixels_per_cell=(7,7), cells_per_block=(1,1), visualise=False)
    hf_length = len(fd)
    hog_features = np.zeros((num_train,hf_length))
    for i in range(num_train):
        temp = raw_training_data[i]
        temp = temp.reshape((28,28))
        fd = hog(temp, orientations=12, pixels_per_cell=(7,7), cells_per_block=(1,1), visualise=False)
        hog_features[i] = fd

    return hog_features
def get_hog_features(img, orient, pix_per_cell, cell_per_block, 
                        vis=False, feature_vec=True):
    # Call with two outputs if vis==True
    if vis == True:
        features, hog_image = hog(img, orientations=orient, pixels_per_cell=(pix_per_cell, pix_per_cell),
                                  cells_per_block=(cell_per_block, cell_per_block), transform_sqrt=False, 
                                  visualise=vis, feature_vector=feature_vec)
        return features, hog_image
    # Otherwise call with one output
    else:      
        features = hog(img, orientations=orient, pixels_per_cell=(pix_per_cell, pix_per_cell),
                       cells_per_block=(cell_per_block, cell_per_block), transform_sqrt=False, 
                       visualise=vis, feature_vector=feature_vec)
        return features
예제 #20
0
def test_histogram_of_oriented_gradients():
    img = img_as_float(data.astronaut()[:256, :].mean(axis=2))

    fd = feature.hog(img, orientations=9, pixels_per_cell=(8, 8),
                     cells_per_block=(1, 1))

    assert len(fd) == 9 * (256 // 8) * (512 // 8)
def getFeature(image, blocks=5):
    '''
    Given an cv2 Image object it returns its feature vector.

    Args:
      image (ndarray): image to process.
      blocks (int, optional): number of block to subdivide the RGB space into.

    Returns:
      numpy array.
    '''
    image_resized = cv2.resize(image, (64, 64))
    imgray = cv2.cvtColor(image_resized, cv2.COLOR_RGB2GRAY)
    feature = np.zeros(blocks * blocks * blocks + 144)  # 144 for hog
    width, height, channel = image_resized.shape
    pixel_count = width * height
    r = ((image[:, :, 2]) / (256 / blocks)).astype("int")
    g = ((image[:, :, 1]) / (256 / blocks)).astype("int")
    b = ((image[:, :, 0]) / (256 / blocks)).astype("int")
    result = r + g * blocks + b * blocks * blocks
    unique, counts = np.unique(result, return_counts=True)
    feature[unique] = counts
    feature = feature / (pixel_count)
    feature_hog = hog(
        imgray, orientations=9,
        pixels_per_cell=(16, 16), cells_per_block=(1, 1), visualise=False)
    feature[blocks**3:] = feature_hog
    return feature
예제 #22
0
def hogKmeansClustering(param, orientNum, DATA_FOLDER):
    ts = ListaSet(param)
    print "{} images in total".format(ts.get_num_images())

    clustNum = 5
#    d1 = {}
#    Patches = np.empty([ts.get_num_images(), 13, 13 ], dtype=np.float32)
    PatchArr = np.empty([ ts.get_num_images(), orientNum])
    for i in range( ts.get_num_images()):
#        Patches[i,:,:] = ts.get_input(i)
        PatchArr[i, :] = hog( ts.get_input(i), orientations=orientNum, pixels_per_cell=(13, 13), cells_per_block=(1, 1), visualise=False)
        # for 5x5 centered at 13x13 input    
#        PatchArr[i, :] = hog( ts.get_input(i)[4:9, 4:9], orientations=orientNum, pixels_per_cell=(5, 5), cells_per_block=(1, 1), visualise=False)
        # for 17x17 input
#        PatchArr[i, :] = hog( ts.get_input(i)[6:11, 6:11], orientations=orientNum, pixels_per_cell=(5, 5), cells_per_block=(1, 1), visualise=False)
        if i % 10000 == 0:
            print i

    print "load existing codebook..."
    codebook = np.load( DATA_FOLDER+'/4bins_5cls/codebookArtificial2.npy')
    print codebook

    print "assign codes for patches..."
    code, dist = scipy.cluster.vq.vq( PatchArr, codebook)

    d1 = {}
    for i in range( clustNum):
        d1['label'+str(i+1)+'_idx'] = np.where( code == i)[0].astype( np.uint32)
    d1['labelArr'] = code.astype( np.uint32)
#        d1['PatchArr'+str(i+1)] = Patches[ np.where( code == i)[0], :, :].astype( np.uint32)
#    d1['PatchArr'] = Patches

    scipy.io.savemat( DATA_FOLDER+'/4bins_5cls/trainlabelsArtificial13code2_sps100_r8.mat', d1)
def cal_hog(image,orientations=9, pixels_per_cell=(16, 16),
                    cells_per_block=(1, 1), visualise=True):
    # fd, hog_image = hog(image, orientations=8, pixels_per_cell=(16, 16),
    #                 cells_per_block=(1, 1), visualise=True)
    fd, hog_image = hog(image, orientations, pixels_per_cell,
                    cells_per_block, visualise)
    return fd,hog_image
예제 #24
0
def print_hog_image(image):
    """
    image is expected to be in it's original format

    function prints hog image
    """
    print image.shape
    image = color.rgb2gray(image)

    fd, hog_image = hog(image, orientations=8, pixels_per_cell=(4, 4),
                        cells_per_block=(1, 1), visualise=True, normalise=True)
    print "finished hog..."
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)

    ax1.axis('off')
    ax1.imshow(image, cmap=plt.cm.gray)
    ax1.set_title('Input image')
    ax1.set_adjustable('box-forced')

    # Rescale histogram for better display
    hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 0.02))

    ax2.axis('off')
    ax2.imshow(hog_image_rescaled, cmap=plt.cm.gray)
    ax2.set_title('Histogram of Oriented Gradients')
    ax1.set_adjustable('box-forced')
    plt.show()
def learn_hog(img):
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    global n_bin
    global b_size
    global c_size
    global hog_list
    global labels
    w, l = np.shape(img)
    img_list = list()
    img_list.append(img)
    img_list.append(img[5:w - 2, 7:l - 6])
    img_list.append(img[4:, :])
    img_list.append(img[0:w-4, :])
    img_list.append(img[:, 4:])
    img_list.append(img[:, :l-4])
    img_list.append(img[7:, :])
    img_list.append(img[0:w-7, :])
    img_list.append(img[:, 7:])
    img_list.append(img[:, :l-7])
    img_list.append(img[12:, :])
    img_list.append(img[0:w-12, :])
    img_list.append(img[:, 12:])
    img_list.append(img[:, :l-12])
    index = 0
    global show
    for imgs in img_list:
        imgs = cv2.resize(imgs, (115, 120), interpolation=cv2.INTER_AREA)  # resize image
        if SHOW == 1:
            cv2.imshow('img' + str(index), imgs)
        index += 1
        HOG_LIST.append(hog(imgs, orientations=n_bin, pixels_per_cell=(c_size, c_size),
                            cells_per_block=(b_size / c_size, b_size / c_size), visualise=False))
        labels.append(label)
예제 #26
0
def plothog(k1):
    infile=os.path.join('C:\meenuneenu\project\libsvm-3.17\python\data',"IMG-%s.png" % k1)
    #infile="C:/Python27/Lib/site-packages/temp/svm/window/window4.jpg"
    #img = Image.open(infile)
    img = Image.open(infile)
    #image = color.rgb2gray(data.lena())
    """
    width = 50
    height = 50 
    # Resize it.
    img = img.resize((width, height), Image.BILINEAR)
    # Save it back to disk.
    img.save(os.path.join("C:/Python27/Lib/site-packages/temp/svm/", 'resized.png'))
    """
    img = img.convert('1')
    img.save("C:/Python27/Lib/site-packages/temp/IMG-4.png")

    fd = list(hog(img, orientations=8, pixels_per_cell=(16, 16),
                        cells_per_block=(1, 1), visualise=False))
#filepath=os.path.join('C:/Python27/Lib/site-packages/temp',"data%s.txt" % k1)
    filepath=os.path.join('C:\meenuneenu\project\libsvm-3.17\python\data',"data%s.txt" % k1)
    
    file = open(filepath, "w")
    for item in fd:
        file.write("%s " % item)
    file.close()
#delpath=os.path.join('rm C:/Python27/Lib/site-packages/temp/',"IMG-%s.png" % k)
    os.system('rm C:/Python27/Lib/site-packages/temp/IMG-4.png')
        
예제 #27
0
def do_hog(im):
    img = color.rgb2gray(im)

    fd, hog_image = hog(img, orientations=8, pixels_per_cell=(16, 16),
                        cells_per_block=(1, 1), visualise=True)
    hog_image_rescaled = hog_image # exposure.rescale_intensity(hog_image, in_range=(0, 0.02))
    return hog_image_rescaled 
예제 #28
0
def neg_hog_rand(path, num_samples, window_size, num_window_per_image):
	rows = window_size[0]
	cols = window_size[1]
	features = []
	cnt = 0
	for dirpath, dirnames, filenames in walk(path):
		for my_file in filenames:
			
			if cnt < num_samples:
				print cnt,my_file
				cnt = cnt + 1
				im = cv2.imread(path + my_file)
				image = color.rgb2gray(im)
				image_rows = image.shape[0]
				image_cols = image.shape[1]
				
				for i in range(0,num_window_per_image):
					x_min = random.randrange(0,image_rows - rows)
					y_min = random.randrange(0,image_cols - cols)

					x_max = x_min + rows
					y_max = y_min + cols
					
					image_hog = image[x_min:x_max , y_min:y_max]
					
					my_feature, _ = hog(image_hog, orientations=9, pixels_per_cell=(8, 8),cells_per_block=(2, 2), visualise=True)
					features.append(my_feature)
	return features
예제 #29
0
def extractPHOGFeature(image, level1, level2):
    ''' Extract PHOG feature from image '''
    height, width = image.shape
    orientationNum = 9
    pHOGVec = np.array([])
    widthBase = 4
    heightBase = 3
    
    for l in xrange(level1, level2 + 1):
        multi = 2 ** (l - 1)
        widthGridNum = widthBase * multi
        heightGridNum = heightBase * multi
        
        featureVector, hogImage = hog(image, orientations = orientationNum, 
                                  pixels_per_cell = (width/widthGridNum, height/heightGridNum),
                                  cells_per_block=(1, 1), visualise = True)
        
        featureVector = featureVector[np.newaxis].transpose()   # transpose to column vector
        
        if pHOGVec.size == 0:
            pHOGVec = featureVector.copy()
        else:
            pHOGVec = np.vstack((pHOGVec, featureVector))
        
    return pHOGVec
예제 #30
0
def getFeat(Data, mode, fileNames, positive):
    num = 0

    for image in Data:
        gray = rgb2gray(image)
        fd, hog_image = hog(gray, orientations, pixels_per_cell,
                            cells_per_block, block_norm, visualize, normalize, feature_vector)

        if(visualize):
            visualize(data, hog_image)

        fd_name = str(fileNames[num]) + '.feat'  # set file name

        if mode == 'train':
            if positive == True:
                fd_path = os.path.join('./features/train/positive/', fd_name)
            else:
                fd_path = os.path.join(
                    './features/train/negative/', fd_name)

        else:
            if positive == True:
                fd_path = os.path.join('./features/test/positive/', fd_name)
            else:
                fd_path = os.path.join('./features/test/negative/', fd_name)

        joblib.dump(fd, fd_path, compress=3)  # save data to local
        num += 1
        print("%d saving: ." % (num))
예제 #31
0
ax1.axis('off')

ax2.imshow(image_gb5, vmin=image.min(), vmax=image.max(), cmap='gray')
ax2.set_title('gaussian blur 5')
ax2.axis('off')

fig.tight_layout()
fig.savefig('image-gaussian_blur.png')

# In[35]:

#hog feature
(hog, hog_image) = feature.hog(image_gb3,
                               orientations=9,
                               pixels_per_cell=(8, 8),
                               cells_per_block=(4, 4),
                               block_norm='L2-Hys',
                               visualize=True,
                               transform_sqrt=True)

plt.imshow(image_raw)
plt.imshow(hog_image, alpha=0.7, cmap='hsv')

plt.show()
#plt.imwrite('hog_gb.jpg', hog_image*255)

# In[162]:

img_rgb = image_gb5

# In[163]:
 def extract_hog_feature(self, image):
     hog_feature = hog(image, orientations=9, pixels_per_cell=(16, 16), cells_per_block=(2, 2))
     return hog_feature
예제 #33
0
data = []
labels = []

#Read all images in training directory
print("Computing HOG...")
for file in paths.list_images(args["training"]):
    file = file.replace('\\', '')  #This treat if has some space in image name

    img_original = cv2.imread(file)
    img = cv2.cvtColor(img_original, cv2.COLOR_BGR2GRAY)  #Image in grayscale

    #Hog method
    (H, hogImage) = hog(img,
                        orientations=9,
                        pixels_per_cell=(8, 8),
                        cells_per_block=(2, 2),
                        transform_sqrt=True,
                        visualise=True,
                        block_norm='L2-Hys')

    #Call this function to print the HOG image
    #print_hog(hogImage, file.split('/')[-1], img_original)

    labels.append(file.split('/')[-2])
    data.append(H)

mode = args["machineLearning"]

#Training a model
if (int(mode) == 2):
    print("Training a Model with SVC...")
	# 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 = imutils.grab_contours(cnts)
	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, (224, 224))

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

	# update the data and labels
	data.append(H)
	labels.append(make)
	# "train" the nearest neighbors classifier
print("[INFO] training classifier...")
model = KNeighborsClassifier(n_neighbors=1)
model.fit(data, labels)
print("[INFO] evaluating...")



# loop over the test dataset
for (i, imagePath) in enumerate(paths.list_images(args["test"])):
	# load the test image, convert it to grayscale, and resize it to
예제 #35
0
print("brightness features")
brightness = util.loading_map(extraction.calculateDarktoBrightRatio, resized)
print("hsv 11 + std")
hsv_11_std = util.loading_map(
    lambda x: extraction.split_image_features(
        lambda y: extraction.color_features(y, mean=True, std=True), 11, x),
    hsv)
print("luv features")
luv_features = util.loading_map(lambda x: extraction.pixel_features(x, 11),
                                luv)
print("hog features")
hog = util.loading_map(
    lambda x: feature.hog(x,
                          orientations=6,
                          pixels_per_cell=(12, 12),
                          cells_per_block=(8, 8),
                          normalise=True), grayscaled)
print("corner features")
corners = util.loading_map(
    lambda x: extraction.pixel_features(
        numpy.sqrt(feature.corner_shi_tomasi(x, sigma=8)), 8), grayscaled)

n_folds = 10

model = Pipeline([("standard scaler", StandardScaler()),
                  ("logistic regression",
                   LogisticRegression(solver='lbfgs',
                                      multi_class='multinomial'))])

print("Evaluating brightness features")
def HOG_SVM_detector(image_path, model_path):
    ori_img = cv2.imread(image_path)
    if type(model_path) == str:
        model = joblib.load(model_path)
    else:
        model = model_path
    # print(type(model_path)==str)
    # 将图像裁剪到最大宽度为400个像素,之所以降低我们的图像维度(其实就是之所以对我们的图像尺寸进行裁剪)主要有两个原因:
    # 1. 减小图像的尺寸可以减少在图像金字塔中滑窗的数目,如此可以降低检测的时间,从而提高整体检测的吞吐量。
    # 2. 调整图像的尺寸能够整体提高行人检测的精度。
    minAxis_Image = 400
    img = imutils.resize(ori_img,
                         width=min(minAxis_Image,
                                   ori_img.shape[1]))  # 修改的图像是以最小的那个数字对齐
    # 用于之后复原图片
    HO, WO, _ = ori_img.shape
    HR, WR, _ = img.shape

    # 改 程序运行时间过长,将参数改大,注释中是 论文参数
    # 这个设置是按照开创性的 Dalal 和 Triggs 论文来设置的 Histograms of Oriented Gradients for Human Detection
    win_size = (64, 128)  # 窗口的大小固定在64*128像素大小
    step_size = (5, 5)  # 一个分别在x方向和y方向步长为(4,4)像素大小的滑窗
    downscale = 1.2  # 尺度 scale=1.05 的图像金字塔
    threshold = 0.6  # 设定 SVM 预测的阈值,即只有当预测的概率大于 0.6 时,才会确定支持向量机的预测
    overlapThresh = 0.3  # nms

    rectangles = []
    scores = []
    scale = 0
    for img_scale in pyramid_gaussian(img, downscale=downscale):
        if img_scale.shape[0] < win_size[1] or img_scale.shape[1] < win_size[0]:
            break

        for (x, y, img_window) in sliding_window(img_scale, win_size,
                                                 step_size):
            if img_window.shape[0] != win_size[1] or img_window.shape[
                    1] != win_size[
                        0]:  # ensure the sliding window has met the minimum size requirement
                continue

            fd = hog(rgb2gray(img_window),
                     orientations=9,
                     pixels_per_cell=(8, 8),
                     cells_per_block=(2, 2))
            fd = fd.reshape(1, -1)
            predict = model.predict(fd)
            score = model.decision_function(fd)[0]
            if predict == 1 and score > threshold:
                x = int(x * (downscale**scale))
                y = int(y * (downscale**scale))
                w = int(win_size[0] * (downscale**scale))
                h = int(win_size[1] * (downscale**scale))
                rectangles.append((x, y, x + w, y + h))
                scores.append(score)
        scale += 1
    rectangles = np.array(rectangles)
    scores = np.array(scores)
    bounding_boxes = non_max_suppression(rectangles,
                                         probs=scores,
                                         overlapThresh=overlapThresh)

    # print("rectangles.shape : ", rectangles.shape)
    # print("bounding_boxes.shape : ", bounding_boxes.shape)
    # 如果检测到了内容
    if rectangles.shape[0] > 0:
        # 复原
        rectangles = rectangles.astype(float)
        rectangles[:, [0, 2]] *= (WO / WR)
        rectangles[:, [1, 3]] *= (HO / HR)
        rectangles = rectangles.astype(int)

        bounding_boxes = bounding_boxes.astype(float)
        bounding_boxes[:, [0, 2]] *= (WO / WR)
        bounding_boxes[:, [1, 3]] *= (HO / HR)
        bounding_boxes = bounding_boxes.astype(int)

    # print("rectangles.shape : ", rectangles.shape)
    # print("bounding_boxes.shape : ", bounding_boxes.shape)
    # print(bounding_boxes)
    # return rectangles, bounding_boxes
    return bounding_boxes
예제 #37
0
    labels = []

    #fill the training dataset
    # the flow is
    # 1) load sample
    # 2) resize it to (200,200) so that we have same size for all the images
    # 3) get the HOG features of the resized image
    # 4) save them in the data list that holds all the hog features
    # 5) also save the label (target) of that sample in the labels list
    for filename in brian_filenames:
        #read the images
        image = imread(filename, 1)
        #flatten it
        image = imresize(image, (200, 200))
        hog_features = hog(image,
                           orientations=12,
                           pixels_per_cell=(16, 16),
                           cells_per_block=(1, 1))
        data.append(hog_features)
        labels.append(0)
    print 'Finished adding brians samples to dataset'

    for filename in alfin_filenames:
        image = imread(filename, 1)
        image = imresize(image, (200, 200))
        hog_features = hog(image,
                           orientations=12,
                           pixels_per_cell=(16, 16),
                           cells_per_block=(1, 1))
        data.append(hog_features)
        labels.append(1)
    print 'Finished adding alfins samples to dataset'
예제 #38
0
def get_hog(img):
    hog_image = hog(img,
                    orientations=10,
                    pixels_per_cell=(5, 5),
                    cells_per_block=(3, 3))
    return exposure.rescale_intensity(hog_image, in_range=(0, 0.9))
def calculate_hog(img):
    return feature.hog(img,
                       orientations=8,
                       pixels_per_cell=(32, 32),
                       cells_per_block=(8, 8),
                       block_norm='L2-Hys')

# read the image
img = cv2.imread("dataset/digits.png")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# break up the image into individual digits
cells = [np.hsplit(row, 100) for row in np.vsplit(gray, 50)]


# compute the HOG features for each digit and make a dataset
dataset = []
for i in range(50):
    for j in range(100):
        feature = hog(cells[i][j],
                      pixels_per_cell=(10, 10),
                      cells_per_block=(1, 1))
        dataset.append(feature)
dataset = np.array(dataset, 'float64')


# make labels for all 5000 digits
labels = []
for i in range(10):
    labels = labels + [i] * 500


# use the KNN algorithm for training
clf = KNeighborsClassifier()
x_train, x_test, y_train, y_test = tts(dataset, labels, test_size=0.3)
예제 #41
0
        im_gray1)  # Extract out the object and place into output imag
    out[mask == 255] = im_gray1[mask == 255]
    lower_value = np.array([60])
    upper_value = np.array([200])
    # Threshold the HSV image to get only blue colors
    mask = cv2.inRange(out, lower_value, upper_value)
    # Bitwise-AND mask and original image
    out = cv2.bitwise_and(out, out, mask=mask)
    v = out[out[:, :] > 0]
    #    print(v.mean())

    out[out[:, :] < (u.mean())] = 255
    out[out[:, :] > (u.mean() + 10)] = 0
    fd = hog(out.reshape((512, 512)),
             orientations=9,
             pixels_per_cell=(14, 14),
             cells_per_block=(1, 1),
             visualise=False)

    features.append(fd)
    hog_features = np.array(features, 'float64')
    labels.append("true")

    #    cv2.imshow("TestImageGry", im_gray)
    #    cv2.imshow("TestImage", imq)
    i = i + 1
    #    cv2.waitKey()
    #    inp=input()
    print(i)
    if i is 32:
        test = False
            # curImageCropped.save("processed_alpha_test/" + imagename)

# Crop images to 900 x 900
# img2 = curImage.crop((0, 0, 900, 900))
# img2.save("processed_alpha_test/img_a.png")

# Save image > matrix

# Save label

list_hog_fd = []
for feature in letter_image_features:
    print "feature", feature
    fd = hog(feature.reshape((28, 28)),
             orientations=9,
             pixels_per_cell=(14, 14),
             cells_per_block=(1, 1),
             visualise=False)
    list_hog_fd.append(fd)
hog_features = np.array(list_hog_fd, 'float64')

print "Count of digits in dataset", Counter(labels)

# Create an linear SVM object
clf = LinearSVC()

# Perform the training
clf.fit(hog_features, labels)

# Save the classifier
joblib.dump(clf, "digits_cls_alpha1.pkl", compress=3)
예제 #43
0
if testEdgeDetection:
    edge = cv2.Canny(cv2.cvtColor(im, cv2.COLOR_RGB2GRAY),100,300)
    plot.figure(plotIndex)
    plotIndex += 1
    plot.clf()
    plot.imshow(edge)

# *************************************************

if trainClassifier:
    l = []
    for i in range(len(trainingImages)):
        if trainFromHSVImage:
            l.append(labels[i])
            hsv = cv2.cvtColor(trainingImages[i], cv2.COLOR_RGB2HSV)
            feat = hog(hsv[:,:,1], orientations=5, pixels_per_cell=(7, 7), cells_per_block=(2, 2), block_norm='L1-sqrt', visualise=False)
            normalizedFeatures = StandardScaler().fit(feat.reshape(-1, 1)).transform(feat.reshape(-1, 1))
            if (i == 0):
                features = normalizedFeatures
            else:
                features = np.column_stack((features, normalizedFeatures))
        if trainFromEdgeImage:
            l.append(labels[i])
            edge = cv2.Canny(cv2.cvtColor(trainingImages[i], cv2.COLOR_RGB2GRAY),50,100)
            feat = hog(edge, orientations=5, pixels_per_cell=(7, 7), cells_per_block=(2, 2), block_norm='L1-sqrt', visualise=False)
            normalizedFeatures = StandardScaler().fit(feat.reshape(-1, 1)).transform(feat.reshape(-1, 1))
            if (i == 0) and not (trainFromHSVImage):
                features = normalizedFeatures
            else:
                features = np.column_stack((features, normalizedFeatures))
    svm = SVC(kernel='rbf').fit(features.T,np.array(l))
예제 #44
0
파일: test.py 프로젝트: zipdang04/Python
f = os.popen("ls /dev/ttyACM*")
usbPort = f.read()
usbPort = usbPort[0:len(usbPort) - 1]
ser = serial.Serial(usbPort, 9600)
print("connect succesfully")
while True:
    img = cv2.imread('image.jpg', 0)
    mi = 1.0
    xx = 0
    yy = 0
    img = cv2.flip(img, 1)
    img = cv2.resize(img, (160, 120))
    for ii in range(16):
        for jj in range(9):
            frame = img[jj * 8:jj * 8 + 56, ii * 8:ii * 8 + 40]
            out = feature.hog(frame, visualise=False, feature_vector=True)
            compare = arr - out
            x = 0.0
            for i in compare:
                x += i**2
            x /= 1215.0
            x = math.sqrt(x)
            if x < mi:
                mi = x
                xx = ii
                yy = jj
    print('min:', mi, ' at ', xx, '-', yy)
    if mi <= maxCorrect:
        if yy > high:
            cv2.rectangle(img, (xx * 8 - 1, yy * 8 - 1),
                          (xx * 8 + 40, yy * 8 + 56), (255, 255, 255))
from sklearn.model_selection import train_test_split
from sklearn import svm, datasets
from skimage import color,transform
import matplotlib.image as mpimg
from skimage.feature import hog

X = []
Y = []

dataset_size = 12500
datasetpath = "dataset/train/"
for i in range(dataset_size):
    img_name  = datasetpath+"cat." + str(i) + '.jpg'
    img_cat = color.rgb2gray(mpimg.imread(img_name))
    img = transform.resize(img_cat, (128,64) , mode='constant')
    fcat, hog_img = hog(img, orientations = 9, pixels_per_cell = (8,8),cells_per_block = (2,2), visualise = True , block_norm='L2-Hys')
    X.append(fcat)
    Y.append(0)

for i in range(dataset_size):
    img_name  =  datasetpath +"dog." + str(i) + '.jpg'
    img_dog = color.rgb2gray(mpimg.imread(img_name))
    img = transform.resize(img_dog, (128, 64) , mode='constant')
    fdog, hog_img = hog(img, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualise=True , block_norm='L2-Hys')
    X.append(fdog)
    Y.append(1)

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size = 0.30)


svc = svm.SVC(kernel='poly', C=1 , degree=1).fit(X_train, y_train)
예제 #46
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 25 21:56:30 2021

@author: batuhan
"""
import matplotlib.pyplot as plt
from skimage.feature import hog
from skimage import data, exposure
image = data.astronaut()
fd, hog_image = hog(image, orientations=8, pixels_per_cell=(16, 16),
 cells_per_block=(1, 1), visualize=True, multichannel=True)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)
ax1.axis('off')
ax1.imshow(image, cmap=plt.cm.gray)
ax1.set_title('Input image')
# Rescale histogram for better display
hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 10))
ax2.axis('off')
ax2.imshow(hog_image_rescaled, cmap=plt.cm.gray)
ax2.set_title('Histogram of Oriented Gradients')
plt.show()
예제 #47
0
def testImage(path, args):
    # Read the image
    #im = imread(args["image"], as_grey=False)
    im = cv2.imread(path, cv2.IMREAD_GRAYSCALE)  # read img from file
    min_wdw_sz = (24, 48)
    step_size = (5, 5)
    downscale = args['downscale']
    visualize_det = args['visualize']

    # Load the classifier
    clf = joblib.load("../myData/traffic.model6")

    # List to store the detections
    detections = []
    # The current scale of the image
    scale = 0
    # Downscale the image and iterate
    for im_scaled in pyramid_gaussian(im, downscale=downscale):
        # This list contains detections at the current scale
        cd = []
        # If the width or height of the scaled image is less than
        # the width or height of the window, then end the iterations.
        if im_scaled.shape[0] < min_wdw_sz[1] or im_scaled.shape[
                1] < min_wdw_sz[0]:
            break
        for (x, y, im_window) in sliding_window(im_scaled, min_wdw_sz,
                                                step_size):
            if im_window.shape[0] != min_wdw_sz[1] or im_window.shape[
                    1] != min_wdw_sz[0]:
                continue
            # Calculate the HOG features
            fd = hog(im_window,
                     orientations,
                     pixels_per_cell,
                     cells_per_block,
                     block_norm="L1",
                     visualise=False,
                     transform_sqrt=True,
                     feature_vector=True)
            fd = [fd]  # clf wants a list of samples
            #pred = clf.predict(fd)
            probs = list(clf.predict_proba(fd)[0])
            #print(pred)
            pred = probs.index(max(probs))  # index of max
            # TODO: use all my labels
            if pred != 0 and probs[pred] > 0.80:
                print("prediction is " + str(pred))
                print(probs)
                #plt.imshow(im_window)
                #plt.show()
                print("Detection:: Location -> ({}, {})".format(x, y))
                print("Scale ->  {} | Confidence Score {} \n".format(
                    scale, probs[pred]))
                detections.append((x, y, probs[pred],
                                   int(min_wdw_sz[0] * (downscale**scale)),
                                   int(min_wdw_sz[1] * (downscale**scale))))
                cd.append(detections[-1])
            # If visualize is set to true, display the working
            # of the sliding window
            if visualize_det:
                clone = im_scaled.copy()
                for x1, y1, _, _, _ in cd:
                    # Draw the detections at this scale
                    cv2.rectangle(
                        clone, (x1, y1),
                        (x1 + im_window.shape[1], y1 + im_window.shape[0]),
                        (0, 0, 0),
                        thickness=2)
                cv2.rectangle(clone, (x, y),
                              (x + im_window.shape[1], y + im_window.shape[0]),
                              (255, 255, 255),
                              thickness=2)
                cv2.imshow("Sliding Window in Progress", clone)
                cv2.waitKey(30)
        # Move the the next scale
        scale += 1

    # Display the results before performing NMS
    clone = im.copy()
    for (x_tl, y_tl, _, w, h) in detections:
        # Draw the detections
        cv2.rectangle(im, (x_tl, y_tl), (x_tl + w, y_tl + h), (0, 0, 0),
                      thickness=2)
    cv2.imshow("Raw Detections before NMS", im)
    cv2.waitKey()

    # Perform Non Maxima Suppression
    detections = nms(detections, threshold)

    # Display the results after performing NMS
    for (x_tl, y_tl, _, w, h) in detections:
        # Draw the detections
        cv2.rectangle(clone, (x_tl, y_tl), (x_tl + w, y_tl + h), (0, 0, 0),
                      thickness=2)

    # save image to file
    fname = path[::-1]  # reverse the string
    index = fname.find("/")
    fname = fname[:index][::-1]  # isolate just the file name and reverse back
    cv2.imwrite(fname, clone)
    print("saved to " + str(fname))
    cv2.imshow("Final Detections after applying NMS", clone)
    cv2.waitKey()
    cv2.destroyAllWindows()
예제 #48
0
    imgs = []
    labels = []
    label_counter = 0
    file_counter = 0

    for c in c_list:
            curr_dir = os.path.join(args.data, c)
            f_list = os.listdir(curr_dir)
            f_list.sort()

            print('Reading class:', c)

            for f in f_list:
                    f_path = os.path.join(curr_dir, f)
                    img = imread(f_path)
                    feats = hog(img, orientations=9, pixels_per_cell=(16, 16), cells_per_block=(3, 3), block_norm='L2',
                                visualize=False, transform_sqrt=False, feature_vector=True, multichannel=True)
                    if args.subsample:
                            if file_counter % 10 == 0:
                                    imgs.append(feats)
                                    labels.append(label_counter)
                    else:
                            imgs.append(feats)
                            labels.append(label_counter)

                    file_counter += 1

            label_counter += 1

    imgs = np.vstack(imgs)
    labels = np.array(labels)
예제 #49
0
mndata = MNIST('data')
tr_imgs, tr_lbs = mndata.load_training()
test_imgs, test_lbs = mndata.load_testing()

new_tr_lbs = [item for item in tr_lbs]
new_test_lbs = [item for item in test_lbs]

print(purity_score([2, 1, 2, 3, 2, 2, 3, 1], [1, 1, 2, 3, 2, 2, 3, 1]))

new_train = []
for img in tr_imgs:
    pixels = np.array(img, dtype='uint8')
    pixels = pixels.reshape((28, 28))
    pixels = deskew(pixels)
    pixels = np.pad(pixels, ((4, 4), (4, 4)), mode='constant')
    img_hog = hog(pixels, block_norm='L2-Hys')
    new_train.append(img_hog)

print('here')
new_test = []
for img in test_imgs:
    pixels = np.array(img, dtype='uint8')
    pixels = pixels.reshape((28, 28))
    pixels = deskew(pixels)
    # print(np.shape(pixels))
    pixels = np.pad(pixels, ((4, 4), (4, 4)), mode='constant')
    img_hog = hog(pixels, block_norm='L2-Hys')
    # print(np.shape(img_hog))
    new_test.append(img_hog)
print(np.shape(new_train))
예제 #50
0
def quantify_images(image):
    features = feature.hog(image, orientations=9, pixels_per_cell=(10,10), cells_per_block=(2,2),
     transform_sqrt=True, block_norm='L1')
    return features
예제 #51
0
def hogProcess(image):
    fd, hog_image = hog(image, orientations=8, pixels_per_cell=(8,8), cells_per_block=(1, 1), visualize=True, multichannel=False)
    return hog_image
#  cambio a binario
ret, im_th = cv2.threshold(im_gray, 90, 255, cv2.THRESH_BINARY_INV)

# busco la figura en la imagen
ctrs, hier = cv2.findContours(im_th.copy(), cv2.RETR_EXTERNAL,
                              cv2.CHAIN_APPROX_SIMPLE)

# cuento figuras encontradas
rects = [cv2.boundingRect(ctr) for ctr in ctrs]

for rect in rects:
    cv2.rectangle(im, (rect[0], rect[1]),
                  (rect[0] + rect[2], rect[1] + rect[3]), (0, 255, 0), 3)
    leng = int(rect[3] * 1.4)
    pt1 = int(rect[1] + rect[3] // 2 - leng // 2)
    pt2 = int(rect[0] + rect[2] // 2.5 - leng // 2)
    roi = im_th[pt1:pt1 + leng, pt2:pt2 + leng]

    roi = cv2.resize(roi, (28, 28), interpolation=cv2.INTER_AREA)
    roi = cv2.dilate(roi, (3, 3))

    roi_hog_fd = hog(roi,
                     orientations=9,
                     pixels_per_cell=(14, 14),
                     cells_per_block=(1, 1))
    nbr = clf.predict(np.array([roi_hog_fd], 'float64'))
    cv2.putText(im, str(int(nbr[0])), (rect[0], rect[1]),
                cv2.FONT_HERSHEY_DUPLEX, 2, (0, 255, 255), 3)

cv2.imshow("Resulting Image with Rectangular ROIs", im)
cv2.waitKey()
예제 #53
0
        print('removing', file_path)
        os.unlink(file_path)

print("Calculating the descriptors for the positive samples and saving them")
for im_path in glob.glob(os.path.join(pos_im_path, "*")):
    print("Working on file: ", im_path)

    # Read image and convert to grayscale
    im = cv2.imread(im_path)
    gray_im = cv2.cvtColor(im, cv2.COLOR_RGB2GRAY)

    resize_im = cv2.resize(gray_im, scale_size)
    # Resize the image
    fd = hog(resize_im,
             orientations=orientations,
             pixels_per_cell=pixels_per_cell,
             cells_per_block=cells_per_block,
             visualise=False)

    # Save features
    fd_name = os.path.split(im_path)[1].split(".")[0] + ".feat"
    fd_path = os.path.join(pos_feat_dir, fd_name)
    joblib.dump(fd, fd_path)
print("Positive features saved in {}".format(pos_feat_dir))

print("Calculating the descriptors for the negative samples and saving them")
for im_path in glob.glob(os.path.join(neg_im_path, "*")):
    print("Working on file: ", im_path)

    im = cv2.imread(im_path)
    gray_im = cv2.cvtColor(im, cv2.COLOR_RGB2GRAY)
예제 #54
0
파일: cross.py 프로젝트: LegendBC/Code
    img[..., 1] = np.reshape(data[1024:2048], (32, 32))
    img[..., 2] = np.reshape(data[2048:3072], (32, 32))
    return img

batches_meta = unpack(DATA_PATH + "batches.meta")
data_batches = [
    unpack(DATA_PATH + "data_batch_" + str(i+1))
    for i in range(5)
]
test_batch = unpack(DATA_PATH + "test_batch")

from skimage.color import rgb2gray
from skimage.feature import hog

for i in range(5):
    data_batches[i][b"data"] = [hog(rgb2gray(reshape(img))) for img in data_batches[i][b"data"]]

test_batch[b"data"] = [hog(rgb2gray(reshape(img))) for img in test_batch[b"data"]]

hyperparam_train_data = data_batches[0][b"data"][:900]
hyperparam_train_labels = data_batches[0][b"labels"][:900]
hyperparam_test_data = data_batches[0][b"data"][900:1000]
hyperparam_test_labels = data_batches[0][b"labels"][900:1000]

import datetime
begin = datetime.datetime.now()
ks = [2, 3, 4, 5, 6, 7, 8, 9, 10]
correct_sums = []

for k in ks:
    clf = neighbors.KNeighborsClassifier(k, weights="distance")
예제 #55
0
import numpy as np
import os
import scipy.ndimage
import imageio
from skimage.feature import hog
from skimage import data, color, exposure
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.externals import joblib

knn = joblib.load('model/knn_model.pkl')
image = imageio.imread('dataSet/9/IMG_49421.png')

image = color.rgb2gray(image)
df = hog(image,
         orientations=8,
         pixels_per_cell=(10, 10),
         cells_per_block=(5, 5))

predict = knn.predict(df.reshape(1, -1))[0]
print(predict)
예제 #56
0
for i in vals:
    if i[1] <= (int(q) + 50) and i[1] >= (int(q) - 50):
        vds.append(i)
nums = []

for rect in vds:
    cv2.rectangle(im, (rect[0], rect[1]),
                  (rect[0] + rect[2], rect[1] + rect[3]), (0, 255, 0), 3)
    leng = int(rect[3] * 1.6)
    pt1 = int(rect[1] + rect[3] // 2 - leng // 2)
    pt2 = int(rect[0] + rect[2] // 2 - leng // 2)
    roi = im_th[pt1:pt1 + leng, pt2:pt2 + leng]
    roi = cv2.resize(roi, (28, 28), interpolation=cv2.INTER_AREA)
    roi = cv2.dilate(roi, (3, 3))
    roi_hog_fd = hog(roi,
                     orientations=9,
                     pixels_per_cell=(14, 14),
                     cells_per_block=(1, 1),
                     visualise=False)
    nbr = clf.predict(np.array([roi_hog_fd], 'float64'))
    nums.append(nbr[0])
    cv2.putText(im, str(int(nbr[0])), (rect[0], rect[1]),
                cv2.FONT_HERSHEY_DUPLEX, 2, (0, 255, 255), 3)

print('vals', vals)
print(nums)
print(vds)

cv2.imshow("Resulting Image with Rectangular ROIs", im)
cv2.waitKey()
예제 #57
0
# Import the modules
from sklearn.externals import joblib
from sklearn import datasets
from skimage.feature import hog
from sklearn.svm import LinearSVC
import numpy as np
X,y= datasets.fetch_openml('mnist_784', version=1, return_X_y=True)                                                                        #importing datset and labels straight from sklearn
Images = np.array(X, 'int16')                                                                                                              #converting list of Images into a numpy array.
labels = np.array(y, 'int')
list_hog_fd = []
for Image in Images:
    fd = hog(Image.reshape((28, 28)), orientations=9, pixels_per_cell=(14, 14), cells_per_block=(1, 1), visualize=False,block_norm='L2')    # using hog algorithm to extract features from each image
    list_hog_fd.append(fd)                                                                                                                  #adding the hog features extracted from the image into a list
hog_features = np.array(list_hog_fd, 'float64')                                                                                             #converting the HOG feature list into a numpy array

'''
Two line code to train entire dataset
load the LinearSVC() model into clf
and then fit hog_features and list into clf
'''
clf = LinearSVC()
clf.fit(hog_features,labels)

print('Accuracy is:',clf.score(hog_features,labels)*100,'%')
joblib.dump(clf, "digits_cls.pkl", compress=3)         
예제 #58
0
# In[17]:

#load image and convert into gray image
gray_sample = cv2.imread(file_list[0], 0)

# In[18]:

print(gray_sample.shape)
print(gray_sample)

# In[19]:

fd, hog_image = hog(gray_sample,
                    orientations=8,
                    pixels_per_cell=(16, 16),
                    cells_per_block=(1, 1),
                    visualise=True)

# In[20]:

print(hog_image.shape)

# In[21]:

print(hog_image)

# In[22]:

print(fd)
예제 #59
0
x_train = x_train_full[0:73500]
y_train = y_train_full[0:73500]
x_test = x_test_full[0:18000]
y_test = y_test_full[0:18000]
print(x_test.shape)
print(y_test.shape)

y_train = y_train.ravel()
y_test = y_test.ravel()

df_1 = []

for i in range(0, x_train.shape[0]):

    df1 = hog(np.reshape(x_train[i], (32, 32)),
              orientations=8,
              pixels_per_cell=(8, 8),
              cells_per_block=(4, 4))
    df_1.append(df1)
x_train = np.array(df_1, 'float64')

df_2 = []

for i in range(0, x_test.shape[0]):

    df2 = hog(np.reshape(x_test[i], (32, 32)),
              orientations=8,
              pixels_per_cell=(8, 8),
              cells_per_block=(4, 4))
    df_2.append(df2)
x_test = np.array(df_2, 'float64')
print('Shape of Training data after HOG is: ' + str(x_train.shape))
예제 #60
0
def compute_descriptor(im, sp, spPatch=15, colBins=20, hogCells=9,
                        hogBins=6, redirect=False):
    """
    Compute region descriptors for NLC
    Input:
        im: (h,w,c) or (n,h,w,c): 0-255: np.uint8: RGB
        sp: (h,w) or (n,h,w): 0-indexed regions, #regions <= numsp
        spPatch: patchsize around superpixel for feature computation
    Output:
        regions: (k,d) where k < numsp*n
        frameEnd: (n,): indices of regions where frame ends: 0-indexed, included
    """
    sTime = time.time()
    if im.ndim < 4:
        im = im[None, ...]
        sp = sp[None, ...]

    hogCellSize = int(spPatch / np.sqrt(hogCells))
    n, h, w, c = im.shape
    d = 6 * colBins + hogCells * hogBins + 2
    numsp = np.max(sp) + 1  # because sp are 0-indexed
    regions = np.ones((numsp * n, d), dtype=np.float) * -1e6
    frameEnd = np.zeros((n,), dtype=np.int)
    count = 0
    for i in range(n):
        boxes = get_region_boxes(sp[i])

        # get patchsize around center; corner cases handled inside loop
        boxes[:, :2] = ((boxes[:, :2] + boxes[:, 2:] - spPatch) / 2)
        boxes = boxes.astype(np.int)
        boxes[:, 2:] = boxes[:, :2] + spPatch

        for j in range(boxes.shape[0]):
            # fix corner cases
            xmin, xmax = np.maximum(0, np.minimum(boxes[j, [0, 2]], w - 1))
            ymin, ymax = np.maximum(0, np.minimum(boxes[j, [1, 3]], h - 1))
            xmax = spPatch if xmin == 0 else xmax
            xmin = xmax - spPatch if xmax == w - 1 else xmin
            ymax = spPatch if ymin == 0 else ymax
            ymin = ymax - spPatch if ymax == h - 1 else ymin

            imPatch = im[i, ymin:ymax, xmin:xmax]
            hogF = hog(
                color.rgb2gray(imPatch), orientations=hogBins,
                pixels_per_cell=(hogCellSize, hogCellSize),
                cells_per_block=(int(np.sqrt(hogCells)),
                                    int(np.sqrt(hogCells))),
                visualise=False)
            colHist = color_hist(imPatch, colBins)
            regions[count, :] = np.hstack((
                hogF, colHist, [boxes[j, 1] * 1. / h, boxes[j, 0] * 1. / w]))
            count += 1
        frameEnd[i] = count - 1
        if not redirect:
            sys.stdout.write('Descriptor computation: [% 5.1f%%]\r' %
                                (100.0 * float((i + 1) / n)))
            sys.stdout.flush()
    regions = regions[:count]
    eTime = time.time()
    print('Descriptor computation finished: %.2f s' % (eTime - sTime))

    return regions, frameEnd