def use_image(self, im): self.kind = 'opencv' self.hist = cv.CreateHist([self.bins], cv.CV_HIST_ARRAY, [self.value_range], 1) cv.CalcHist([im], self.hist) self.min_value, self.max_value, _, _ = cv.GetMinMaxHistValue(self.hist) return self
def hs_histogram(src): # Convert to HSV hsv = cv.CreateImage(cv.GetSize(src), 8, 3) cv.CvtColor(src, hsv, cv.CV_BGR2HSV) # Extract the H and S plane h_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) s_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) cv.Split(hsv, h_plane, s_plane, None, None) planes = [h_plane, s_plane] h_bins = 30 s_bins = 32 hist_size = [h_bins, s_bins] # hue varies from 0 to 180 h_ranges = [0, 180] # saturation varies from 0 to 255 s_ranges = [0, 255] ranges = [h_ranges, s_ranges] scale = 10 hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1) cv.CalcHist([cv.GetImage(i) for i in planes], hist) (_, max_value, _, _) = cv.GetMinMaxHistValue(hist) hist_img = cv.CreateImage((h_bins * scale, s_bins * scale), 8, 3) for h in range(h_bins): for s in range(s_bins): bin_val = cv.QueryHistValue_2D(hist, h, s) intensity = cv.Round(bin_val * 255 / max_value) cv.Rectangle(hist_img, (h * scale, s * scale), ((h + 1) * scale - 1, (s + 1) * scale - 1), cv.RGB(intensity, intensity, intensity), cv.CV_FILLED) return hist_img
def run(self): while True: frame = cv.QueryFrame( self.capture) # Run the cam-shift if self.track_window and is_rect_nonzero(self.track_window): crit = ( cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, 10, 1) (iters, (area, value, rect), track_box) = cv.CamShift(backproject, self.track_window, crit) self.track_window = rect # If mouse is pressed, highlight the current selected rectangle # and recompute the histogram if self.drag_start and is_rect_nonzero(self.selection): sub = cv.GetSubRect(frame, self.selection) save = cv.CloneMat(sub) cv.ConvertScale(frame, frame, 0.5) cv.Copy(save, sub) x,y,w,h = self.selection cv.Rectangle(frame, (x,y), (x+w,y+h), (255,255,255)) sel = cv.GetSubRect(self.hue, self.selection ) cv.CalcArrHist( [sel], hist, 0) (_, max_val, _, _) = cv.GetMinMaxHistValue( hist) if max_val != 0: cv.ConvertScale(hist.bins, hist.bins, 255. / max_val) elif self.track_window and is_rect_nonzero(self.track_window): cv.EllipseBox( frame, track_box, cv.CV_RGB(255,0,0), 3, cv.CV_AA, 0 ) cv.ShowImage("Output",frame) cv.WaitKey(0)
def extract_bright(grey_img, histogram=False): """ Extracts brightest part of the image. Expected to be the LEDs (provided that there is a dark background) Returns a Thresholded image histgram defines if we use the hist calculation to find the best margin """ ## Searches for image maximum (brightest pixel) # We expect the LEDs to be brighter than the rest of the image [minVal, maxVal, minLoc, maxLoc] = cv.MinMaxLoc(grey_img) print "Brightest pixel val is %d" % (maxVal) #We retrieve only the brightest part of the image # Here is use a fixed margin (80%), but you can use hist to enhance this one if 0: ## Histogram may be used to wisely define the margin # We expect a huge spike corresponding to the mean of the background # and another smaller spike of bright values (the LEDs) hist = grey_histogram(img, nBins=64) [hminValue, hmaxValue, hminIdx, hmaxIdx] = cv.GetMinMaxHistValue(hist) margin = 0 # statistics to be calculated using hist data else: margin = 0.8 thresh = int(maxVal * margin) # in pix value to be extracted print "Threshold is defined as %d" % (thresh) thresh_img = cv.CreateImage(cv.GetSize(img), img.depth, 1) cv.Threshold(grey_img, thresh_img, thresh, 255, cv.CV_THRESH_BINARY) return thresh_img
def normalize_plane(plane, aggressive=0): if aggressive: # smooth = image_empty_clone(plane) # cv.Smooth(plane, smooth, cv.CV_GAUSSIAN, 13, 13) hist = get_gray_histogram(plane, bins=255) _, max_value, _, max_color = cv.GetMinMaxHistValue(hist) thr_value = max_value * aggressive down_threshold, up_threshold = None, None for k in range(256): down_val = cv.QueryHistValue_1D(hist, k) up_val = cv.QueryHistValue_1D(hist, 254 - k) if down_threshold is None and down_val >= thr_value: down_threshold = k if up_threshold is None and up_val >= thr_value: up_threshold = k if down_threshold is not None and up_threshold is not None: break sub_plane = None if down_threshold > 0: sub_plane = image_empty_clone(plane) cv.SubS(plane, down_threshold, sub_plane) add_plane = None if down_threshold + up_threshold > 0: add_plane = image_empty_clone(plane) cv.AddS(sub_plane or plane, down_threshold + up_threshold, add_plane) plane = add_plane or plane norm_plane = image_empty_clone(plane) cv.Normalize(plane, norm_plane, 0, 255, cv.CV_MINMAX) return norm_plane
def renderIndividualHist(self, painting): height = 500 width = 500 (r, g, b) = cv.GetDims(painting.data.bins) (_, tallest, _, _) = cv.GetMinMaxHistValue(painting.data) scale = height / tallest if scale > 1: scale = 1 histImage = cv.CreateImage((width, height), 8, 3) prev = -1 cv.Rectangle(histImage, (0, 0), (width, height), cv.CV_RGB(0, 0, 0), cv.CV_FILLED) step = width / (r * g * b) cur = 0 for (i, j, k) in iter3D(range(r), range(g), range(b)): intensity = cv.QueryHistValue_3D(painting.data, i, j, k) color = cv.CV_RGB(int((255 / r) * i), int((255 / g) * j), int((255 / b) * k)) x1 = cur cur += step x2 = x1 + step cv.Rectangle(histImage, (int(x1), height), (int(x2), height - int(intensity * scale)), color, cv.CV_FILLED) windowTitle = '{0} ({1})'.format(painting.title, painting.year) cv.NamedWindow(windowTitle) cv.ShowImage(windowTitle, histImage) cv.WaitKey(0)
def rescaleMax(self,value=255): ''' Rescale the histogram such that the maximum equals the value. ''' cv.NormalizeHist(self.hist,1) _,max_value,_,_ = cv.GetMinMaxHistValue(self.hist) if max_value == 0: max_value = 1.0 cv.NormalizeHist(self.hist,255/max_value)
def run(self): hist = cv.CreateHist([180], cv.CV_HIST_ARRAY, [(0, 180)], 1) backproject_mode = False while True: frame = cv.QueryFrame(self.capture) # Convert to HSV and keep the hue hsv = cv.CreateImage(cv.GetSize(frame), 8, 3) cv.CvtColor(frame, hsv, cv.CV_BGR2HSV) self.hue = cv.CreateImage(cv.GetSize(frame), 8, 1) print(self.hue) cv.Split(hsv, self.hue, None, None, None) # Compute back projection backproject = cv.CreateImage(cv.GetSize(frame), 8, 1) # Run the cam-shift cv.CalcArrBackProject([self.hue], backproject, hist) if self.track_window and is_rect_nonzero(self.track_window): crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, 10, 1) (iters, (area, value, rect), track_box) = cv.CamShift(backproject, self.track_window, crit) self.track_window = rect # If mouse is pressed, highlight the current selected rectangle # and recompute the histogram if self.drag_start and is_rect_nonzero(self.selection): sub = cv.GetSubRect(frame, self.selection) save = cv.CloneMat(sub) cv.ConvertScale(frame, frame, 0.5) cv.Copy(save, sub) x, y, w, h = self.selection cv.Rectangle(frame, (x, y), (x + w, y + h), (255, 255, 255)) sel = cv.GetSubRect(self.hue, self.selection) cv.CalcArrHist([sel], hist, 0) (_, max_val, _, _) = cv.GetMinMaxHistValue(hist) if max_val != 0: cv.ConvertScale(hist.bins, hist.bins, 255. / max_val) elif self.track_window and is_rect_nonzero(self.track_window): cv.EllipseBox(frame, track_box, cv.CV_RGB(255, 0, 0), 3, cv.CV_AA, 0) if not backproject_mode: #frame=cv.Flip(frame) cv.ShowImage("CamShiftDemo", frame) else: cv.ShowImage("CamShiftDemo", backproject) cv.ShowImage("Histogram", self.hue_histogram_as_image(hist)) c = cv.WaitKey(7) if c == 27: break elif c == ord("b"): backproject_mode = not backproject_mode
def calcularHistograma(self): cv.CalcArrHist([self.imagem_destino], self.histograma) valorMaximoMinimo = cv.GetMinMaxHistValue(self.histograma) cv.Rectangle(self.imagemHistograma, (0, 0), (512, 100), cv.CV_RGB(0, 0, 0), -1) for i in range(512): valor = cv.QueryHistValue_1D(self.histograma, i) normalizado = cv.Round(valor * 100 / valorMaximoMinimo[1]) cv.Line(self.imagemHistograma, (i, 100), (i, 100 - normalizado), cv.CV_RGB(255, 255, 255))
def do_camshift(self, cv_image): """ Get the image size """ image_size = cv.GetSize(cv_image) image_width = image_size[0] image_height = image_size[1] """ Convert to HSV and keep the hue """ hsv = cv.CreateImage(image_size, 8, 3) cv.CvtColor(cv_image, hsv, cv.CV_BGR2HSV) self.hue = cv.CreateImage(image_size, 8, 1) cv.Split(hsv, self.hue, None, None, None) """ Compute back projection """ backproject = cv.CreateImage(image_size, 8, 1) """ Run the cam-shift algorithm """ cv.CalcArrBackProject( [self.hue], backproject, self.hist ) if self.track_window and is_rect_nonzero(self.track_window): crit = ( cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, 10, 1) (iters, (area, value, rect), track_box) = cv.CamShift(backproject, self.track_window, crit) self.track_window = rect """ If mouse is pressed, highlight the current selected rectangle and recompute the histogram """ if self.drag_start and is_rect_nonzero(self.selection): sub = cv.GetSubRect(cv_image, self.selection) save = cv.CloneMat(sub) cv.ConvertScale(cv_image, cv_image, 0.5) cv.Copy(save, sub) x,y,w,h = self.selection cv.Rectangle(cv_image, (x,y), (x+w,y+h), (255,255,255)) sel = cv.GetSubRect(self.hue, self.selection ) cv.CalcArrHist( [sel], self.hist, 0) (_, max_val, _, _) = cv.GetMinMaxHistValue(self.hist) if max_val != 0: cv.ConvertScale(self.hist.bins, self.hist.bins, 255. / max_val) elif self.track_window and is_rect_nonzero(self.track_window): cv.EllipseBox( cv_image, track_box, cv.CV_RGB(255,0,0), 3, cv.CV_AA, 0 ) roi = RegionOfInterest() roi.x_offset = int(min(image_width, max(0, track_box[0][0] - track_box[1][0] / 2))) roi.y_offset = int(min(image_height, max(0, track_box[0][1] - track_box[1][1] / 2))) roi.width = int(track_box[1][0]) roi.height = int(track_box[1][1]) self.ROI.publish(roi) cv.ShowImage("Histogram", self.hue_histogram_as_image(self.hist)) if not self.backproject_mode: return cv_image else: return backproject
def hs_histogram(src, patch): # Convert to HSV hsv = cv.CreateImage(cv.GetSize(src), 8, 3) cv.CvtColor(src, hsv, cv.CV_BGR2HSV) hsv_patch= cv.CreateImage(cv.GetSize(patch), 8, 3) # Extract the H and S planes h_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) h_plane_img = cv.CreateImage(cv.GetSize(src), 8, 1) h_plane_patch = cv.CreateMat(patch.rows, patch.cols, cv.CV_8UC1) s_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) s_plane_img = cv.CreateImage(cv.GetSize(src), 8, 1) s_plane_patch = cv.CreateMat(patch.rows, patch.cols, cv.CV_8UC1) v_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) cv.Split(hsv, h_plane, s_plane, v_plane, None) cv.Split(hsv, h_plane_img, s_plane_img, None, None) cv.Split(hsv_patch, h_plane_patch, s_plane_patch, None, None) #cv.Split(src, h_plane, s_plane, v_plane, None) planes = [h_plane_patch, s_plane_patch]#, s_plane, v_plane] h_bins = 30 s_bins = 32 v_bins = 30 hist_size = [h_bins, s_bins] # hue varies from 0 (~0 deg red) to 180 (~360 deg red again */ h_ranges = [0, 180] # saturation varies from 0 (black-gray-white) to # 255 (pure spectrum color) s_ranges = [0, 255] v_ranges = [0, 255] ranges = [h_ranges, s_ranges]#, s_ranges, v_ranges] scale = 10 hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1) cv.CalcHist([cv.GetImage(i) for i in planes], hist) (_, max_value, _, _) = cv.GetMinMaxHistValue(hist) hist_img = cv.CreateImage((h_bins*scale, s_bins*scale), 8, 3) back_proj_img = cv.CreateImage(cv.GetSize(src), 8, 1) cv.CalcBackProject([h_plane_img, s_plane_img], back_proj_img, hist) # for h in range(h_bins): # for s in range(s_bins): # bin_val = cv.QueryHistValue_2D(hist, h, s) # intensity = cv.Round(bin_val * 255 / max_value) # cv.Rectangle(hist_img, # (h*scale, s*scale), # ((h+1)*scale - 1, (s+1)*scale - 1), # cv.RGB(intensity, intensity, intensity), # cv.CV_FILLED) return back_proj_img, hist
def histogram_image(hist, color=(255, 255, 255), background_color=(0, 0, 0), num_bins=256): '''Returns an image displaying the the given histogram.''' max_value = int(cv.GetMinMaxHistValue(hist)[1]) img = cv.CreateImage((num_bins, num_bins), 8, 3) cv.Set(img, background_color) for i in xrange(num_bins): height = int(cv.QueryHistValue_1D(hist, i) / max_value * num_bins) cv.Line(img, (i, num_bins), (i, num_bins - height), color) return img
def pitch_detect(intrinsics, dist_coeffs, dst0): capture = cv.CaptureFromCAM(0) src = cv.QueryFrame(capture) cv.SetImageROI(dst0, (0, 0, 640, 480)) cv.Undistort2(src, dst0, intrinsics, dist_coeffs) cv.SetImageROI(dst0, image_ROI) dst = GetImage(dst0) hsv = cv.CreateImage(size, 8, 3) CvtColor(dst, hsv, CV_RGB2HSV) cv.Split(hsv, hue, sat, val, None) hist = cv.CreateHist([32, 64], CV_HIST_ARRAY, [[0, 180], [0, 256]], 1) cv.CalcHist([hue, sat], hist, 0, None) values = cv.GetMinMaxHistValue(hist) tweak = values[3][0] return tweak
def channel_to_image(self, chan, scale_x=3, scale_y=3, y_range=64): """ Creates an iplimage displaying histogram results after its computation """ if ((type(chan) != int) or (chan <= 0)): raise TypeError("(%s) Positive integer expected!" % (sys._getframe().f_code.co_name)) elif chan > self.channels: raise ValueError("(%s) Incoherent channel selected!" % (sys._getframe().f_code.co_name)) if ((type(scale_x) != int) or (scale_x <= 0)): raise TypeError("(%s) Positive integer expected!" % (sys._getframe().f_code.co_name)) if ((type(scale_y) != int) or (scale_y <= 0)): raise TypeError("(%s) Positive integer expected!" % (sys._getframe().f_code.co_name)) if ((type(y_range) != int) or (y_range <= 0)): raise TypeError("(%s) Positive integer expected!" % (sys._getframe().f_code.co_name)) max_range = self.ranges[1] - 1 (_, hist_max, _, _) = cv.GetMinMaxHistValue(self.cvhist[chan - 1]) hist_img = cv.CreateImage((max_range * scale_x, y_range * scale_y), self.depth, 1) cv.Zero(hist_img) # resets image values for i in range(max_range): # 0 to max_range hist_value = cv.QueryHistValue_1D(self.cvhist[chan - 1], i) next_value = cv.QueryHistValue_1D(self.cvhist[chan - 1], i + 1) pt1 = (int(i * scale_x), int(y_range * scale_y)) pt2 = (int(i * scale_x + scale_x), int(y_range * scale_y)) pt3 = (int(i * scale_x + scale_x), int((y_range - (next_value * y_range / hist_max)) * scale_y)) pt4 = (int(i * scale_x), int((y_range - (hist_value * y_range / hist_max)) * scale_y)) pts = (pt1, pt2, pt3, pt4) cv.FillConvexPoly(hist_img, pts, 255, lineType=8, shift=0) return hist_img
def update(self, im=None): if im is not None: self.im = im cv.CalcArrHist([self.im], self.hist) (min_value, max_value, _, _) = cv.GetMinMaxHistValue(self.hist) cv.Scale(self.hist.bins, self.hist.bins, float(self.hist_image.height) / max_value, 0) cv.Set(self.hist_image, cv.ScalarAll(255)) bin_w = round(float(self.hist_image.width) / self.hist_size) for i in range(self.hist_size): cv.Rectangle(self.hist_image, (int(i * bin_w), self.hist_image.height), (int((i + 1) * bin_w), self.hist_image.height - cv.Round(self.hist.bins[i])), self.color, -1, 8, 0) cv.ShowImage(self.title, self.hist_image)
def set_hist(self, frame, selection): sub = cv.GetSubRect(frame, selection) save = cv.CloneMat(sub) cv.ConvertScale(frame, frame, 0.5) cv.Copy(save, sub) x, y, w, h = selection # rectangular piece of frame cv.Rectangle(frame, (x, y), (x + w, y + h), (255, 255, 255)) sel = cv.GetSubRect(self.hue, selection) cv.CalcArrHist([sel], self.hist, 0) # get the most prevalent color in the histogram (_, max_val, _, _) = cv.GetMinMaxHistValue(self.hist) if max_val != 0: cv.ConvertScale(self.hist.bins, self.hist.bins, 255. / max_val) print "Val set to " + str(max_val)
def get_2d_hist_img(x_bins=30, y_bins=32, scale=10, hist=None, img=None): if not hist: if img: hist = get_hs_2d_hist(img, x_bins, y_bins) else: raise Exception("Histogram or image should be given") (_, max_value, _, _) = cv.GetMinMaxHistValue(hist) hist_img = cv.CreateImage((x_bins * scale, y_bins * scale), 8, 3) for h in range(x_bins): for s in range(y_bins): bin_val = cv.QueryHistValue_2D(hist, h, s) intensity = cv.Round(bin_val * 255 / max_value) cv.Rectangle( hist_img, (h * scale, s * scale), ((h + 1) * scale - 1, (s + 1) * scale - 1), cv.RGB(255 - intensity, 255 - intensity, 255 - intensity), cv.CV_FILLED) return hist_img
def get_hist_image(hist, bins, width=500): height = 255 white = cv.RGB(255, 255, 255) black = cv.RGB(0, 0, 0) img_size = (width, height) hist_img = cv.CreateImage(img_size, 8, 1) cv.Rectangle(hist_img, (0, 0), img_size, white, cv.CV_FILLED) (_, max_value, _, _) = cv.GetMinMaxHistValue(hist) scale = width / float(bins) x = 0 for s in range(bins): bin_val = cv.QueryHistValue_1D(hist, s) y = cv.Round(bin_val * height / max_value) cv.Rectangle(hist_img, (x, height - y), (x + scale, height), black, cv.CV_FILLED) x += scale return hist_img
def OCVHistogram(frame, ranges=[[0, 256]], hist_size=64): """Create a histogram of given frame""" if frame.nChannels != 1: dest = OCVCopyGrayscale(frame) else: dest = frame hist_image = cv.CreateImage((dest.width, dest.height), 8, 1) hist = cv.CreateHist([hist_size], cv.CV_HIST_ARRAY, ranges, 1) cv.CalcArrHist([dest], hist) (min_value, max_value, _, _) = cv.GetMinMaxHistValue(hist) cv.Scale(hist.bins, hist.bins, float(hist_image.height) / max_value, 0) cv.Set(hist_image, cv.ScalarAll(255)) bin_w = round(float(hist_image.width) / hist_size) for i in range(hist_size): cv.Rectangle(hist_image, (int(i * bin_w), hist_image.height), (int( (i + 1) * bin_w), hist_image.height - cv.Round(hist.bins[i])), cv.ScalarAll(0), -1, 8, 0) return hist_image
def __init__(self): self.bridge = cv_bridge.CvBridge() # Histogram parameters. bins_hue = rospy.get_param('~bins_hue', 10) min_hue = rospy.get_param('~min_hue', 0) max_hue = rospy.get_param('~max_hue', 255) bins_sat = rospy.get_param('~bins_sat', 10) min_sat = rospy.get_param('~min_sat', 0) max_sat = rospy.get_param('~max_sat', 255) self.ker_size = rospy.get_param('~kernel_size', 3) self.bins = [ bins_hue, bins_sat ] self.ranges = [ (min_hue, max_hue), (min_sat, max_sat) ] self.channels = [ CH_HUE, CH_SAT, CH_VAL ] # Histogram matching parameters. width = rospy.get_param('~window_width', 20) height = rospy.get_param('~window_height', 20) self.window = (width, height) self.method = cv.CV_COMP_CORREL # Load training data from a CSV file. train_path = rospy.get_param('~train_path') train_data = numpy.genfromtxt(train_path, delimiter=',', comments='@', dtype=numpy.uint8) # Build the HS-histogram of both positive and negative examples. pos = train_data[train_data[:,CH_LABEL] == 1, :] self.hist_pos = self.LoadHistogram(pos, self.channels, self.bins, self.ranges, 1.0) val_min, val_max, loc_min, loc_max = cv.GetMinMaxHistValue(self.hist_pos) rospy.loginfo('histogram counts are in range [{0}, {1}]'.format(val_min, val_max)) self.sub = rospy.Subscriber('image', sensor_msgs.msg.Image, self.ImageCallback) self.pub = rospy.Publisher('white', sensor_msgs.msg.Image)
def histogram(self, src): # Convert to HSV hsv = cv.CreateImage(cv.GetSize(src), 8, 3) cv.CvtColor(src, hsv, cv.CV_BGR2HSV) h_plane = cv.CreateMat(cv.GetSize(src)[1], cv.GetSize(src)[0], cv.CV_8UC1) s_plane = cv.CreateMat(cv.GetSize(src)[1], cv.GetSize(src)[0], cv.CV_8UC1) v_plane = cv.CreateMat(cv.GetSize(src)[1], cv.GetSize(src)[0], cv.CV_8UC1) cv.Split(hsv, h_plane, s_plane, v_plane, None) planes = [h_plane, s_plane] h_bins = 30 s_bins = 32 hist_size = [h_bins, s_bins] # hue varies from 0 (~0 deg red) to 180 (~360 deg red again */ h_ranges = [0, 180] # saturation varies from 0 (black-gray-white) to # 255 (pure spectrum color) s_ranges = [0, 255] ranges = [h_ranges, s_ranges] scale = 10 hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1) cv.CalcHist([cv.GetImage(i) for i in planes], hist) max_val = cv.GetMinMaxHistValue(hist)[3] max_hue_bin = max_val[0] max_sat_bin = max_val[1] # display this color in RGB h_interval = 6 s_interval = 8 hue = h_interval * max_hue_bin BGR_color = HSV_to_RGB(hue) cv.NamedWindow("About this color?", cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow("About this color?", 620, 530) color_swatch = cv.CreateImage((200, 140), 8, 3) cv.Set(color_swatch, BGR_color) cv.ShowImage("About this color?", color_swatch) return BGR_color, hue
################################### ########calculate histogram######## if biggestFace > 0: #sets the Region of Interest (face) in HSV image cv.SetImageROI(frameSmallHSV, rect) face = cv.CreateImage(cv.GetSize(frameSmallHSV), frameSmallHSV.depth, frameSmallHSV.nChannels) cv.Copy(frameSmallHSV, face) cv.ResetImageROI(frameSmallHSV) #get size of face area faceArea = face.height * face.width hist = hs_histogram(face) myHist = hist.getHist(hBins, sBins) (_, maxValue, _, _) = cv.GetMinMaxHistValue(myHist) print "face detected >>> Histogram constructed" hasHist = True ################################### else: # if hist already calculated skinProbImg = cv.CreateImage(cv.GetSize(frameSmallHSV), 8, 1) hueImg = cv.CreateMat(frameSmallHSV.height, frameSmallHSV.width, cv.CV_8UC1) satImg = cv.CreateMat(frameSmallHSV.height, frameSmallHSV.width, cv.CV_8UC1) cv.Split(frameSmallHSV, hueImg, satImg, None, None) binSum = face.height * face.width maxProbInt = 0 for x in range(0, frameSmallHSV.height):
def recompute_histogram(self, hist): sel = cv.GetSubRect(self.hue, self.selection) cv.CalcArrHist([sel], hist, 0) (_, max_val, _, _) = cv.GetMinMaxHistValue(hist) if max_val != 0: cv.ConvertScale(hist.bins, hist.bins, 255. / max_val)
def calc_1dhisto(inframe, nbin=256, scale=2, histh=200, hist=None, histimg=None): """ Calculate 1D intensity histogram of a iplimage, and return the histogram itself (as cv2.cv.cvhistogram) and an image representing this histogram ( as 8bit unsigned iplimage) Use **hist** and **histimg** if they are provided, otherwise create them from scratch. To re-use the allocated memory, simply pass the output as input for input **hist** and **histimg**. Histogram bar height is calculated as follows: bin_height = bin_count*1.0/(npix/nbin) * 0.2 * histh where bin_height is in pixels, bin_count is the number of pixels in this bin, npix the total number of pixels in the image, nbin the total bins, such that (npix/nbin) is the average bin count. 0.2 is a factor that sets the average bin height to 20% and histh scales the bin normalized bin height to pixels. @param [in] inframe Input frame, as iplimage @param [in] nbin Number of intensity bins @param [in] scale Histogram image bar width in pixels @param [in] histh Histogram image height in pixels @param [in] hist Previously allocated cv2.cv.cvhistogram to use @param [in] histimg Previously allocated iplimage to use @return Tuple of (histogram, histogram image) """ if (inframe.depth == cv.IPL_DEPTH_32F): hranges = [[0, 1]] elif (inframe.depth in [ cv.IPL_DEPTH_8U, cv.IPL_DEPTH_8S, cv.IPL_DEPTH_16U, cv.IPL_DEPTH_16S, cv.IPL_DEPTH_32S ]): hranges = None else: raise ValueError("Unsupported datatype ('%s')" % (str(inframe.depth))) if (not hist): hist = cv.CreateHist([nbin], cv.CV_HIST_ARRAY, ranges=[[0, 1]], uniform=1) if (not histimg): histimg = cv.CreateImage((nbin * scale, histh), cv.IPL_DEPTH_8U, 1) npix = np.product(cv.GetDims(inframe)) cv.CalcHist([cv.GetImage(inframe)], hist) hmin, hmax, _, _ = cv.GetMinMaxHistValue(hist) cv.Zero(histimg) for i in range(nbin): bin_val = cv.QueryHistValue_1D(hist, i) bin_h = int(bin_val * 1.0 / (npix / nbin) * 0.2 * histh) cv.Rectangle(histimg, (i * scale, histh), ((i + 1) * scale - 1, histh - bin_h), 256, cv.CV_FILLED) return hist, histimg
# Build the histogram and compute its contents. hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, [(0, 180), (0, 255)], 1) cv.CalcHist(planes, hist, 0, None) cv.NormalizeHist(hist, 1.0) # Create an image to use to visualize our histogram. scale = 10 hist_img = cv.CreateImage((h_bins * scale, s_bins * scale), 8, 3) cv.Zero(hist_img) max_value = 0 (minvalue, maxvalue, minidx, maxidx) = cv.GetMinMaxHistValue(hist) for h in range(h_bins): for s in range(s_bins): bin_val = cv.QueryHistValue_2D(hist, h, s) intensity = cv.Round(bin_val * 255 / maxvalue) cv.Rectangle(hist_img, (h * scale, s * scale), ((h + 1) * scale - 1, (s + 1) * scale - 1), (intensity, intensity, intensity), cv.CV_FILLED) print intensity cv.ShowImage("src", src) cv.ShowImage("hsv", hist_img) cv.WaitKey(0) else:
def back_project_hs(src, patch): # Convert to HSV hsv = cv.CreateImage(cv.GetSize(src), 8, 3) cv.CvtColor(src, hsv, cv.CV_BGR2HSV) hsv_patch= cv.CreateImage(cv.GetSize(patch), 8, 3) cv.CvtColor(patch, hsv_patch, cv.CV_BGR2HSV) # Extract the H and S planes h_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) h_plane_img = cv.CreateImage(cv.GetSize(src), 8, 1) h_plane_patch = cv.CreateMat(patch.rows, patch.cols, cv.CV_8UC1) s_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) s_plane_img = cv.CreateImage(cv.GetSize(src), 8, 1) s_plane_patch = cv.CreateMat(patch.rows, patch.cols, cv.CV_8UC1) v_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1) cv.Split(hsv, h_plane, s_plane, v_plane, None) cv.Split(hsv, h_plane_img, s_plane_img, None, None) cv.Split(hsv_patch, h_plane_patch, s_plane_patch, None, None) #cv.Split(src, h_plane, s_plane, v_plane, None) planes = [h_plane_patch, s_plane_patch]#, s_plane, v_plane] # planes = [s_plane_patch]#, s_plane, v_plane] h_bins = 30 s_bins = 32 hist_size = [h_bins, s_bins] # hue varies from 0 (~0 deg red) to 180 (~360 deg red again */ h_ranges = [0, 180] s_ranges = [0, 255] # saturation varies from 0 (black-gray-white) to # 255 (pure spectrum color) ranges = [h_ranges, s_ranges]#, s_ranges, v_ranges] #ranges = [s_ranges]#, s_ranges, v_ranges] scale = 1 hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1) #hist = cv.CreateHist([s_bins], cv.CV_HIST_ARRAY, ranges, 1) cv.CalcHist([cv.GetImage(i) for i in planes], hist) (min_value, max_value, _, _) = cv.GetMinMaxHistValue(hist) #cv.NormalizeHist(hist, 20*250.0) print "min hist value is :", min_value print "max hist value is :", max_value back_proj_img = cv.CreateImage(cv.GetSize(src), 8, 1) #cv.NormalizeHist(hist, 2000) cv.CalcBackProject([h_plane_img, s_plane_img], back_proj_img, hist) back_modified = cv.CreateImage(cv.GetSize(src), 8, 1) back_modified2 = cv.CreateImage(cv.GetSize(src), 8, 1) # cv.Dilate(back_proj_img, back_proj_img) # cv.Erode(back_proj_img, back_proj_img) #cv.Smooth(back_proj_img, back_modified) #cv.AdaptiveThreshold(back_proj_img, back_modified, 255, adaptive_method=cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C) #cv.Threshold(back_proj_img, back_modified, 250, 255, cv.CV_THRESH_BINARY) #cv.MorphologyEx(back_modified,back_modified2, None, None, cv.CV_MOP_CLOSE, 3) #cv.MorphologyEx(back_modified,back_modified2, None, None, cv.CV_MOP_CLOSE, 1) # cv.MorphologyEx(back_proj_img,back_modified2, None, None, cv.CV_MOP_CLOSE, 1) #cv.MorphologyEx(back_modified2,back_modified2, None, None, cv.CV_MOP_OPEN, 2) cv.MorphologyEx(back_proj_img,back_modified, None, None, cv.CV_MOP_OPEN, 1) cv.MorphologyEx(back_modified,back_modified, None, None, cv.CV_MOP_CLOSE, 2) cv.Threshold(back_modified, back_modified, 250, 255, cv.CV_THRESH_BINARY) # cv.MorphologyEx(back_proj_img,back_modified2, None, None, cv.CV_MOP_CLOSE, 1) # cv.MorphologyEx(back_modified2,back_modified2, None, None, cv.CV_MOP_OPEN, 2) #cv.FloodFill(back_modified, (320, 240), cv.Scalar(255), cv.Scalar(30), cv.Scalar(30), flags=8) # for i in xrange (10): # cv.MorphologyEx(back_modified,back_modified, None, None, cv.CV_MOP_OPEN, 3) # cv.MorphologyEx(back_modified,back_modified, None, None, cv.CV_MOP_CLOSE, 1) #cv.SubRS(back_modified, 255, back_modified) # cv.CalcBackProject([s_plane_img], back_proj_img, hist) # cv.Scale(back_proj_img, back_proj_img, 30000) cv.ShowImage("back_projection", back_proj_img) cv.ShowImage("back_modified", back_modified) cv.ShowImage("back_modified2", back_modified2) cv.WaitKey(0) #return back_proj_img, hist return back_modified, hist
def getMinMax(self): (min, max, minIdx, maxIdx) = cv.GetMinMaxHistValue(self.hist) return maxIdx
def camshift_track(roi_selection, img): """ setup_camshift: - is_rect_nonzero(r) - hue_histogram_as_image(hist) - making_selection(roi_selection) - create_hist() - placeholder() compute_camshift_centroid: - isolate_hue - compute_back_projection - recompute_histogram(roi_selection) - run_camshift - draw ellipse - find_centroid(track_box) - show_hist """ # setup_camshift def is_rect_nonzero(r): (_, _, w, h) = r return (w > 0) and (h > 0) def hue_histogram_as_image(hist): """ Returns representation of a hue histogram """ histimg_hsv = cv.CreateImage((320, 200), 8, 3) mybins = cv.CloneMatND(hist.bins) cv.Log(mybins, mybins) (_, hi, _, _) = cv.MinMaxLoc(mybins) cv.ConvertScale(mybins, mybins, 255. / hi) w, h = cv.GetSize(histimg_hsv) hdims = cv.GetDims(mybins)[0] for x in range(w): xh = (180 * x) / (w - 1) # hue sweeps from 0-180 across the image val = int(mybins[int(hdims * x / w)] * h / 255) cv.Rectangle(histimg_hsv, (x, 0), (x, h - val), (xh, 255, 64), -1) cv.Rectangle(histimg_hsv, (x, h - val), (x, h), (xh, 255, 255), -1) histimg = cv.CreateImage((320, 200), 8, 3) cv.CvtColor(histimg_hsv, histimg, cv.CV_HSV2BGR) return histimg # making_selection # print roi_selection[0] # print roi_selection[1] point1 = roi_selection[0] point2 = roi_selection[1] xmin = point1[0] ymin = point1[1] xmax = point2[0] ymax = point2[1] widthx = xmax - xmin heighty = ymax - ymin selection = (xmin, ymin, widthx, heighty) # end of making_selection # create_hist() hist = cv.CreateHist([180], cv.CV_HIST_ARRAY, [(0, 180)], 1) # end of create_hist # placeholder() backproject_mode = False # end of placeholder while True: # capture = cv.CaptureFromCAM(0) # frame = cv.QueryFrame(capture) # isolate_hue # Convert to HSV and keep the hue hsv = cv.CreateImage(cv.GetSize(frame), 8, 3) cv.CvtColor(frame, hsv, cv.CV_BGR2HSV) hue = cv.CreateImage(cv.GetSize(frame), 8, 1) cv.Split(hsv, hue, None, None, None) # end isolate_hue # Compute back projection backproject = cv.CreateImage(cv.GetSize(frame), 8, 1) # end compute back projection # highlight the current selected rectangle and recompute the histogram w = xmax - xmin h = ymax - ymax xmin, ymin, w, h = selection cv.Rectangle(frame, (xmin, ymin), (xmax, ymax), (0, 0, 255)) # end highlight # Run the camshift cv.CalcArrBackProject([hue], backproject, hist) # end run camshift # draw ellipse print "selection is" + str(selection) if selection and is_rect_nonzero(selection): crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, 10, 1) (iters, (area, value, rect), track_box) = cv.CamShift(backproject, selection, crit) selection = rect sel = cv.GetSubRect(hue, selection) cv.CalcArrHist([sel], hist, 0) (_, max_val, _, _) = cv.GetMinMaxHistValue(hist) if max_val != 0: cv.ConvertScale(hist.bins, hist.bins, 255. / max_val) elif selection and is_rect_nonzero(selection): cv.EllipseBox(frame, track_box, cv.CV_RGB(255, 0, 0), 3, cv.CV_AA, 0) # end draw ellipse # find centroid coordinate (x,y) and area (z) selection_centroid = track_box[0] xposition = selection_centroid[0] yposition = selection_centroid[1] width_height = track_box[1] # selection_area = width_height[0]*width_height[1] face_centroid_camshift = (xposition, yposition) # return face_centroid_camshift # end find centroid # show hist if backproject_mode: # cv.ShowImage( "CamShiftDemo", backproject) cv.ShowImage("Histogram", self.hue_histogram_as_image(hist)) # end show hist print "I made it this far" # print face_centroid_camshift return face_centroid_camshift
def OnIdle( self, ): """Request refresh of the context whenever idle. track, get position, update camera, then redraw""" hist = cv.CreateHist([180], cv.CV_HIST_ARRAY, [(0,180)], 1 ) backproject_mode = False while True: frame = cv.QueryFrame(self.capture) # Convert to HSV and keep the hue hsv = cv.CreateImage(cv.GetSize(frame), 8, 3) cv.CvtColor(frame, hsv, cv.CV_BGR2HSV) self.hue = cv.CreateImage(cv.GetSize(frame), 8, 1) cv.Split(hsv, self.hue, None, None, None) # Compute back projection backproject = cv.CreateImage(cv.GetSize(frame), 8, 1) # Run the cam-shift cv.CalcArrBackProject( [self.hue], backproject, hist ) if self.track_window and is_rect_nonzero(self.track_window): crit = ( cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, 10, 1) (iters, (area, value, rect), track_box) = cv.CamShift(backproject, self.track_window, crit) self.track_window = rect # If mouse is pressed, highlight the current selected rectangle # and recompute the histogram if self.drag_start and is_rect_nonzero(self.selection): sub = cv.GetSubRect(frame, self.selection) save = cv.CloneMat(sub) cv.ConvertScale(frame, frame, 0.5) cv.Copy(save, sub) x,y,w,h = self.selection cv.Rectangle(frame, (x,y), (x+w,y+h), (0,0,255)) sel = cv.GetSubRect(self.hue, self.selection ) cv.CalcArrHist( [sel], hist, 0) (_, max_val, _, _) = cv.GetMinMaxHistValue( hist) if max_val != 0: cv.ConvertScale(hist.bins, hist.bins, 255. / max_val) elif self.track_window and is_rect_nonzero(self.track_window): cv.EllipseBox(frame, track_box, cv.CV_RGB(255,0,0), 3, cv.CV_AA, 0 ) # find centroid coordinate (x,y) and area (z) selection_centroid = track_box[0] global xposition xposition = selection_centroid[0] global yposition yposition = selection_centroid[1] width_height = track_box[1] # writes output of coordinates to seed file if needed # with open('seed.txt', 'a') as f: # value = (xposition, yposition) # s = str(value) + '\n' # f.write(s) # # f.write('end_of_session') # f.close() # print outs print "x: " + str(xposition) print "y: " + str(yposition) selection_area = width_height[0]*width_height[1] # print "The width is: " + str(width_height[0]) + " The height is: " + str(width_height[1]) # print "centroid is: " + str(selection_centroid) # return "centroid is: " + str(selection_centroid) print "area: " + str(selection_area) # return "area is: " + str(selection_area) if not backproject_mode: cv.ShowImage( "CamShiftDemo", frame ) else: cv.ShowImage( "CamShiftDemo", backproject) cv.ShowImage( "Histogram", self.hue_histogram_as_image(hist)) c = cv.WaitKey(10) if c == 27: # escape key break elif c == ord("b"): # show backproject mode with "b" key backproject_mode = not backproject_mode self.triggerRedraw(1) return 1