def func1(x, y, z): print x print y print z def func2(*args): # Convert args tuple to a list so we can modify it args = list(args) args[0] = 'Hello' args[1] = 'awesome' func1(*args)func2('Goodbye', 'cruel', 'world!')# Will print# > Hello# > awesome# > world!
>>> a = [1,2,3]>>> for m in a:... print(m)...123>>> x = iter(a)>>> for i in x:... print(i)...123>>> for i in x:... print(x) # x 已经被迭代过了，是迭代的指针没有回去，理解为被清空了。...
lambda express: express 返回一个可以调用的对象，可以理解为函数double = lambda x : return x * 2
上面等价于
def double(x): retrun x * 2
所以关于
group_adjacent = lambda a, k: zip(*([iter(a)] * k))
我们首先看(k取3)：
>>>[iter(x)]*3[<list_iterator object at 0x0000026899671D68>, <list_iterator object at 0x0000026899671D68>, <list_iterator object at 0x0000026899671D68>]
>>> groupAdjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))>>> groupAdjacent(a,3)<zip object at 0x0000026899679FC8>>>> list(groupAdjacent(a,3))[(1, 2, 3), (4, 5, 6)]
>>>import itertools>>> a = [[1, 2], [3, 4], [5, 6]]>>> list(itertools.chain.from_iterable(a))[1, 2, 3, 4, 5, 6]>>> sum(a, [])[1, 2, 3, 4, 5, 6]>>> [x for l in a for x in l][1, 2, 3, 4, 5, 6]>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]>>> [x for l1 in a for l2 in l1 for x in l2][1, 2, 3, 4, 5, 6, 7, 8]>>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]>>> flatten(a)[1, 2, 3, 4, 5, 6, 7, 8]
>>> g = (x ** 2 for x in range(10))>>> g<generator object <genexpr> at 0x00000268994B6150>>>> next(g)0>>> next(g)1>>> sum(x ** 2 for x in range(10))285>>>
19、Dictionary comprehensions(字典推导)
>>> m = {x: x ** 2 for x in range(5)}>>> m{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}>>> m = {x: 'A' + str(x) for x in range(10)}>>> m{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}
20、 Inverting a dictionary using a dictionary comprehension(用字典推导反转字典)
>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> m{'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> {v : k for k,v in m.items()}{1: 'a', 2: 'b', 3: 'c', 4: 'd'}>>>
21、Named tuples (collections.namedtuple)(命名元组)
>>> import collections>>> Point = collections.namedtuple('Point',['x','y'])>>> p = Point(x=1.0,y=2.0)>>> pPoint(x=1.0, y=2.0)>>> p.x1.0>>> p.y2.0
]]>
<p class="description"></p>
case study_building an amazon.com cover searchhttps://0Leo0.github.io//2018/11/30/case study_building an amazon.com cover search.html2018-11-30T04:17:50.000Z2018-12-03T15:53:09.505Z
Building an amazon.com cover search
新建一个coverdescriptor.py
import numpy as np import cv2 class CoverDescriptor: def __init__(self,useSIFT = False): self.useSIFT = useSIFT
def describe(self,image): # initialize the BRISK detector and feature extractor(the # standard openCV 3 install includes BRISK by default) descriptor = cv2.BRISK_create() # check if SIFT should be utilized to detect and extract # features (this this will cause an error if you are using # OpenCV 3.0+ and do not have the `opencv_contrib` module # installed and use the `xfeatures2d` package) if self.useSIFT: descriptor = cv2.xfeatures2d.SIFT_create() # detect keypoints in the image, describing the region # surrounding each keypoint, then convert the keypoints # to a NumPy array (kps,descs) = descriptor.detectAndCompute(image,None) kps = np.float32([kp.pt for kp in kps]) # return a tuple of keypoints and descriptor return (kps,descs)
import numpy as np import cv2 class CoverMatcher: def __init__(self,descriptor,coverPaths,ratio=0.7, minMatches=40,useHamming=True): # store the descriptor, book cover paths, ratio and minimum # number of matches for the homography calculation, then # initialize the distance metric to be used when computing # the distance between features self.descriptor = descriptor self.coverPaths = coverPaths self.ratio = ratio self.minMatches = minMatches self.distanceMethod = "BruteForce" # if the Hamming distance should be used, then update the # distance method if useHamming: self.distanceMethod += "-Hamming"
值得注意的是，SIFT和SURF产生real-valued特征向量，而ORB，BRISK以及AKAZE则产生binary特征向量。在比较real-valued描述符的时候，比如，SIFT或者SURF，我们希望使用欧氏距离(Euclidean distance)。然而，如果我们使用BRISK特征(产生binary feature)，我们应该使用Hamming距离。你所选择的特征向量描述符(SIFT vs BISK)将会影响你的distance method。由于我们默认使用BRISK features，因此我们将使用Hamming method。
接下来，我们定义search方法，看看关键点和描述符将如何匹配：
def search(self,queryKps,queryDescs): # initialize the dictionary of results results = {} # loop over the book cover images for coverPath in self.coverPaths: # load the query image,convert it to grayscale,and # extract keypoints and descriptors cover = cv2.imread(coverPath) gray = cv2.cvtColor(cover,cv2.COLOR_BGR2GRAY) (kps,descs) = self.descriptor.describe(gray) # determine the number of matched , inlier keypoints, # then update the results score = self.match(queryKps,queryDescs,kps,descs) results[coverPath] = score # if matches were found,sort them if len(results) > 0: results = sorted([(v,k) for (v,k) in results.items() if v > 0],reverse = True) # return the results return results
def match(self,kpsA,featuresA,kpsB,featuresB): # compute the raw matches and initialize the list of actual # matches matcher = cv2.DescriptorMatcher_create(self.distanceMethod) rawMatches = matcher.knnMatch(featuresB,featuresA,2) matches = [] # loop over the raw matches for m in rawMatches: # ensure the distance is within a certain ratio of each # other if len(m) == 2 and m[0].distance < m[1].distance * self.ratio: matches.append((m[0].trainIdx,m[1].queryIdx)) # check to see if there are enough matches to process if len(matches) > self.minMatches: # construct the two sets of points ptsA = np.float32([kpsA[i] for (i,_) in matches]) ptsB = np.float32([kpsB[j] for (_,j) in matches]) # conpute the homography between the two sets of points # and compute the ratio of matched points (_,status) = cv2.findHomography(ptsA,ptsB,cv2.RANSAC,4.0) # return the ratio of the number of matched keypoints # to the total number of keypoints return float(status.sum()) / status.size # no matches were found return -1.0
然后确保下面两个情况成立(make a check to ensure two cases hold)。第一个是首先确保确实有two matches。第二个是应用David Lowe ratio进行测试，确保the first match的距离小于the second match 乘以 ratio的距离。
from __future__ import print_functionfrom preprocess.coverdescriptor import CoverDescriptorfrom preprocess.covermatcher import CoverMatcherimport argparseimport globimport csvimport cv2# construct the argument parse and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-d", "--db", required = True, help = "path to the book database")ap.add_argument("-c", "--covers", required = True, help = "path to the directory that contains our book covers")ap.add_argument("-q", "--query", required = True, help = "path to the query book cover")ap.add_argument("-s", "--sift", type = int, default = 0, help = "whether or not SIFT should be used")args = vars(ap.parse_args())# initialize the database dictionary of coversdb = {}# loop over the database for l in csv.reader(open(args["db"]): # update the database using image ID as the key db[l[0]] = l[1:]
# initialize the default parameters using BRISK is being useduseSIFT = args["sift"] > 0useHamming = args["sift"] == 0ratio = 0.7minMatches = 40# if SIFT is to be used, then update the parametersif useSIFT: minMatches = 50
# initialize the cover descriptor and cover matcher cd = CoverDescriptor(useSIFT = useSIFT)cv = CoverMatcher(cd,glob.glob(args["covers"] + "\\*.png"), ratio=ratio,minMatches=minMatches,useHamming = useHamming)# load the query image, convert it to grayscale,and extract # keypoints and descriptorsqueryImage = cv2.imread(args["query"])gray = cv2.cvtColor(queryImage,cv2.COLOR_BGR2GRAY)(queryKps,queryDescs) = cd.describe(gray)# try to match the book cover to a know database of imagesresults = cv.search(queryKps,queryDescs)# show the query covercv2.imshow("Query", queryImage)
# check to see if no results were found if len(results) == 0: print("I could not find a match for that cover!") cv2.waitKey(0)# otherwise , matches were found else: # loop over the results for (i,(score,coverPath)) in enumerate(results): # grab the book information (author,title) = db[coverPath[coverPath.rfind("\\") + 1:]] print("{} . {:.2f}% : {} -- {}".format(i+1,score * 100, author,title)) # load the result image and show it result = cv2.imread(coverPath) cv2.imshow("Result",result) cv2.waitKey(0)
]]>
<p class="description"></p>
case study_plant classificationhttps://0Leo0.github.io//2018/11/29/case study_plant classification.html2018-11-29T04:17:50.000Z2018-12-03T15:55:20.644Z
Plant classification
新建一个rbghistogram.py文件
import cv2 class RGBHistogram: def __init__(self,bins): # store the number of bins the histogram will use self.bins = bins def describe(self,image,mask=None): # compute a 3D histogram in the RGB colorspace, # then normalize the histogram so that images # with the same content,but either scaled larger # or smaller will have(roughly) the same histogram hist = cv2.calcHist([image],[0,1,2], mask,self.bins,[0,256,0,256,0,256]) cv2.normalize(hist,hist) # return out 3D histogram as a flattened array return hist.flatten()
# grab the image and mask paths imagePaths = sorted(glob.glob(args["images"] + "\\*.png"))maskPaths = sorted(glob.glob(args["masks"] + "\\*.png"))# initialize the list of data and class label targetsdata = []target = []# initialize the image descriptordesc = RGBHistogram([8,8,8])# loop over the image and mask paths for (imagePath,maskPath) in zip(imagePaths,maskPaths): # load the image and mask image = cv2.imread(imagePath) mask = cv2.imread(maskPath) mask = cv2.cvtColor(mask,cv2.COLOR_BGR2GRAY) # describe the image features = desc.describe(image,mask) # update the list of data and targets data.append(features) target.append(imagePath.split("_")[-2])
# grab the unique target names and encode the labels targetNames = np.unique(target)le = LabelEncoder()target = le.fit_transform(target)# construct the training and testing splits (trainData,testData,trainTarget,testTarget) = train_test_split(data,target, test_size=0.3,random_state = 42)# train the classifiermodel = RandomForestClassifier(n_estimators=25,random_state=84)model.fit(trainData,trainTarget)# evaluate the classifier print(classification_report(testTarget,model.predict(testData), target_names=targetNames))
# loop over a sample of the images for i in np.random.choice(np.arange(0,len(imagePaths)),10): # grab the image and mask paths imagePath = imagePaths[i] maskPath = maskPaths[i] # load the image and mask image = cv2.imread(imagePath) mask = cv2.imread(maskPath) mask = cv2.cvtColor(mask,cv2.COLOR_BGR2GRAY) # describe the image features = desc.describe(image,mask) # predict what type of flower the image is flower = le.inverse_transform(model.predict([features]))[0] print(imagePath) print("I think this flower is a {}".format(flower.upper())) cv2.imshow("image",image) cv2.waitKey(0)
import cv2 class EyeTracker: def __init__(self,faceCascadePath,eyeCascadePath): # load the face and eye detector self.faceCascade = cv2.CascadeClassifier(faceCascadePath) self.eyeCascade = cv2.CascadeClassifier(eyeCascadePath) def track(self,image): # detect faces in the image and initialize the list of # rectangles containing the faces and eyes faceRects = self.faceCascade.detectMultiScale(image, scaleFactor=1.1,minNeighbors=5,minSize=(30,30), flags=cv2.CASCADE_SCALE_IMAGE) rects = []
# loop over the face bounding boxesfor (fX,fY,fW,fH) in faceRects: # extract the face ROI and update the list of # bounding boxes faceROI = image[fY:fY + fH,fX:fX + fW] rects.append((fX,fY,fX + fW,fY + fH)) # detect eyes in the face ROI eyeRects = self.eyeCascade.detectMultiScale(faceROI, scaleFactor=1.1,minNeighbors=10, minSize=(20,20), flags=cv2.CASCADE_SCALE_IMAGE) # loop over the eye bounding boxes for (eX,eY,eW,eH) in eyeRects: # update the list of boounding boxes rects.append((fX + eX,fY + eY,fX + eX + eW,fY + eY + eH))# return the rectangles representing bounding# boxes around the faces and eyesreturn rects
然后，我们使用NumPy阵列切片从图像中提取面部感兴趣区域(ROI:region of interest)。faceROI变量现在包含面部的边界框区域。
from preprocess import EyeTracker import imutilsimport argparseimport cv2 # construct the argument parse and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-f", "--face", required = True, help = "path to where the face cascade resides")ap.add_argument("-e", "--eye", required = True, help = "path to where the eye cascade resides")ap.add_argument("-v", "--video", help = "path to the (optional) video file")args = vars(ap.parse_args())# construct the eye trackeret = EyeTracker(args["face"],args["eye"])
# if a video path was not supplied, grab the reference# to the grayif not args.get("video"): camera = cv2.VideoCapture(0)# otherwise, load the videoelse: camera = cv2.VideoCapture(args["video"])# keep loopingwhile True: # grab the current frame (grabbed,frame) = camera.read() # if we are viewing a video and we did not grab a # frame, then we have reached the end of the video if args.get("video") and not grabbed: break
# resize the frame and convert it to grayscale frame = imutils.resize(frame,width=300) gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) # detect faces and eyes in the image rects = et.track(gray) # loop over the face bounding boxes and draw them for rect in rects: cv2.rectangle(frame,(rect[0],rect[1]), (rect[2],rect[3]),(0,255,0),2) # show the tracked eyes and face cv2.imshow("Tracking",frame) # if the 'q' key is pressed, stop the loop if cv2.waitKey(1) & 0xFF == ord("q"): break# cleanup the camera and close any open windowscamera.release()cv2.destroyAllWindows()
]]>
<p class="description"></p>
case study_handwriting recognition with hoghttps://0Leo0.github.io//2018/11/28/case study_handwriting recognition with hog.html2018-11-28T04:17:50.000Z2018-12-03T15:54:37.081Z
Handwriting recognition with HOG
HOG：Histogram of Oriented Gradients。类似于边缘方向直方图和局部不变描述符(例如SIFT)，HOG对图像的梯度幅度进行操作。
from skimage import feature class HOG: def __init__(self,orientations = 9,pixelsPerCell=(8,8), cellsPerBlock=(3,3),transform=False): # store the number of orientations, pixels per cell, # cells per block, and whether or not power law # compression should be applied self.orienations = orientations self.pixelsPerCell = pixelsPerCell self.cellsPerBlock = cellsPerBlock self.transform = transform def describe(self,image): # compute HOG for the image hist = feature.hog(image,orientations=self.orienations, pixels_per_cell=self.pixelsPerCell, cells_per_block=self.cellsPerBlock, transform_sqrt=self.transform) # return the HOG features return hist
from . import imutilsimport numpy as np import mahotasimport cv2 def load_digits(datasetPath): # build the dataset and then split it into data # and labels data = np.genfromtxt(datasetPath,delimiter=",",dtype="uint8") target = data[:,0] data = data[:,1:].reshape(data.shape[0],28,28) # return a tuple of the data and targets return (data,target)
def deskew(image,width): # grab the width and height of the image and compute # moments for the image (h,w) = image.shape[:2] moments = cv2.moments(image) # deskew the image by applying an affine transformation skew = moments["mu11"] / moments["mu02"] M = np.float32([ [1,skew,-0.5 * w * skew], [0,1,0] ]) image = cv2.warpAffine(image,M,(w,h), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR) # resize the image to have a constant width image = imutils.resize(image,width = width) # return the deskewed image return image
def center_extent(image,size): # grab the extent width and height (eW,eH) = size # handle when the width is greater than the height if image.shape[1] > image.shape[0]: image = imutils.resize(image,width = eW) # otherwise , the height is greater than the width else: image = imutils.resize(image,height = eH) # allocate memory for the extent of the image and # grab it extent = np.zeros((eH,eW),dtype="uint8") offsetX = (eW - image.shape[1]) // 2 offsetY = (eH - image.shape[0]) // 2 extent[offsetY:offsetY + image.shape[0],offsetX:offsetX + image.shape[1]] = image # compute the center of mass of the image and then # move the center of mass to the center of the image (cY,cX) = np.round(mahotas.center_of_mass(extent)).astype("int32") (dX,dY) = ((size[0] // 2) - cX,(size[1] // 2) - cY) M = np.float32([[1,0,dX],[0,1,dY]]) extent = cv2.warpAffine(extent,M,size) # return the extent of the image return extent
M是我们的平移矩阵，该矩阵告诉我们的图像要进行平移多少像素(从左到右，从上到下)。该矩阵被定义为float32类型的数组，因为OpenCV希望该矩阵是一个float类型。[1,0,tx]，其中tx是the number of pixels we will shift the image left or right，而负值则表示图像将向左平移，正值表示图像将向右平移。然后[0,1,ty]，其中，ty是the number of pixels we will shift the image up or down。其中，负值表示图像向上平移，正值表示图像向下平移。我们定义好了平移矩阵之后，图像的实际平移是使用了cv2.warpAffine函数来执行，该函数的第一个参数是我们要进行平移的图像，第二个参数是我们的平移矩阵M，最后我们需要手动地提供图像的尺寸(width and height)作为第三个参数。
最后，我们将居中图像返回给调用者。
接下来训练我们的机器模型，编写train.py文件
# import the necessary packagesfrom sklearn.externals import joblibfrom sklearn.svm import LinearSVCfrom preprocess.hog import HOGfrom preprocess import datasetimport argparse# construct the argument parse and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-d", "--dataset", required = True, help = "path to the dataset file")ap.add_argument("-m", "--model", required = True, help = "path to where the model will be stored")args = vars(ap.parse_args())
# load the dataset and initialize the data matrix(digits,target) = dataset.load_digits(args["dataset"])data = []# initialize the HOG descriptorhog = HOG(orientations=18,pixelsPerCell=(10,10), cellsPerBlock=(1,1),transform=True)#loop over the images for image in digits: # deskew the image, center it image = dataset.deskew(image,20) image = dataset.center_extent(image,(20,20)) # describe the image and update the data matrix hist = hog.describe(image) data.append(hist)
from __future__ import print_functionfrom sklearn.externals import joblibfrom preprocess.hog import HOGfrom preprocess import datasetimport argparseimport mahotasimport cv2# construct the argument parse and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-m", "--model", required = True, help = "path to where the model will be stored")ap.add_argument("-i", "--image", required = True, help = "path to the image file")args = vars(ap.parse_args())model = joblib.load(args["model"])# initialize the HOG descriptorhog = HOG(orientations = 18, pixelsPerCell = (10, 10), cellsPerBlock = (1, 1), transform = True)
# load the image and convert it to grayscaleimage = cv2.imread(args["image"])gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)# blur the image, find edges, and then find contours along# the edged regionsblurred = cv2.GaussianBlur(gray,(5,5),0)edged = cv2.Canny(blurred,30,150)(_,cnts,_) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)# sort the contours by their x-axis position, ensuring# that we read the numbers from left to rightcnts = sorted([(c,cv2.boundingRect(c)[0]) for c in cnts],key=lambda x:x[1])
# loop over the contoursfor (c,_) in cnts: # compute the bouding box for the rectangle (x,y,w,h) = cv2.boundingRect(c) # if the width is at least 7 pixels and the height # is at least 20 pixels, the contour is likely a digit if w>=7 and h>=20: # crop the ROI and then threshold the grayscale # ROI to reveal the digit roi = gray[y:y + h,x:x + w] thresh = roi.copy() T = mahotas.thresholding.otsu(roi) thresh[thresh > T] = 255 thresh = cv2.bitwise_not(thresh) # deskew the image center its extent thresh = dataset.deskew(thresh, 20) thresh = dataset.center_extent(thresh, (20, 20)) cv2.imshow("thresh", thresh)
# extract features from the image and classify it hist = hog.describe(thresh)digit = model.predict([hist])[0]print("I think thath number is : {}".format(digit))# draw a rectangle around the digit, the show what # digit was classified as cv2.rectangle(image,(x,y),(x + w,y + h),(0,255,0),1)cv2.putText(image,str(digit),(x-10,y-10), cv2.FONT_HERSHEY_SIMPLEX,1.2,(0,255,0),2)cv2.imshow("Image",image)cv2.waitKey(0)
]]>
<p class="description"></p>
case study_object tracking in videohttps://0Leo0.github.io//2018/11/27/case study_object tracking in video.html2018-11-27T05:17:50.000Z2018-12-03T15:55:00.586Z
Object tracking in video
import numpy as np import argparseimport timeimport cv2 # construct the argument parse and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-v", "--video", help = "path to the (optional) video file")args = vars(ap.parse_args())# define the upper and lower boundaries for a color# to be considered "blue"blueLower = np.array([100,67,0],dtype="uint8")blueUpper = np.array([255,128,50],dtype="uint8")# load the videoif not args.get("video"): camera = cv2.VideoCapture(0)else: camera = cv2.VideoCapture(args["video"])
# keep looping while True: # grab the current frame (grabbed,frame) = camera.read() # check to see if we have reached the end of the video if args.get("video") and not grabbed: break # determine which pixels fall within the blue boundaries # and then blur the binary image blue = cv2.inRange(frame,blueLower,blueUpper) blue = cv2.GaussianBlur(blue,(3,3),0)
# find contours in the image (_,cnts,_) = cv2.findContours(blue.copy(),cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # check to see if any contours were found if len(cnts) > 0: # sort the contours and find the largest one -- # we will assume this contour coorespondes to the # area of my phone cnt = sorted(cnts,key=cv2.contourArea,reverse=True)[0] # compute the (rotated) bounding box around then # contour and then draw it rect = np.int32(cv2.boxPoints(cv2.minAreaRect(cnt))) cv2.drawContours(frame,[rect],-1,(0,255,0),2) # show the frame and the binary image cv2.imshow("Traccking",frame) cv2.imshow("Binary",blue) # if your machine is fast, it may display the frames in # what appears to be 'fast forward' since more than 32 # frames per second are being displayed -- a simple hack # is just to sleep for a tiny bit in between frames; # however, if your computer is slow, you probably want to # comment out this line time.sleep(0.025) # if the 'q' key is pressed, stop the loop if cv2.waitKey(1) & 0xFF == ord("q"): break# cleanup the camera and close any open windowscamera.release()cv2.destroyAllWindows()
]]>
<p class="description"></p>
case study_webcam face detectionhttps://0Leo0.github.io//2018/11/27/case study_webcam face detection.html2018-11-27T02:17:50.000Z2018-12-03T15:55:44.593Z
Webcam face detection
from preprocess import FaceDetectorfrom preprocess import imutils import argparseimport cv2 # construct the argument parse and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-f", "--face", required = True, help = "path to where the face cascade resides")ap.add_argument("-v", "--video", help = "path to the (optional) video file")args = vars(ap.parse_args())# construct the face detectorfd = FaceDetector(args["face"])
# if a video path was not supplied, grab the reference# to the grayif not args.get("video"): camera = cv2.VideoCapture(0)else: camera = cv2.VideoCapture(args["video"])
# keep loopingwhile True: # grab the current frame (grabbed,frame) = camera.read() # if we are viewing a video and we did not grab a # frame, then we have reached the end of the video if args.get("video") and not grabbed: break # resize the frame and convert it to grayscale frame = imutils.resize(frame,width=300) gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
# detect faces in the image and then clone the frame # so that we can draw on it faceRects = fd.detect(gray,scaleFactor=1.1,minNeighbors=5, minSize=(30,30)) frameClone = frame.copy() # loop over the face bounding boxes and draw them for (fX,fY,fW,fH) in faceRects: cv2.rectangle(frameClone,(fX,fY),(fX + fW,fY + fH),(0,255,0),2) # show our detected faces cv2.imshow("Face",frameClone) # if the 'q' key is pressed, stop the loop if cv2.waitKey(1) & 0xFF == ord("q"): break # cleanup the camera and close any open windows camera.release()cv2.destroyAllWindows()
]]>
<p class="description"></p>
case study_face detectionhttps://0Leo0.github.io//2018/11/26/case study_face detection.html2018-11-26T14:17:50.000Z2018-12-03T15:54:13.395Z
Face Detection
from __future__ import print_functionfrom preprocess import FaceDetectorimport argparseimport cv2 ap = argparse.ArgumentParser()ap.add_argument("-f", "--face", required = True, help = "path to where the face cascade resides")ap.add_argument("-i", "--image", required = True, help = "path to where the image file resides")args = vars(ap.parse_args())# load the image and convert it to grayscaleimage = cv2.imread(args["image"])gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# find faces in the imagefd = FaceDetector(args["face"])faceRects = fd.detect(gray,scaleFactor=1.1,minNeighbors=5, minSize=(30,30))print("I found {} face(s)".format(len(faceRects))) # loop over the faces and draw a rectangle around eachfor (x,y,w,h) in faceRects: cv2.rectangle(image,(x,y),(x + w,y + h),(0,255,0),2)# show the detected facescv2.imshow("Faces",image)cv2.waitKey(0)
from __future__ import print_functionimport numpy as npimport argparseimport cv2# Construct the argument parser and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-i", "--image", required = True, help = "Path to the image")args = vars(ap.parse_args())# Load the image, convert it to grayscale, and blur it slightlyimage = cv2.imread(args["image"])gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)blurred = cv2.GaussianBlur(gray, (11, 11), 0)cv2.imshow("Image", image)# The first thing we are going to do is apply edge detection to# the image to reveal the outlines of the coinsedged = cv2.Canny(blurred, 30, 150)cv2.imshow("Edges", edged)
# Find contours in the edged image.# NOTE: The cv2.findContours method is DESTRUCTIVE to the image# you pass in. If you intend on reusing your edged image, be# sure to copy it before calling cv2.findContours(_,cnts,_) = cv2.findContours(edged.copy(),cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)# How many contours did we find?print("I count {} coins in this image".format(len(cnts)))# Let's highlight the coins in the original image by drawing a# green circle around themcoins = image.copy()cv2.drawContours(coins,cnts,-1,(0,255,0),2)cv2.imshow("Coins",coins)cv2.waitKey(0)
现在我们有了硬币的轮廓，我们可以找到the contours of the outlines。我们使用cv2.findContours函数来实现。此方法返回一个3元组：(1)应用轮廓检测后的图像(经过修改并基本上被破坏)，(2)轮廓本身，cnts以及(3)轮廓的层次结构(见下文)。
Note:
The return tuple of cv2. findContours has changed in OpenCV 3.0. Originally in OpenCV 2.4.X, this tuple was only a 2-tuple, consisting of just the contours themselves and the associated hierarchy. However, in OpenCV 3.0, we have a third value added to the return tuple: the image itself after applying the contour detection algorithm. This is a small, minor change (and one that I’m personally not crazy about since it breaks backwards compatibility with so many scripts), but something that can definitely trip you up when working with both OpenCV 2.4.X and OpenCV 3.0. Be sure to take special care when using the cv2. findContours function if you intend for your code to be cross-version portable.
# Now, let's loop over each contourfor (i,c) in enumerate(cnts): # We can compute the 'bounding box' for each contour, which is # the rectangle that encloses the contour (x,y,w,h) = cv2.boundingRect(c) # Now that we have the contour, let's extract it using array # slices print("Coin #{}".format(i+1)) coin = image[y:y + h,x:x + w] cv2.imshow("Coin",coin) # Just for fun, let's construct a mask for the coin by finding # The minumum enclosing circle of the contour mask = np.zeros(image.shape[:2],dtype="uint8") ((centerX,centerY),radius) = cv2.minEnclosingCircle(c) cv2.circle(mask,(int(centerX),int(centerY)),int(radius),255,-1) mask = mask[y:y + h,x:x + w] cv2.imshow("Masked Coin",cv2.bitwise_and(coin,coin,mask=mask)) cv2.waitKey(0)
import numpy as np import argparseimport cv2 ap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path to the image")args = vars(ap.parse_args())image = cv2.imread(args["image"])image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)cv2.imshow("orginal",image)# Compute the Laplacian of the imagelap = cv2.Laplacian(image,cv2.CV_64F)lap = np.uint8(np.absolute(lap))cv2.imshow("Laplacian",lap)cv2.waitKey(0)
# Compute gradients along the X and Y axis, respectivelysobelX = cv2.Sobel(image,cv2.CV_64F,1,0)sobelY = cv2.Sobel(image,cv2.CV_64F,0,1)# The sobelX and sobelY images are now of the floating# point data type -- we need to take care when converting# back to an 8-bit unsigned integer that we do not miss# any images due to clipping values outside the range# of [0, 255]. First, we take the absolute value of the# graident magnitude images, THEN we convert them back# to 8-bit unsigned integerssobelX = np.uint8(np.absolute(sobelX))sobelY = np.uint8(np.absolute(sobelY))# We can combine our Sobel gradient images using our# bitwise ORsobelCombined = cv2.bitwise_or(sobelX,sobelY)# Show our Sobel imagescv2.imshow("Sobel X",sobelX)cv2.imshow("Sobel Y",sobelY)cv2.imshow("Sobel Combined",sobelCombined)cv2.waitKey(0)
import numpy as npimport argparseimport cv2# Construct the argument parser and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-i", "--image", required = True, help = "Path to the image")args = vars(ap.parse_args())# Load the image, convert it to grayscale, and blur it# slightly to remove high frequency edges that we aren't# interested inimage = cv2.imread(args["image"])image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)image = cv2.GaussianBlur(image, (5, 5), 0)cv2.imshow("Blurred", image)# When performing Canny edge detection we need two values# for hysteresis: threshold1 and threshold2. Any gradient# value larger than threshold2 are considered to be an# edge. Any value below threshold1 are considered not to# ben an edge. Values in between threshold1 and threshold2# are either classified as edges or non-edges based on how# the intensities are "connected". In this case, any gradient# values below 30 are considered non-edges whereas any value# above 150 are considered edges.canny = cv2.Canny(image, 30, 150)cv2.imshow("Canny", canny)cv2.waitKey(0)
import numpy as np import argparse import cv2 # Construct the argument parser and parse the argumentsap = argparse.ArgumentParser()ap.add_argument("-i", "--image", required = True, help = "Path to the image")args = vars(ap.parse_args())# Load the image, convert it to grayscale, and blur it slightlyimage = cv2.imread(args["image"])image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)blurred = cv2.GaussianBlur(image,(5,5),0)cv2.imshow("Image",image)
import numpy as np import argparseimport cv2 ap = argparse.ArgumentParser()ap.add_argument("-i","--image",required=True, help="path to the image")args = vars(ap.parse_args())# Load the image, convert it to grayscale, and blur it slightlyimage = cv2.imread(args["image"])image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)blurred = cv2.GaussianBlur(image,(5,5,),0)cv2.imshow("Image",image)# In our previous example, we had to use manually specify a# pixel value to globally threshold the image. In this example# we are going to examine a neighborbood of pixels and adaptively# apply thresholding to each neighborbood. In this example, we'll# calculate the mean value of the neighborhood area of 11 pixels# and threshold based on that value. Finally, our constant C is# subtracted from the mean calculation (in this case 4)thresh = cv2.adaptiveThreshold(blurred,255, cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY_INV,11,4)cv2.imshow("Mean Thresh",thresh)# We can also apply Gaussian thresholding in the same mannerthresh = cv2.adaptiveThreshold(blurred,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,15,3)cv2.imshow("Gaussian Thresh",thresh)cv2.waitKey(0)
虽然OpenCV为Otsu的方法提供了支持，但我更喜欢Luis Pedro Coelho在mahotas包中的实现，因为它更像是Pythonic。
新建一个otsu_and_riddler.py文件
from __future__ import print_functionimport numpy as np import argparseimport mahotasimport cv2 ap = argparse.ArgumentParser()ap.add_argument("-i","--image",required=True, help="path to the image")args = vars(ap.parse_args())image = cv2.imread(args["image"])image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)blurred = cv2.GaussianBlur(image,(5,5),0)cv2.imshow("Image",image)# OpenCV provides methods to use Otsu's thresholding, but I find# the mahotas implementation is more 'Pythonic'. Otsu's method# assumes that are two 'peaks' in the grayscale histogram. It finds# these peaks, and then returns a value we should threshold on.T = mahotas.thresholding.otsu(blurred)print("Otsu's threshold:{}".format(T))
# Applying the threshold can be done using NumPy, where values# smaller than the threshold are set to zero, and values above# the threshold are set to 255 (white).thresh = image.copy()thresh[thresh > T] = 255thresh[thresh < 255] = 0thresh = cv2.bitwise_not(thresh)cv2.imshow("Otsu",thresh)# An alternative is to use the Riddler-Calvard methodT = mahotas.thresholding.rc(blurred)print("Riddler-Calvard:{}".format(T))thresh = image.copy()thresh[thresh > T] = 255thresh[thresh < 255] = 0thresh = cv2.bitwise_not(thresh)cv2.imshow("Riddler-Calvard",thresh)cv2.waitKey(0)
# Let's apply standard "averaging" blurring first. Average# blurring (as the name suggests), takes the average of all# pixels in the surrounding area and replaces the centeral# element of the output image with the average. Thus, in# order to have a central element, the area surrounding the# central must be odd. Here are a few examples with varying# kernel sizes. Notice how the larger the kernel gets, the# more blurred the image becomesblurred = np.hstack([ cv2.blur(image,(3,3)), cv2.blur(image,(5,5)), cv2.blur(image,(7,7))])cv2.imshow("Averaged",blurred)cv2.waitKey(0)
# We can also apply Gaussian blurring, where the relevant# parameters are the image we want to blur and the standard# deviation in the X and Y direction. Again, as the standard# deviation size increases, the image becomes progressively# more blurredblurred = np.hstack([ cv2.GaussianBlur(image,(3,3),0), cv2.GaussianBlur(image,(5,5),0), cv2.GaussianBlur(image,(7,7),0)])cv2.imshow("Gaussian",blurred)cv2.waitKey(0)
# The cv2.medianBlur function is mainly used for removing# what is called "salt-and-pepper" noise. Unlike the Average# method mentioned above, the median method (as the name# suggests), calculates the median pixel value amongst the# surrounding area.blurred = np.hstack([ cv2.medianBlur(image,3), cv2.medianBlur(image,5), cv2.medianBlur(image,7)])cv2.imshow("Median",blurred)cv2.waitKey(0)
# You may have noticed that blurring can help remove noise,# but also makes edge less sharp. In order to keep edges# sharp, we can use bilateral filtering. We need to specify# the diameter of the neighborhood (as in examples above),# along with sigma values for color and coordinate space.# The larger these sigma values, the more pixels will be# considered within the neighborhood.blurred = np.hstack([ cv2.bilateralFilter(image,5,21,21), cv2.bilateralFilter(image,7,31,31), cv2.bilateralFilter(image,9,41,41)])cv2.imshow("Bilateral",blurred)cv2.waitKey(0)
绘制直方图时，X轴作为我们的“箱(bins)”。如果我们构造一个有256个bins的直方图，那么我们就可以有效地计算每个像素值出现的次数。相反，如果我们仅使用2个(等间隔)二进制位，那么我们计算一个像素在[0,128]或[128,255]范围内的次数。The number of pixels binned to the x-axis value is then plotted on the y-axis.
from matplotlib import pyplot as plt import argparse import cv2 ap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path to the image")args = vars(ap.parse_args())image = cv2.imread(args["image"])image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)cv2.imshow("Original",image)
解释：导入必要的库，显示原始图像并转为灰度图
hist = cv2.calcHist([image],[0],None,[256],[0,256])plt.figure()plt.title("Grayscale Histogram")plt.xlabel("Bins")plt.ylabel("# of Pixels")plt.plot(hist)plt.xlim([0,256])plt.show()cv2.waitKey(0)
from __future__ import print_functionfrom matplotlib import pyplot as plt import numpy as np import argparseimport cv2 ap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path to the image")args = vars(ap.parse_args())image = cv2.imread(args["image"])cv2.imshow("Original",image)#Grab the image channels, initialize the tuple of colors#and the figurechans = cv2.split(image)colors = ("b","g","r")plt.figure()plt.title("'Flattened' Color Histogram")plt.xlabel("Bins")plt.ylabel("# of Pixels")#Loop over the image channelsfor (chan,color) in zip(chans,colors): #Create a histogram for the current channel and plot it hist = cv2.calcHist([chan],[0],None,[256],[0,256]) plt.plot(hist,color=color) plt.xlim([0,256]) plt.show()
#Let's move on to 2D histograms -- I am reducing the#number of bins in the histogram from 256 to 32 so we#can better visualize the resultsfig = plt.figure()#Plot a 2D color histogram for green and blueax = fig.add_subplot(131)hist = cv2.calcHist([chans[1],chans[0]],[0,1],None, [32,32],[0,256,0,256])p = ax.imshow(hist,interpolation="nearest")ax.set_title("2D Color Histogram for G and B")plt.colorbar(p)#Plot a 2D color histogram for green and redax = fig.add_subplot(132)hist = cv2.calcHist([chans[1],chans[2]],[0,1],None, [32,32],[0,256,0,256])p = ax.imshow(hist,interpolation="nearest")ax.set_title("2D Color Histogram for G and R")plt.colorbar(p)#Plot a 2D color histogram for blue and redax = fig.add_subplot(133)hist = cv2.calcHist([chans[0],chans[2]],[0,1],None, [32,32],[0,256,0,256])p = ax.imshow(hist,interpolation="nearest")ax.set_title("2D Color Histogram for B and R")plt.colorbar(p)print("2D histogram shape : {}, with {} values".format( hist.shape,hist.flatten().shape[0]))
# Our 2D histogram could only take into account 2 out# of the 3 channels in the image so now let's build a# 3D color histogram (utilizing all channels) with 8 bins# in each direction -- we can't plot the 3D histogram, but# the theory is exactly like that of a 2D histogram, so# we'll just show the shape of the histogramhist = cv2.calcHist([image], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])print("3D histogram shape: {}, with {} values".format( hist.shape, hist.flatten().shape[0]))# Show our plotsplt.show()
import numpy as np import argparseimport cv2 ap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path to the image")args = vars(ap.parse_args())# Load the image and convert it to grayscaleimage = cv2.imread(args["image"])image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)# Apply histogram equalization to stretch the constrast# of our imageeq = cv2.equalizeHist(image)# Show our images -- notice how the constrast of the second# image has been stretchedcv2.imshow("Histogram Equalization",np.hstack([image,eq]))cv2.waitKey(0)
from matplotlib import pyplot as plt import numpy as np import argparseimport cv2 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") # Grab the image channels, initialize the tuple of colors # and the figure 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])
ap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path to the image")args = vars(ap.parse_args())image = cv2.imread(args["image"])cv2.imshow("Original",image)plot_histogram(image,"Histogram for Original Image")# Construct a mask for our image -- our mask will be BLACK for# regions we want to IGNORE and WHITE for regions we want to# EXAMINE. In this example we will be examining the foliage# of the image, so we'll draw a white rectangle where the foliage# ismask = np.zeros(image.shape[:2],dtype="uint8")cv2.rectangle(mask,(15,15),(130,100),255,-1)cv2.imshow("Mask",mask)masked = cv2.bitwise_and(image,image,mask=mask)cv2.imshow("Applying the Mask",masked)cv2.waitKey(0)
# Let's compute a histogram for our image, but we'll only include# pixels in the masked regionplot_histogram(image, "Histogram for Masked Image", mask = mask)# Show our plotsplt.show()
# Construct the argument parser and parse the argumentsap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path ot the image")args = vars(ap.parse_args())# Load the image and show itimage = cv2.imread(args["image"])cv2.imshow("Original",image)
读取输入参数，显示原始图片。
# Convert the image to grayscalegray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)cv2.imshow("Gray",gray)# Convert the image to the HSV (Hue, Saturation, Value)# color spaceshsv = cv2.cvtColor(image,cv2.COLOR_BGR2HSV)cv2.imshow("HSV",hsv)lab = cv2.cvtColor(image,cv2.COLOR_BGR2LAB)cv2.imshow("L*a*b",lab)cv2.waitKey(0)
import numpy as np import argparseimport cv2 # Construct the argument parser and parse the argumentsap = argparse.ArgumentParser()ap.add_argument('-i',"--image",required=True, help="path to the image")args = vars(ap.parse_args())
上面读取输入参数。
# Load the image and grab each channel: Red, Green, and Blue# NOTE: OpenCV stores an image as NumPy array with its# channels in reverse order! When we call cv2.split, we are# actually getting the channels as Blue, Green, Red!image = cv2.imread(args["image"])(B,G,R) = cv2.split(image)# Show each channel individuallycv2.imshow("Red",R)cv2.imshow("Green",G)cv2.imshow("Blue",B)cv2.waitKey(0)# Merge the image back together againmerged = cv2.merge([B,G,R])cv2.imshow("Merged",merged)cv2.waitKey(0)cv2.destroyAllWindows()
# Now, let's visualize each channel in colorzeros = np.zeros(image.shape[:2],dtype="uint8")cv2.imshow("Red",cv2.merge([zeros,zeros,R]))cv2.imshow("Green",cv2.merge([zeros,G,zeros]))cv2.imshow("Blue",cv2.merge([B,zeros,zeros]))cv2.waitKey(0)
