python类hog()的实例源码

def getFeat(data):
    normalize = True
    visualize = False
    block_norm = 'L2-Hys'
    cells_per_block = [2,2]
    pixels_per_cell = [20,20]
    orientations = 9
    gray = rgb2gray(data)/255.0
    fd = hog(gray, orientations, pixels_per_cell, cells_per_block, block_norm, visualize, normalize)
    return fd

def getFeat(data):
    gray = rgb2gray(data)/255.0
    fd = hog(gray, orientations, pixels_per_cell, cells_per_block, block_norm, visualize, normalize)
    return fd

def _extract(self, images, coords, mapping, args):
        assert images.shape[1] == images.shape[2]
        n_inst = coords.shape[0]

        nb = args.get('num_bins', 8)
        win_sizes = args.get('window_sizes', 32)
        win_sizes = win_sizes if isinstance(win_sizes, np.ndarray) else np.ones((n_inst,), dtype=np.int32) * win_sizes

        # Prepare descriptors
        descriptors = np.zeros(tuple(coords.shape[:2])+(nb*4*4,), dtype=np.float32)

        # Fill descriptors
        coords, vis = np.copy(coords), np.zeros(coords.shape[:2], dtype=np.bool)
        for i, (c, mp, ws) in enumerate(zip(coords, mapping, win_sizes)):
            hsize, qsize = ws/2, ws/4

            # Pad image, set landmarks visibility
            im, c = np.pad(images[mp, ...], ((hsize, hsize), (hsize, hsize)), 'constant', constant_values=0), c+hsize
            ims = im.shape[0] - hsize
            vis[i, :] = (c[:, 0] >= hsize) & (c[:, 1] >= hsize) & (c[:, 0] < ims) & (c[:, 1] < ims)

            # Extract descriptors from each interest window
            for j, (jc, jv) in enumerate(zip(c, vis[i, :])):
                descriptors[i, j, :] = hog(
                    im[jc[0]-hsize:jc[0]+hsize, jc[1]-hsize:jc[1]+hsize],
                    orientations=nb,
                    pixels_per_cell=(qsize, qsize),
                    cells_per_block=(1, 1)
                ) if jv else 0

        # Normalize descriptors, return extracted information
        return descriptors.reshape((len(mapping), -1)), vis

def _extract(self, images, coords, mapping, args):
        assert images.shape[1] == images.shape[2]
        n_inst = coords.shape[0]

        nb = args.get('num_bins', 8)
        rotations = args.get('rotations', np.zeros((n_inst,), dtype=np.float32))
        win_sizes = args.get('window_sizes', 32)
        win_sizes = win_sizes if isinstance(win_sizes, np.ndarray) else np.ones((n_inst,), dtype=np.int32) * win_sizes

        # Prepare descriptors
        descriptors = np.zeros(tuple(coords.shape[:2])+(nb*4*4,), dtype=np.float32)

        # Fill descriptors
        coords, vis = np.copy(coords) - images.shape[1] / 2.0, np.empty(coords.shape[:2], dtype=np.bool)
        for i, (c, r, mp, ws) in enumerate(zip(coords, rotations, mapping, win_sizes)):
            hsize, qsize = ws/2, ws/4

            # Get maximum window half-size, rotate and pad image
            im = np.pad(
                rotate(images[mp, ...], 57.2957*r),
                ((hsize, hsize), (hsize, hsize)),
                'constant', constant_values=0
            )

            # Rotate geometry, set landmarks visibility
            ims = im.shape[0] - hsize
            c = np.dot(c, np.array([[np.cos(r), np.sin(r)], [-np.sin(r),  np.cos(r)]])) + im.shape[0] / 2.0
            vis[i, :] = (c[:, 0] >= hsize) & (c[:, 1] >= hsize) & (c[:, 0] < ims) & (c[:, 1] < ims)

            # Extract descriptors from each interest window
            for j, (jc, jv) in enumerate(zip(c, vis[i, :])):
                descriptors[i, j, :] = hog(
                    im[jc[0]-hsize:jc[0]+hsize, jc[1]-hsize:jc[1]+hsize],
                    orientations=nb,
                    pixels_per_cell=(qsize, qsize),
                    cells_per_block=(1, 1)
                ) if jv else 0

        # Normalize descriptors, return extracted information
        return descriptors.reshape((len(mapping), -1)), vis

def extract_pos_hog_features2(path, num_samples):
    features = []
    cnt = 0
    for dirpath, dirnames, filenames in walk(path):
        for my_file in filenames:
            if cnt < num_samples:
                cnt = cnt + 1
                im = cv2.imread(path + my_file)
                image = color.rgb2gray(im)
                my_feature, _ = hog(image, orientations=9, pixels_per_cell=(8, 8),cells_per_block=(2, 2), visualise=True)
                features.append(my_feature)
    return features

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

def detector(my_im, weight,bias, scale):
    window_size = [128, 64]
    block_size = 4
    cell_size = 8
    min_height = 128
    min_width = 64
    orient = 9
    thresh = 0

    total_block_size = block_size * cell_size; 

    curr_depth = 0

    for im in ip.createImagePyramid(my_im, scale, min_height, min_width):
        curr_depth +=1
        H = im.shape[0]
        W = im.shape[1]
        dim_size_feat = weight.shape[1];
        for h in xrange(0,H,total_block_size / 2):
            for w in xrange(0,W,total_block_size / 2):
                if ((window_size[1] + w <= W) and (window_size[0]+h) <= H):
                    fd, _ = hog(im[h:(window_size[0]+h), w:(window_size[1]+w)], orientations=orient, pixels_per_cell=(cell_size, cell_size),
                    cells_per_block=(block_size, block_size), visualise=True)

                    score_calc =  np.dot(np.reshape(fd, (1, dim_size_feat)) , np.transpose(weight)) + bias
                    if(score_calc[0][0] >= thresh):
                        print score_calc[0][0]
                        cv2.imshow("Detected Pedestrian", my_im)
                        cv2.waitKey(25)
                        return score_calc[0][0]

    return False