python类hog()的实例源码

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=True, 
                                  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=True, 
                       visualise=vis, feature_vector=feature_vec)
        return features

# Define a function to compute binned color features

def __update_state(self):
        """
        Updates the state space (self.gamestate) after the suggested action is taken
        :return: None
        """
        jigsaw_id, place_id = self.decode_action()
        self.__update_placed_pieces(jigsaw_id, place_id)
        if self.state_type == 'hog':
            self.__render_gamestate()
        elif self.state_type == 'image':
            resized_discrete_im = np.digitize(
                            imresize(self.jigsaw_image, (self.state_height, self.state_width)),
                            self.bins)
            self.gamestate = np.array([resized_discrete_im]).transpose().swapaxes(0, 1)

        else:
            ValueError('The state type is not valid, enter "hog" or "image"')

def trainClassifier(foldername,classifierName):
    model = cv2.ml.KNearest_create()
    features = []
    labels = []
    os.chdir(foldername)
    for filename in glob.iglob('*.png'):
        features.append(cv2.imread((filename),-1))
        labels.append(filename[0])
    list_hog_fd = []
    for feature in features:
        fd = hog(feature.reshape((27, 35)), orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)
        list_hog_fd.append(fd)
    hog_features = np.array(list_hog_fd, 'float64')
    os.chdir("..")
    clf = LinearSVC()
    clf.fit(hog_features, labels)
    joblib.dump(clf,classifierName, compress=3)
    os.chdir("..")

def getFeat(Data,mode): # get and save feature valuve
    num = 0  
    for data in Data:  
        image = np.reshape(data[0], (200, 200, 3)) 
        gray = rgb2gray(image)/255.0 # trans image to gray
        fd = hog(gray, orientations, pixels_per_cell, cells_per_block, block_norm, visualize, normalize)  
        fd = np.concatenate((fd, data[1])) # add label in the end of the array
        filename = list(data[2])  
        fd_name = filename[0].split('.')[0]+'.feat' # set file name  
        if mode == 'train':  
            fd_path = os.path.join('./features/train/', fd_name)  
        else:  
            fd_path = os.path.join('./features/test/', fd_name)  
        joblib.dump(fd, fd_path,compress=3) # save data to local  
        num += 1  
        print "%d saving: %s." %(num,fd_name)

def extract_pos_hog_features(path, num_samples):

    features = []
    cnt = 0
    for dirpath, dirnames, filenames in walk(path):
        for my_file in filenames:
            print path+my_file
            if cnt < num_samples:
                cnt = cnt + 1
                im = cv2.imread(path + my_file)
                print im.shape
                image = color.rgb2gray(im)
                image = image[17:145, 16:80]

                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 extract_neg_hog_features(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)
                image = image[17:145, 16:80]
                #cv2.imshow('test',image)
                #cv2.waitKey(0)
                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 getFeat(TrainData, TestData):
    for data in TestData:
        image = np.reshape(data[0].T, (32, 32, 3))
        gray = rgb2gray(image)/255.0
        fd = hog(gray, 9, [8, 8], [2, 2], 'L2-Hys', False, True)
        fd = np.concatenate((fd, data[1]))
        filename = list(data[2])
        fd_name = filename[0].split('.')[0]+'.feat'
        fd_path = os.path.join('./data/features/test/', fd_name)
        joblib.dump(fd, fd_path)
    print "Test features are extracted and saved."
    for data in TrainData:
        image = np.reshape(data[0].T, (32, 32, 3))
        gray = rgb2gray(image)/255.0
        fd = hog(gray, 9, [8, 8], [2, 2], 'L2-Hys', False, True)
        fd = np.concatenate((fd, data[1]))
        filename = list(data[2])
        fd_name = filename[0].split('.')[0]+'.feat'
        fd_path = os.path.join('./data/features/train/', fd_name)
        joblib.dump(fd, fd_path)
    print "Train features are extracted and saved."

def extract_features():
    pos_img_path = positive_images_path
    neg_img_path = negative_images_path

    pos_feat_path = positive_features_path
    neg_feat_path = negative_features_path

    if not os.path.isdir(pos_feat_path):
        os.makedirs(pos_feat_path)

    if not os.path.isdir(neg_feat_path):
        os.makedirs(neg_feat_path)

    print "Extracting positive features"
    progress = 0.0
    for im_path in glob.glob(os.path.join(pos_img_path, "*")):
        im = imread(im_path)
        im_ycbcr = cv2.cvtColor(im, cv2.COLOR_RGB2YCR_CB)
        im = cv2.split(im_ycbcr)[0]
        feature_vector = hog(image=im, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(3, 3), visualise=False)
        feature_name = os.path.split(im_path)[1].split(".")[0] + ".feat"
        feature_path = os.path.join(pos_feat_path, feature_name)
        joblib.dump(feature_vector, feature_path)
        progress += 1.0
        update_progress(progress/float(len(glob.glob(os.path.join(pos_img_path, "*")))))

    print "Extracting negative features"
    progress = 0.0
    for im_path in glob.glob(os.path.join(neg_img_path, "*")):
        im = imread(im_path)
        im_ycbcr = cv2.cvtColor(im, cv2.COLOR_RGB2YCR_CB)
        im = cv2.split(im_ycbcr)[0]
        feature_vector = hog(image=im, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(3, 3), visualise=False)
        feature_name = os.path.split(im_path)[1].split(".")[0] + ".feat"
        feature_path = os.path.join(neg_feat_path, feature_name)
        joblib.dump(feature_vector, feature_path)
        progress += 1.0
        update_progress(progress/float(len(glob.glob(os.path.join(neg_img_path, "*")))))

def test_classifier(img_path, roi_path):
    model_path = classifier_model_path
    # Load the classifier
    clf = joblib.load(model_path)

    max_win_y = 171
    max_win_x = 70

    detections = []

    regions = get_regions(roi_path)

    im = imread(img_path)
    im_ycbcr = cv2.cvtColor(im, cv2.COLOR_RGB2YCR_CB)
    im = cv2.split(im_ycbcr)[0]

    for region in regions:
        x = int(float(region[0])*1000)
        y = int(float(region[1])*1000)

        im_window = im[y: y + max_win_y, x: x + max_win_x]

        fd = hog(image=im_window, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(3, 3), visualise=False)

        if len(fd) == 9234:
            prediction = clf.predict(fd.reshape(1, -1))

            if prediction == 1:
                print "Detection:: Location -> ({}, {})".format(x, y)
                print "Confidence Score {} \n".format(clf.decision_function(fd))
                detections.append((x, y, clf.decision_function(fd)))

    im = imread(img_path)
    im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)

    for (x_tl, y_tl, _) in detections:
        cv2.rectangle(im, (x_tl, y_tl), (x_tl+max_win_x, y_tl+max_win_y), (0, 255, 0), thickness=1)
    cv2.imwrite("result.png", im)

def describe(self, images):
        features = []
        for image in images:
            feature_vector = feature.hog(image, 
                                   orientations=self._orientations, 
                                   pixels_per_cell=self._pixels_per_cell,
                                   cells_per_block=self._cells_per_block, 
                                   transform_sqrt=True)
            features.append(feature_vector)
        features = np.array(features)
        return features

def __init__(self, original_image, initial_gamestate, grid_dim,
                 puzzle_pieces, image_dim, window, stride, num_channels, state_type):
        """

        :param original_image: The true output expected. It is used to give reward
        :param initial_gamestate: The start state for each episode. It is all zeros.
        :param grid_dim: The number of horizontal and vertical splits each, required to form the puzzle pieces
        :param puzzle_pieces: The dictionary of puzzle piece image as value for the puzzle_piece id as key
        :param image_dim: The dimension (row/col) of the original image. The image must be a square image.
        :param window: The window dimension for HOG based state space construction
        :param stride: The stride of the sliding window for HOG
        :param num_channels: The number of channels of the state space (= number of gradients given by HOG)
        :param state_type: 'hog' -> state is windowed HOG filter ,
                           'image' -> state is just the partially solved jigsaw image
        """
        self.state_type = state_type
        self.bins = np.array([x/float(NUM_BINS) for x in range(0, NUM_BINS, 1)])
        self.original_image = original_image
        self.jigsaw_image = np.zeros([image_dim, image_dim])
        self.initial_gamestate = initial_gamestate
        self.gamestate = initial_gamestate
        self.grid_dim = grid_dim
        self.puzzle_pieces = puzzle_pieces
        self.image_dim = image_dim
        self.state_height = self.gamestate.shape[0]
        self.state_width = self.state_height
        self.window = tuple(window)
        self.num_gradients = num_channels
        self.stride = stride
        self.action = None
        self.jigsaw_id_to_placed_location = dict()
        self.placed_location_to_jigsaw_id = dict()
        self.jigsaw_split = np.split(np.array(range(self.image_dim)), self.grid_dim)
        self.steps = 0
        self.terminal = False
        self.reward = 0.

def __render_gamestate(self):
        """
        Renders the new gamestate based on the changed board condition using HOG gradients over sliding window
        :return: None
        """
        slides = sliding_window(self.jigsaw_image, self.stride, self.window)

        hog_gradients = []
        for slide in slides:
            window_image = slide[2]

            gradient = np.array(hog(image=window_image,
                                    orientations=self.num_gradients,
                                    pixels_per_cell=self.window,
                                    cells_per_block=(1, 1), visualise=False))
            assert 0 <= np.max(gradient) <= 1, "Gradients are not normalized"
            assert gradient.size == self.num_gradients, "Gradient size not equal to desired size"
            gradient = gradient_discretizer(gradient, self.bins)
            hog_gradients.extend(gradient)

        hog_gradients = np.array(hog_gradients)

        hog_gradients = hog_gradients.reshape((self.state_height, self.state_width, self.num_gradients))

        assert self.gamestate.shape == hog_gradients.shape, "The state dimension is trying to be altered"
        self.gamestate = hog_gradients

def __init__(self, image_dir, checkpoint_dir, checkpoint_iter, num_actions, num_gradients, state_type):
        """

        :param image_dir: The test directory for images
        :param checkpoint_dir: The checkpoint containing the best learnt model weights and biases
        :param num_actions: Number of actions that the agent can take
        :param num_gradients: Number of gradients to be used for each window
        :param state_type: 'hog' for using windowed HOG gradient as state, 'image' for using raw images itself
        """
        self.state_type = state_type
        self.image_dir = image_dir
        self.bins = np.array([x / float(NUM_BINS) for x in range(0, NUM_BINS, 1)])
        self.sess = None
        self.checkpoint_dir = checkpoint_dir
        self.checkpoint_iter = checkpoint_iter
        self.num_actions = num_actions
        self.num_gradients = num_gradients
        if self.state_type == 'hog':
            self.input_channels = self.num_gradients
        elif self.state_type == 'image':
            self.input_channels = 1
        else:
            raise ValueError('State type not recognized, enter hog or image')

        self.input_height = len(range(0, IMAGE_HEIGHT - SLIDING_STRIDE, SLIDING_STRIDE))
        self.input_width = self.input_height
        self.imagenet = None
        # self.feature_dict = dict()
        self.state_height = self.input_height
        self.state_width = self.state_height
        self.save_transform = True
        self.im2f_loc = None
        self.feature_size = None
        Creator.__init__(self, self.input_channels, self.num_actions, self.input_height, self.input_width)

def __get_input_for_model(self, image):
        """
        Renders the new gamestate based on the changed board condition using HOG gradients over sliding window
        :return: None
        """
        state = None
        if self.state_type == 'hog':
            slides = sliding_window(image, SLIDING_STRIDE, WINDOW_SIZE)

            hog_gradients = []
            for slide in slides:
                window_image = slide[2]

                gradient = np.array(hog(window_image,
                                        orientations=self.num_gradients,
                                        pixels_per_cell=WINDOW_SIZE,
                                        cells_per_block=(1, 1), visualise=False))

                assert gradient.size == self.num_gradients, "Gradient size not equal to desired size"
                gradient = gradient_discretizer(gradient, self.bins)
                hog_gradients.extend(gradient)

            hog_gradients = np.array(hog_gradients)

            hog_gradients = hog_gradients.reshape((self.state_height, self.state_width, self.num_gradients))

            assert hog_gradients.shape == (self.input_height, self.input_width, self.input_channels), \
                "The state dimension is trying to be altered"
            state = hog_gradients

        elif self.state_type == 'image':
            resized_discrete_im = np.digitize(
                imresize(image, (self.state_height, self.state_width)),
                self.bins)
            state = np.array([resized_discrete_im]).transpose().swapaxes(0, 1)

        else:
            ValueError('The state type is not valid, enter "hog" or "image"')

        return state

def generate_hog_features(image_arr):
    fd = hog(image_arr, orientations=8, pixels_per_cell=(16, 16),
                        cells_per_block=(2, 2), visualise=False)
    return fd

def generate_hog_features(filename):
    input_image = io.imread(filename)
    gray_image = color.rgb2gray(input_image)
    # 87% for orientations=8, pixels_per_cell=(4, 4), cells_per_block=(1, 1)
    fd, hog_image = hog(gray_image, orientations=8, pixels_per_cell=(4, 4),
                        cells_per_block=(1, 1), visualise=True)
    hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 0.02))
    return hog_image_rescaled

def save_hog_image_comparison(filename):
    input_image = io.imread(filename)
    gray_image = color.rgb2gray(input_image)
    out_filename = "hog/" + filename

    # 87% for orientations=8, pixels_per_cell=(4, 4), cells_per_block=(1, 1)
    fd, hog_image = hog(gray_image, orientations=8, pixels_per_cell=(4, 4),
                        cells_per_block=(1, 1), visualise=True)
    # io.imsave("hog/" + filename, hog_image)
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)

    ax1.axis('off')
    ax1.imshow(gray_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.savefig(out_filename)
    plt.close()

    return hog_image

def generate_hog_features(image_arr):
    fd = hog(image_arr, orientations=8, pixels_per_cell=(16, 16),
                        cells_per_block=(2, 2), visualise=False)
    # hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 0.02))
    return fd

def generate_hog_features(filename):
    input_image = io.imread(filename)
    gray_image = color.rgb2gray(input_image)
    # 87% for orientations=8, pixels_per_cell=(4, 4), cells_per_block=(1, 1)
    fd, hog_image = hog(gray_image, orientations=8, pixels_per_cell=(4, 4),
                        cells_per_block=(1, 1), visualise=True)
    hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 0.02))
    return hog_image_rescaled

def save_hog_image_comparison(filename):
    input_image = io.imread(filename)
    gray_image = color.rgb2gray(input_image)
    out_filename = "hog/" + filename

    # 87% for orientations=8, pixels_per_cell=(4, 4), cells_per_block=(1, 1)
    fd, hog_image = hog(gray_image, orientations=8, pixels_per_cell=(4, 4),
                        cells_per_block=(1, 1), visualise=True)
    # io.imsave("hog/" + filename, hog_image)
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)

    ax1.axis('off')
    ax1.imshow(gray_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.savefig(out_filename)
    plt.close()

    return hog_image

def __init__(self, orientations=5, pixels_per_cell=(8, 8), cells_per_block=(3, 3), resize=96):
        self.transform = PrepCombiner([BWTransform(), ResizeTransform(resize)])
        self.orientations = orientations
        self.pixels_per_cell = pixels_per_cell
        self.cells_per_block = cells_per_block

    # Process the hog feature

def process(self, im):
        greyscaled = im.prep(self.transform)
        fd = hog(greyscaled, orientations=self.orientations, pixels_per_cell=self.pixels_per_cell,
                 cells_per_block=self.cells_per_block, visualise=False)
        return fd

def get_similarIamgeRect(*args):
    """
    ????????.
    :param img:
    :param lefttop_x:
    :param lefttop_y:
    :return:
    """
    kargs = args[0][0]
    img = kargs[0];
    lefttop_x = kargs[1];
    lefttop_y = kargs[2];
    min_wdw_sz = kargs[3];
    downscale = kargs[4]
    scale = kargs[5];

    # Calculate the HOG features
    right_y = lefttop_y + min_wdw_sz[1];
    right_x = lefttop_x + min_wdw_sz[0];
    fd = hog(img[lefttop_y:right_y, lefttop_x:right_x],
             orientations,
             pixels_per_cell,
             cells_per_block,
             visualize,
             normalize)
    prod = clf.predict_proba([fd])[0][1]
    prod = round(prod, 3);
    # print '------------------'
    if prod >= 0.90:  ##???????0.5?????
        #mutex.acquire();
        detections.append((int(lefttop_x * (downscale ** scale)), int(lefttop_y * (downscale ** scale)), prod,
                           int(min_wdw_sz[0] * (downscale ** scale)),
                           int(min_wdw_sz[1] * (downscale ** scale))));
        print  _thread.current_thread(), "Detection:: Location -> ({}, {})".format(lefttop_x, lefttop_y)
        print _thread.current_thread(), "Scale ->  {} | Confidence Score {} \n".format(scale, prod)
        #mutex.release();

def get_similarIamgeRect(*args):
    """
    ????????.
    :param img:
    :param lefttop_x:
    :param lefttop_y:
    :return:
    """
    kargs = args[0]
    img = kargs[0];
    lefttop_x = kargs[1];
    lefttop_y = kargs[2];
    min_wdw_sz = kargs[3];
    downscale = kargs[4]
    scale = kargs[5];

    # Calculate the HOG features
    right_y = lefttop_y + min_wdw_sz[1];
    right_x = lefttop_x + min_wdw_sz[0];
    fd = hog(img[lefttop_y:right_y, lefttop_x:right_x],
             orientations,
             pixels_per_cell,
             cells_per_block,
             visualize,
             normalize)
    prod = clf.predict_proba([fd])[0][1]
    prod = round(prod, 3);
    # print '------------------'
    if prod >= 0.85:  ##???????0.5?????
        # mutex.acquire();
        detections.append((int(lefttop_x * (downscale ** scale)), int(lefttop_y * (downscale ** scale)), prod,
                           int(min_wdw_sz[0] * (downscale ** scale)),
                           int(min_wdw_sz[1] * (downscale ** scale))));
        # print  _thread.current_thread(), "Detection:: Location -> ({}, {})".format(lefttop_x, lefttop_y)
        # print _thread.current_thread(), "Scale ->  {} | Confidence Score {} \n".format(scale, prod)
        # mutex.release();

def get_similarIamgeRect(*args):
    """
    ????????.
    :param img:
    :param lefttop_x:
    :param lefttop_y:
    :return:
    """
    kargs = args[0]
    img = kargs[0];
    lefttop_x = kargs[1];
    lefttop_y = kargs[2];
    min_wdw_sz = kargs[3];
    downscale = kargs[4]
    scale = kargs[5];

    # Calculate the HOG features
    right_y = lefttop_y + min_wdw_sz[1];
    right_x = lefttop_x + min_wdw_sz[0];
    fd = hog(img[lefttop_y:right_y, lefttop_x:right_x],
             orientations,
             pixels_per_cell,
             cells_per_block,
             visualize,
             normalize)
    prod = clf.predict_proba([fd])[0][1]
    prod = round(prod, 3);
    # print '------------------'
    if prod >= 0.85:  ##???????0.5?????
        mutex.acquire();
        detections.append((int(lefttop_x * (downscale ** scale)), int(lefttop_y * (downscale ** scale)), prod,
                           int(min_wdw_sz[0] * (downscale ** scale)),
                           int(min_wdw_sz[1] * (downscale ** scale))));
        print  _thread.current_thread(), "Detection:: Location -> ({}, {})".format(lefttop_x, lefttop_y)
        print _thread.current_thread(), "Scale ->  {} | Confidence Score {} \n".format(scale, prod)
        mutex.release();

def ReadImages(ListName,FolderName,Label):
    global NumberList
    global responseData
    global trainData
    global hog
    global cv2
    global imutils
    global winSize
    global testData
    for image in ListName:
        img = cv2.imread(join(FolderName,image))
        img = cv2.resize(img,(28,28))   
        feature = HOG(cv2.cvtColor(img,cv2.COLOR_RGB2GRAY))
        trainData.append(feature.T)
        responseData.append(Label)

def get_hog(image):
        image = color.rgb2gray(image)
        imgplot = plt.imshow(image, cmap=plt.cm.gray)
        fd, hog_image = hog(image, orientations=8, pixels_per_cell=(16, 16),
            cells_per_block=(1, 1), visualise=True)
        hog_image_rescaled = exposure.rescale_intensity(hog_image,
            in_range=(0, 0.02))
        return hog_image_rescaled

def testClassifier(foldername,classifier):
    clf = joblib.load(classifier)
    os.chdir(foldername)
    correct = 0
    total = 0
    for filename in glob.iglob('*.png'):
        img = cv2.imread(filename,-1)
        roi = hog(img.reshape((27, 35)), orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)
        preditcion = clf.predict(roi)
        if preditcion == filename[0]:
            correct += 1
        total += 1
    print(total)
    print(correct)

def imageToDamageArray(image_array):
    dmg = [[],[]]
    lastdamage = [0,0]
    for player in range(2):
        for time in range(len(image_array[1])):
            three_cell1 = CLF.predict([hog(image_array[player][time][4:39,2:29].reshape((27, 35)),orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)])[0]
            three_cell2 = CLF.predict([hog(image_array[player][time][4:39,23:50].reshape((27, 35)),orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)])[0]
            three_cell3 = CLF.predict([hog(image_array[player][time][4:39,48:75].reshape((27, 35)),orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)])[0]
            two_cell1 = CLF.predict([hog(image_array[player][time][4:39,13:40].reshape((27, 35)),orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)])[0]
            two_cell2 =  CLF.predict([hog(image_array[player][time][4:39,37:64].reshape((27, 35)),orientations=9, pixels_per_cell=(9, 7), cells_per_block=(1, 1), visualise=False)])[0]
            if three_cell1 != "-" and three_cell2 != "-" and three_cell3 != "-":
                if int(three_cell1)*100+int(three_cell2)*10-lastdamage[player]>50:
                    #print(three_cell1,three_cell2,three_cell3)
                    #print(two_cell1,two_cell2)
                    if two_cell1 != "-" and two_cell2 != "-" and two_cell1 != 0:
                        dmg[player].append(10*int(two_cell1)+int(two_cell2))
                        lastdamage[player]=dmg[player][-1]
                    else:
                        dmg[player].append("-")
                else:
                    dmg[player].append(100*int(three_cell1)+10*int(three_cell2)+int(three_cell3))
                    lastdamage[player]=dmg[player][-1]
            elif two_cell1 != "-" and two_cell2 != "-" and two_cell1!= 0:
                dmg[player].append(10*int(two_cell1)+int(two_cell2))
                lastdamage[player]=dmg[player][-1]
            elif three_cell1 == "-" and three_cell2 != "-" and three_cell3 == "-":
                dmg[player].append(int(three_cell2))
            else:
                dmg[player].append("-")
    return dmg

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