我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用cv2.calcHist()。
def compute(self, frame): frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) descriptor = [] dominantGradients = np.zeros_like(frame) maxGradient = cv2.filter2D(frame, cv2.CV_32F, self.kernels[0]) maxGradient = np.absolute(maxGradient) for k in range(1,len(self.kernels)): kernel = self.kernels[k] gradient = cv2.filter2D(frame, cv2.CV_32F, kernel) gradient = np.absolute(gradient) np.maximum(maxGradient, gradient, maxGradient) indices = (maxGradient == gradient) dominantGradients[indices] = k frameH, frameW = frame.shape for row in range(self.rows): for col in range(self.cols): mask = np.zeros_like(frame) mask[((frameH/self.rows)*row):((frameH/self.rows)*(row+1)),(frameW/self.cols)*col:((frameW/self.cols)*(col+1))] = 255 hist = cv2.calcHist([dominantGradients], [0], mask, self.bins, self.range) hist = cv2.normalize(hist, None) descriptor.append(hist) return np.concatenate([x for x in descriptor])
def compute(self, frame): #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) dx = cv2.filter2D(frame, cv2.CV_32F, self.xkernel) dy = cv2.filter2D(frame, cv2.CV_32F, self.ykernel) orientations = np.zeros_like(dx) magnitudes = np.zeros_like(dx) cv2.cartToPolar(dx,dy, magnitudes,orientations) descriptor = [] frameH, frameW = frame.shape mask_threshold = magnitudes <= self.threshold for row in range(self.rows): for col in range(self.cols): mask = np.zeros_like(frame) mask[((frameH/self.rows)*row):((frameH/self.rows)*(row+1)),(frameW/self.cols)*col:((frameW/self.cols)*(col+1))] = 1 mask[mask_threshold] = 0 a_, b_ = mask.shape hist = cv2.calcHist([orientations], self.channel, mask, [self.bins], self.range) hist = cv2.normalize(hist, None) descriptor.append(hist) return np.concatenate([x for x in descriptor])
def calculate_entropy(image): entropy = image.copy() sum = 0 i = 0 j = 0 while i < entropy.shape[0]: j = 0 while j < entropy.shape[1]: sub_image = entropy[i:i+10,j:j+10] histogram = cv2.calcHist([sub_image],[0],None,[256],[0,256]) sum = 0 for k in range(256): if histogram[k] != 0: sum = sum + (histogram[k] * math.log(histogram[k])) k = k + 1 entropy[i:i+10,j:j+10] = sum j = j+10 i = i+10 ret2,th2 = cv2.threshold(entropy,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU) newfin = cv2.erode(th2, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1) return newfin
def leftRightHistEqualize(self, img_left, img_right) : lookup = np.zeros([256], np.uint8) cdf_new = np.zeros([256]) rows,cols = img_right.shape img_left_new = np.zeros([rows,cols], np.uint8) hist_left = cv2.calcHist([img_left],[0],None,[256],[0,255]) hist_right = cv2.calcHist([img_right],[0],None,[256],[0,255]) cdf_left_norm = hist_left.cumsum() /(rows*cols) cdf_right_norm = hist_right.cumsum() /(rows*cols) for i in range(0,256): lookup[i] = np.argmin(np.abs(cdf_left_norm[i]-cdf_right_norm)) # cdf_new[i] = cdf_right_norm[lookup[i]] img_left_new[ np.where(img_left==i) ] = lookup[i] return img_left_new
def gimpMarkup(self, hints = gimpContours, image = "2x2-red-1.jpg", feature = "top-left-monitor"): r = Rectangle(*hints[image][feature]) contour = r.asContour() cv2.drawContours(self.img, [contour], -1, (0, 255, 0), 5 ) title = self.tgen.next(feature) if self.show: ImageViewer(self.img).show(window=title, destroy = self.destroy, info = self.info, thumbnailfn = title) roi = r.getRoi(self.img) self.rois[feature] = roi # Histogram the ROI to get the spread of intensities, in each channel and grayscale title = '%s-roi.jpg' % feature if self.show: ImageViewer(roi).show(window=title, destroy = self.destroy, info = self.info, thumbnailfn = title) colors = ('b','g','r') for i,col in enumerate(colors): hist = cv2.calcHist([roi], [i], None, [256], [0,256]) plt.plot(hist, color = col) plt.xlim([0,256]) #plt.hist(roi.ravel(), 256, [0,256]) plt.show() cmap = ColorMapper(roi) cmap.mapit(1) title = self.tgen.next('colourMapping') if self.show: ImageViewer(self.img).show(window=title, destroy = self.destroy, info = self.info, thumbnailfn = title) cv2.waitKey()
def describe(self, image): # Compute a 3D histogram in the RGB colorspace and normalize. hist = cv2.calcHist([image], [0, 1, 2], None, self.bins, [0, 256, 0, 256, 0, 256]) hist = cv2.normalize(hist, hist) # Return the 3D histogram output as a flattened array. return hist.flatten()
def accumulated_histogram(images, args): histogram = args[0] try: image, x, y = images.get(timeout=0.3) except: return hsv = cv2.cvtColor(np.array(image, dtype=np.uint8), cv2.COLOR_RGB2HSV) current_histogram = histogram.get() new_histogram = list(map(lambda x: cv2.calcHist([hsv[:,:,x]], [0], None, [256], [0, 256], hist=current_histogram[x], accumulate=True), range(3))) histogram.put(new_histogram) images.task_done()
def extract_color_histogram(image, bins=(8, 8, 8)): # extract a 3D color histogram from the HSV color space using # the supplied number of `bins` per channel hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) hist = cv2.calcHist([hsv], [0, 1, 2], None, bins, [0, 180, 0, 256, 0, 256]) # handle normalizing the histogram if we are using OpenCV 2.4.X if imutils.is_cv2(): hist = cv2.normalize(hist) # otherwise, perform "in place" normalization in OpenCV 3 (I # personally hate the way this is done else: cv2.normalize(hist, hist) # return the flattened histogram as the feature vector return hist.flatten()
def main(): target_im = cv2.imread(sys.argv[1]) target_hist = cv2.calcHist([target_im], [0], None, [256], [0, 256]) for i in list: comparing_im = cv2.imread(i) comparing_hist = cv2.calcHist([comparing_im], [0], None, [256], [0, 256]) diff = cv2.compareHist(target_hist, comparing_hist, 0) if diff > float(sys.argv[2]): print i, print diff
def compute(self, frame): frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) frameH, frameW = frame.shape descriptor = [] for row in range(self.rows): for col in range(self.cols): mask = np.zeros_like(frame) mask[((frameH/self.rows)*row):((frameH/self.rows)*(row+1)),(frameW/self.cols)*col:((frameW/self.cols)*(col+1))] = 1 hist = cv2.calcHist([frame], self.channel, mask, [self.bins], self.range) hist = cv2.normalize(hist, None) descriptor.append(hist) return np.concatenate([x for x in descriptor])
def test_features(): from atx.drivers.android_minicap import AndroidDeviceMinicap cv2.namedWindow("preview") d = AndroidDeviceMinicap() # r, h, c, w = 200, 100, 200, 100 # track_window = (c, r, w, h) # oldimg = cv2.imread('base1.png') # roi = oldimg[r:r+h, c:c+w] # hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # mask = cv2.inRange(hsv_roi, 0, 255) # roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0,180]) # cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # term_cirt = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) while True: try: w, h = d._screen.shape[:2] img = cv2.resize(d._screen, (h/2, w/2)) cv2.imshow('preview', img) hist = cv2.calcHist([img], [0], None, [256], [0,256]) plt.plot(plt.hist(hist.ravel(), 256)) plt.show() # if img.shape == oldimg.shape: # # hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # # ret, track_window = cv2.meanShift(hsv, track_window, term_cirt) # # x, y, w, h = track_window # cv2.rectangle(img, (x, y), (x+w, y+h), 255, 2) # cv2.imshow('preview', img) # # cv2.imshow('preview', img) cv2.waitKey(1) except KeyboardInterrupt: break cv2.destroyWindow('preview')
def _classify_partition(self, partition): """Classifies a partition. Args: partition: Partition. Returns: GameMapObjects enum. """ histogram = cv2.calcHist([partition], [0], None, [256], [0, 256]) return self._classify_histogram(histogram)
def describe(image, mask = None): hist = cv2.calcHist([image], [0, 1, 2], mask, [8,8,8], [0, 256, 0, 256, 0, 256]) cv2.normalize(hist, hist) return hist.flatten()
def accumulated_histogram(image, histogram): hist = list(map(lambda x: cv2.calcHist([image], [x], None, [256], [0, 256]), range(3))) for x in range(3): histogram[x] = np.add(hist[x].ravel(), histogram[x].ravel()) return histogram
def run(self, video_path=None): if video_path is not None: self.video_path = video_path assert (self.video_path is not None), "you should must the video path!" self.shots = [] self.scores = [] self.frames = [] hists = [] cap = cv2.VideoCapture(self.video_path) self.frame_count = cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT) self.fps = cap.get(cv2.cv.CV_CAP_PROP_FPS) while True: success, frame = cap.read() if not success: break self.frames.append(frame) # millis = cap.get(cv2.cv.CV_CAP_PROP_POS_MSEC) # print millis # compute RGB histogram for each frame chists = [cv2.calcHist([frame], [c], None, [__hist_size__], [0,256]) \ for c in range(3)] chists = np.array([chist for chist in chists]) hists.append(chists.flatten()) # compute hist distances self.scores = [np.ndarray.sum(abs(pair[0] - pair[1])) for pair in zip(hists[1:], hists[:-1])]
def screens_show_same_scene(scr1, scr2): scr1 = ia.imresize_single_image(scr1, (50, 70)) scr2 = ia.imresize_single_image(scr2, (50, 70)) hist1 = cv2.calcHist([scr1[...,0], scr1[...,1], scr1[...,2]], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) hist2 = cv2.calcHist([scr2[...,0], scr2[...,1], scr2[...,2]], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) diff = np.sum(np.abs(hist1 - hist2)) return diff <= MAX_PIXELDIFF
def hand_capture(frame_in,box_x,box_y): hsv = cv2.cvtColor(frame_in, cv2.COLOR_BGR2HSV) ROI = np.zeros([capture_box_dim*capture_box_count,capture_box_dim,3], dtype=hsv.dtype) for i in xrange(capture_box_count): ROI[i*capture_box_dim:i*capture_box_dim+capture_box_dim,0:capture_box_dim] = hsv[box_y[i]:box_y[i]+capture_box_dim,box_x[i]:box_x[i]+capture_box_dim] hand_hist = cv2.calcHist([ROI],[0, 1], None, [180, 256], [0, 180, 0, 256]) cv2.normalize(hand_hist,hand_hist, 0, 255, cv2.NORM_MINMAX) return hand_hist # 2. Filters and threshold
def getLBP(img): img2 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) radius = 1 n_points = 8 * radius lbpImage = (local_binary_pattern(img2, n_points, radius)).astype(int)**(1.0/radius) # block processing: lbpImages = block_view(lbpImage, ( int(lbpImage.shape[0] / 2), int(lbpImage.shape[1] / 4))) count = 0 LBP = np.array([]); for i in range(lbpImages.shape[0]): # for each block: for j in range(lbpImages.shape[1]): count += 1 # plt.subplot(4,2,count) # plt.imshow(lbpImages[i,j,:,:],cmap = cm.Greys_r) # plt.subplot(4,2,count+4*2/2) # print count*2+1 LBPt = cv2.calcHist([lbpImages[i,j,:,:].astype('uint8')], [0], None, [8], [0, 256]) LBP = np.append(LBP, LBPt[:,0]); # plt.plot(LBPt) # plt.show() Fnames = ["LBP"+str(i).zfill(2) for i in range(len(LBP))] return normalize(LBP).tolist(), Fnames
def getRGBS(img, PLOT = False): image = cv2.cvtColor(img,cv2.COLOR_BGR2RGB) # grab the image channels, initialize the tuple of colors, # the figure and the flattened feature vector features = [] featuresSobel = [] Grayscale = cv2.cvtColor(img, cv2.cv.CV_BGR2GRAY) histG = cv2.calcHist([Grayscale], [0], None, [16], [0, 256]) histG = histG / histG.sum() features.extend(histG[:,0].tolist()) grad_x = np.abs(cv2.Sobel(Grayscale, cv2.CV_16S, 1, 0, ksize = 3, scale = 1, delta = 0, borderType = cv2.BORDER_DEFAULT)) grad_y = np.abs(cv2.Sobel(Grayscale, cv2.CV_16S, 0, 1, ksize = 3, scale = 1, delta = 0, borderType = cv2.BORDER_DEFAULT)) abs_grad_x = cv2.convertScaleAbs(grad_x) abs_grad_y = cv2.convertScaleAbs(grad_y) dst = cv2.addWeighted(abs_grad_x,0.5,abs_grad_y,0.5,0) histSobel = cv2.calcHist([dst], [0], None, [16], [0, 256]) histSobel = histSobel / histSobel.sum() features.extend(histSobel[:,0].tolist()) Fnames = [] Fnames.extend(["Color-Gray"+str(i) for i in range(8)]) Fnames.extend(["Color-GraySobel"+str(i) for i in range(8)]) return features, Fnames
def are_similar(self, first, second): res = cv2.absdiff(first, second) hist = cv2.calcHist([res], [0], None, [256], [0, 256]) return 1 - np.sum(hist[15::]) / np.sum(hist)
def are_similar(self, first, second): result = 0 for i in xrange(3): hist1 = cv2.calcHist([first], [i], None, [256], [0,256]) hist2 = cv2.calcHist([second], [i], None, [256], [0,256]) result += cv2.compareHist(hist1, hist2, self.get_technique()) return result / 3
def compute_hist(im): hist = cv2.calcHist([im], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) hist = cv2.normalize(hist).flatten() return hist
def __init__(self,frame,rect,method='m'): r,c,h,w=rect roi = frame[r:r+h, c:c+w] mask = cv2.inRange(roi, np.array((0.)), np.array((255.))) roi_hist = cv2.calcHist([roi],[0],mask,[16],[0,255]) roi_hist=cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) plotRects(frame,[rect]) cv2.waitKey(0) cv2.destroyAllWindows() self.roi_hist=roi_hist self.track_window=tuple(rect) self.m=method self.frame=frame
def calHist(frame,rect): r,c,h,w=rect roi = frame[r:r+h, c:c+w] mask = cv2.inRange(roi, np.array((0.)), np.array((255.))) roi_hist = cv2.calcHist([roi],[0],mask,[255],[0,255]) roi_hist=cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) return roi_hist
def plot_histogram(image, title, mask=None): chans = cv2.split(image) colors = ("b", "g", "r") plt.figure() plt.title(title) plt.xlabel("Bins") plt.ylabel("# of Pixels") for (chan, color) in zip(chans, colors): hist = cv2.calcHist([chan], [0], mask, [256], [0, 256]) plt.plot(hist, color=color) plt.xlim([0, 256]) plt.show() # Parse the command line arguments
def hist_lines(image, start, end): scale = 4 height = 1080 result = np.zeros((height, 256 * scale, 1)) hist = cv2.calcHist([image], [0], None, [256], [start, end]) cv2.normalize(hist, hist, 0, height, cv2.NORM_MINMAX) hist = np.int32(np.around(hist)) for x, y in enumerate(hist): cv2.rectangle(result, (x * scale, 0), ((x + 1) * scale, y), (255), -1) result = np.flipud(result) return result
def extract(img): return np.ravel(cv2.calcHist([img],[2],None,[126],[0,256]))
def extract(img): return np.ravel(cv2.calcHist([img],[1],None,[126],[0,256]))
def extract(img): return np.ravel(cv2.calcHist([img],[2],None,[127],[0,256]))
def BlockLBPH(img,minValue,maxValue,normed=True): '''????????LBP?????''' #?????bin??? histSize=[maxValue-minValue+1] ranges=[minValue,maxValue+1] result=cv2.calcHist(img,[0],None,histSize,ranges) #??? if normed: result=result/(int)(img.shape[0]*img.shape[1]) return result.reshape(1,-1)
def gray_histogram_cmp_corr(self): self.threshold = .9 gray_i = cv2.cvtColor(self.image_i, cv2.COLOR_BGR2GRAY) hist_i = cv2.calcHist([gray_i], [0], None, [256], [0, 256]) gray_j = cv2.cvtColor(self.image_j, cv2.COLOR_BGR2GRAY) hist_j = cv2.calcHist([gray_j], [0], None, [256], [0, 256]) self.measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_CORREL) self.assertGreater(self.measure, self.threshold)
def gray_histogram_cmp_bhatta(self): self.threshold = .07 gray_i = cv2.cvtColor(self.image_i, cv2.COLOR_BGR2GRAY) hist_i = cv2.calcHist([gray_i], [0], None, [256], [1, 256]) gray_j = cv2.cvtColor(self.image_j, cv2.COLOR_BGR2GRAY) hist_j = cv2.calcHist([gray_j], [0], None, [256], [1, 256]) self.measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_BHATTACHARYYA) self.assertGreater(self.measure, self.threshold)
def gray_histogram_cmp_bhatta(self): threshold = .07 gray_i = cv2.cvtColor(self.image_i, cv2.COLOR_BGR2GRAY) hist_i = cv2.calcHist([gray_i], [0], None, [256], [1, 256]) gray_j = cv2.cvtColor(self.image_j, cv2.COLOR_BGR2GRAY) hist_j = cv2.calcHist([gray_j], [0], None, [256], [1, 256]) measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_BHATTACHARYYA) self.assertGreater(measure, threshold)
def Harris_Corner(self): self.threshold = 0.999999999999 temp_i = self.image_i.copy() temp1_i = self.image_i.copy() gray_i = cv2.cvtColor(temp_i, cv2.COLOR_BGR2GRAY) gray_i = numpy.float32(gray_i) dst_i = cv2.cornerHarris(gray_i,2,3,0.025) dst_i = cv2.dilate(dst_i,None) # Threshold for an optimal value, it may vary depending on the image. temp_i[dst_i<0.01*dst_i.max()]=[0,0,0] temp_i[dst_i>=0.01*dst_i.max()]=[255,255,255] temp1_i[dst_i>0.01*dst_i.max()]=[0,0,255] hist_i = cv2.calcHist([temp_i], [0], None, [256], [0, 256]) temp_j = self.image_j.copy() temp1_j = self.image_j.copy() gray_j = cv2.cvtColor(temp_j, cv2.COLOR_BGR2GRAY) gray_j = numpy.float32(gray_j) dst_j = cv2.cornerHarris(gray_j,2,3,0.025) dst_j = cv2.dilate(dst_j,None) # Threshold for an optimal value, it may vary depending on the image. temp_j[dst_j<0.01*dst_j.max()]=[0,0,0] temp_j[dst_j>=0.01*dst_j.max()]=[255,255,255] temp1_j[dst_j>0.01*dst_j.max()]=[0,0,255] hist_j = cv2.calcHist([temp_j], [0], None, [256], [0, 256]) self.measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_CORREL) self.assertGreater(self.measure, self.threshold) print self.measure cv2.imshow('Input X',temp1_i) cv2.waitKey(0) cv2.imshow('Input Y',temp1_j) cv2.waitKey(0)
def Canny_edge(self): self.threshold = .999999999999999 gray_i = cv2.cvtColor(self.image_i, cv2.COLOR_BGR2GRAY) edges_i = cv2.Canny(gray_i,100,200) gray_j = cv2.cvtColor(self.image_j, cv2.COLOR_BGR2GRAY) edges_j = cv2.Canny(gray_j,100,200) hist_i = cv2.calcHist([edges_i], [0], None, [256], [0, 256]) hist_j = cv2.calcHist([edges_j], [0], None, [256], [0, 256]) self.measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_CORREL) self.assertGreater(self.measure, self.threshold) print self.measure # cv2.imshow(self.image_i) # cv2.imshow(self.image_j)
def Harris_Corner(self): self.threshold = 0.999999999999 temp_i = self.image_i.copy() temp1_i = self.image_i.copy() gray_i = cv2.cvtColor(temp_i, cv2.COLOR_BGR2GRAY) gray_i = numpy.float32(gray_i) dst_i = cv2.cornerHarris(gray_i,2,3,0.025) dst_i = cv2.dilate(dst_i,None) # Threshold for an optimal value, it may vary depending on the image. temp_i[dst_i<0.01*dst_i.max()]=[0,0,0] temp1_i[dst_i>0.01*dst_i.max()]=[0,0,255] hist_i = cv2.calcHist([temp_i], [0], None, [256], [0, 256]) temp_j = self.image_j.copy() temp1_j = self.image_j.copy() gray_j = cv2.cvtColor(temp_j, cv2.COLOR_BGR2GRAY) gray_j = numpy.float32(gray_j) dst_j = cv2.cornerHarris(gray_j,2,3,0.025) dst_j = cv2.dilate(dst_j,None) # Threshold for an optimal value, it may vary depending on the image. temp_j[dst_j<0.01*dst_j.max()]=[0,0,0] temp1_j[dst_j>0.01*dst_j.max()]=[0,0,255] hist_j = cv2.calcHist([temp_j], [0], None, [256], [0, 256]) self.measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_CORREL) self.assertGreater(self.measure, self.threshold)
def rgb_histogram(self): self.threshold = 0.999999999999999 hist_i = cv2.calcHist([self.image_i], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) hist_j = cv2.calcHist([self.image_j], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) hist_flatten_i = hist_i.flatten() hist_flatten_j = hist_j.flatten() self.measure = cv2.compareHist(hist_flatten_i, hist_flatten_j, cv.CV_COMP_CORREL) self.assertGreater(self.measure, self.threshold)
def __get_roi_hist(self, faces_rects, frame): faces_roi_hists = [] for (x, y, w, h) in faces_rects: roi = frame[y:y+h, x:x+w] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.))) roi_hist = cv2.calcHist([hsv_roi],[0], mask, [180], [0,180]) roi_hist = cv2.normalize(roi_hist,roi_hist, 0, 255, cv2.NORM_MINMAX) faces_roi_hists.append(roi_hist) return faces_roi_hists
def calc_hist(image): mask = cv2.inRange(image, np.array((0., 60.,32.)), np.array((180.,255.,255.))) hist = cv2.calcHist([image],[0],mask,[180],[0,180]) #hist = cv2.calcHist(image,[0,1],None,[10,10],[0,180,0,255]) cv2.normalize(hist,hist,0,1,norm_type=cv2.NORM_MINMAX) return hist
def histogram(self, image, mask=None): #Extract a 3D color histogram from the masked region of the image, using #the supplied number of bins per channel, then normalize the histogram new_im = imcrop(image) hist = cv2.calcHist([new_im], [0, 1, 2], mask, self.bins,[0, 256, 0, 256, 0, 256]) hist = cv2.normalize(hist).flatten() return hist
def get_histogram(image, histogram_scale): h = cv2.calcHist([image], [0], None, [histogram_scale], [0, 256]).flatten() return h/256
