def __produce_gradient_image(self, i, scale):
size = cv.GetSize(i)
grey_image = cv.CreateImage(size, 8, 1)
size = [s/scale for s in size]
grey_image_small = cv.CreateImage(size, 8, 1)
cv.CvtColor(i, grey_image, cv.CV_RGB2GRAY)
df_dx = cv.CreateImage(cv.GetSize(i), cv.IPL_DEPTH_16S, 1)
cv.Sobel( grey_image, df_dx, 1, 1)
cv.Convert(df_dx, grey_image)
cv.Resize(grey_image, grey_image_small)#, interpolation=cv.CV_INTER_NN)
cv.Resize(grey_image_small, grey_image)#, interpolation=cv.CV_INTER_NN)
return grey_image
def DetectFace(image, faceCascade):
#modified from: http://www.lucaamore.com/?p=638
min_size = (20, 20)
image_scale = 1
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Allocate the temporary images
smallImage = cv2.CreateImage((cv2.Round(
image.width / image_scale), cv2.Round(image.height / image_scale)), 8,
1)
# Scale input image for faster processing
cv2.Resize(image, smallImage, cv2.CV_INTER_LINEAR)
# Equalize the histogram
cv2.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv2.HaarDetectObjects(smallImage, faceCascade,
cv2.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
# If faces are found
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv2.Rectangle(image, pt1, pt2, cv2.RGB(255, 0, 0), 5, 8, 0)
return image
def detect_no_draw(self, img):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(img.width / self.image_scale),
cv.Round(img.height / self.image_scale)),
8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if self.cascade:
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, self.cascade,
cv.CreateMemStorage(0),
self.haar_scale, self.min_neighbors,
self.haar_flags, self.min_size)
t = cv.GetTickCount() - t
if faces:
return True
else:
return False
def DetectEyes(imageCV, faceCascade, eyeCascade):
minSize = (20, 20)
imageScale = 2
haarScale = 1.2
minNeighbors = 2
haarFlags = 0
# Allocate the temporary images
#gray = cv2.CreateImage((imageCV.width, image.height), 8, 1)
#smallImage = cv.CreateImage((cv.Round(image.width / image_scale), cv2.Round (image.height / image_scale)), 8 ,1)
# Convert color input image to grayscale
cv2.cvtColor(image, gray, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv2.Resize(gray, smallImage, cv.CV_INTER_LINEAR)
# Equalize the histogram
cv2.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv2.HaarDetectObjects(smallImage, faceCascade,
cv2.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
# If faces are found
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv2.Rectangle(image, pt1, pt2, cv2.RGB(255, 0, 0), 3, 8, 0)
def meanshiftUsingILM(path):
# Load original image given the image path
im = cv2.LoadImageM(path)
# Load bank of filters
filterBank = lmfilters.loadLMFilters()
# Resize image to decrease dimensions during clustering
resize_factor = 1
thumbnail = cv2.CreateMat(im.height / resize_factor,
im.width / resize_factor, cv2.CV_8UC3)
cv2.Resize(im, thumbnail)
# now work with resized thumbnail image
response = np.zeros(shape=((thumbnail.height) * (thumbnail.width), 4),
dtype=float)
for f in range(0, 48):
filter = filterBank[f]
# Resize the filter with the same factor for the resized image
dst = cv2.CreateImage(cv2.GetSize(thumbnail), cv2.IPL_DEPTH_32F, 3)
resizedFilter = cv2.CreateMat(filter.height / resize_factor,
filter.width / resize_factor,
filter.type)
cv2.Resize(filter, resizedFilter)
# Apply the current filter
cv2.Filter2D(thumbnail, dst, resizedFilter)
featureIndex = getFilterTypeIndex(f)
for j in range(0, thumbnail.height):
for i in range(0, thumbnail.width):
# Select the max. along the three channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
if maxRes > response[thumbnail.width * j + i, featureIndex]:
# Store the max. response for the given feature index
response[thumbnail.width * j + i, featureIndex] = maxRes
# Create new mean shift instance
ms = MeanShift(bandwidth=10, bin_seeding=True)
# Apply the mean shift clustering algorithm
ms.fit(response)
labels = ms.labels_
n_clusters_ = np.unique(labels)
print("Number of clusters: ", len(n_clusters_))
repaintImage(thumbnail, labels)
cv2.Resize(thumbnail, im)
return im
def fastResize(I, rszFac, sig=-1):
if rszFac == 1:
return I
else:
Icv = cv.fromarray(np.copy(I))
I1cv = cv.CreateMat(int(math.floor(
I.shape[0] * rszFac)), int(math.floor(I.shape[1] * rszFac)), Icv.type)
cv.Resize(Icv, I1cv)
Iout = np.asarray(I1cv)
if sig > 0:
Iout = gaussian_filter(Iout, sig)
return Iout
def enlarge_image(image, factor):
""" Enlarge the image to the given size
Image must be of type cv.cvmat"""
if type(image).__name__ == 'cvmat':
new_image = cv.CreateMat(int(round(image.height * factor)),
int(round(image.width * factor)),
cv.GetElemType(image))
cv.Resize(image, new_image)
image = new_image
logging.debug(
'Image has been enlarged with factor %.3f (face-detector.py)' %
(factor))
return image
else:
logging.error('Unkown Image Type (tools.py)')
def downsize_image(image):
""" Resize the image to the given size
Image must be of type cv.cvmat"""
height_factor = float(image.height / parameter.max_facesize[0])
width_factor = float(image.width / parameter.max_facesize[1])
if height_factor > width_factor:
new_face = cv.CreateMat(image.height / height_factor,
image.width / height_factor,
cv.GetElemType(image))
downsize_factor = height_factor
else:
new_face = cv.CreateMat(int(image.height / width_factor),
int(image.width / width_factor),
cv.GetElemType(image))
downsize_factor = width_factor
cv.Resize(image, new_face)
return new_face, downsize_factor
def detect_and_draw(self, img):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(img.width / self.image_scale),
cv.Round(img.height / self.image_scale)),
8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if self.cascade:
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, self.cascade,
cv.CreateMemStorage(0),
self.haar_scale, self.min_neighbors,
self.haar_flags, self.min_size)
t = cv.GetTickCount() - t
# print "time taken for detection = %gms" % (t/(cv.GetTickFrequency()*1000.))
if faces:
face_found = True
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * self.image_scale),
int(y * self.image_scale))
pt2 = (int((x + w) * self.image_scale),
int((y + h) * self.image_scale))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
else:
face_found = False
cv.ShowImage("video", img)
return face_found
# @Description: createImage.py
# @Author: 孤烟逐云zjy
# @Date: 2020/5/3 9:49
# @SoftWare: PyCharm
# @CSDN: https://blog.csdn.net/zjy123078_zjy
# @博客园: https://www.cnblogs.com/guyan-2020/
import cv2 as cv
im = cv.LoadImage('./images/photo01.jpg') # get the img
thum = cv.CreateImage((im.width / 2, im.height / 2), 8, 3)
cv.Resize(im, thum)
cv.SaveImage('thum.jpg', thum)
def detectFace(self, cam_img, faceCascade, eyeCascade, mouthCascade): # cam_img should be cv2.cv.iplcam_img
min_size = (20, 20)
image_scale = 2
haar_scale = 1.2
min_neighbors = 2
haar_flags = 0
image_width = int(cam_img.get(cv.CV_CAP_PROP_FRAME_WIDTH))
image_height = int(cam_img.get(cv.CV_CAP_PROP_FRAME_HEIGHT))
# Allocate the temporary images
gray = cv.CreateImage((image_width, image_height), 8, 1) # tuple as the first arg
smallImage = cv.CreateImage((cv.Round(image_width / image_scale), cv.Round(image_height / image_scale)), 8, 1)
(ok, img) = cam_img.read()
# print 'gray is of ',type(gray) >>> gray is of <type 'cv2.cv.iplimage'>
# print type(smallImage) >>> <type 'cv2.cv.iplimage'>
# print type(image) >>> <type 'cv2.VideoCapture'>
# print type(img) >>> <type 'numpy.ndarray'>
# convert numpy.ndarray to iplimage
ipl_img = cv2.cv.CreateImageHeader((img.shape[1], img.shape[0]), cv.IPL_DEPTH_8U, 3)
cv2.cv.SetData(ipl_img, img.tostring(), img.dtype.itemsize * 3 * img.shape[1])
# Convert color input image to grayscale
cv.CvtColor(ipl_img, gray, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv.Resize(gray, smallImage, cv.CV_INTER_LINEAR)
# Equalize the histogram
cv.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv.HaarDetectObjects(smallImage, faceCascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags, min_size)
# => The function returns a list of tuples, (rect, neighbors) , where rect is a CvRect specifying the object’s extents and neighbors is a number of neighbors.
# => CvRect cvRect(int x, int y, int width, int height)
# If faces are found
if faces:
face = faces[0]
self.faceX = face[0][0]
self.faceY = face[0][1]
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(ipl_img, pt1, pt2, cv.RGB(0, 0, 255), 3, 8, 0)
# face_region = cv.GetSubRect(ipl_img,(x,int(y + (h/4)),w,int(h/2)))
cv.SetImageROI(ipl_img, (pt1[0],
pt1[1],
pt2[0] - pt1[0],
int((pt2[1] - pt1[1]) * 0.7)))
eyes = cv.HaarDetectObjects(ipl_img, eyeCascade,
cv.CreateMemStorage(0),
haar_scale, min_neighbors,
haar_flags, (15, 15))
if eyes:
# For each eye found
for eye in eyes:
# Draw a rectangle around the eye
cv.Rectangle(ipl_img, # image
(eye[0][0], # vertex pt1
eye[0][1]),
(eye[0][0] + eye[0][2], # vertex pt2 opposite to pt1
eye[0][1] + eye[0][3]),
cv.RGB(255, 0, 0), 1, 4, 0) # color,thickness,lineType(8,4,cv.CV_AA),shift
cv.ResetImageROI(ipl_img)
return ipl_img
def detect_and_draw(img, cascade):
t = cv2.GetTickCount() ## start counter
cv2.CvtColor(img, gray, cv2.CV_BGR2GRAY)
cv2.Resize(gray, small_img, cv2.CV_INTER_LINEAR)
#Ages all trackedFaces
for f in trackedFaces:
f.updateLife()
#Remove expired faces
for f in trackedFaces:
if (f.isTooOld()):
trackedFaces.remove(f)
faces = cv2.HaarDetectObjects(small_img, cascade, storage, haar_scale,
min_neighbors, haar_flags, min_size)
drawline = 0
if faces:
#found a face
for ((x, y, w, h), n) in faces:
matchedFace = False
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
pt3 = (int(x * image_scale) + int(
((x + w) * image_scale - x * image_scale) / 3),
int(y * image_scale))
pt4 = (int((x + w) * image_scale) - int(
((x + w) * image_scale - x * image_scale) / 3),
int((y * image_scale) + int((
(y + h) * image_scale) - int(y * image_scale)) / 3))
#check if there are trackedFaces
if (len(trackedFaces) > 0):
#each face being tracked
for f in trackedFaces:
#the face is found (small movement)
if ((abs(f.xpt - pt1[0]) < FACE_MAX_MOVEMENT)
and (abs(f.ypt - pt1[1]) < FACE_MAX_MOVEMENT)):
matchedFace = True
f.updateFace(int(w * image_scale),
int(h * image_scale), pt1[0], pt1[1])
mf = f
break
#if face not found, add a new face
if (matchedFace == False):
f = Face(0, int(w * image_scale), int(h * image_scale),
pt1[0], pt1[1], 0)
trackedFaces.append(f)
mf = f
#No tracked faces: adding one
else:
f = Face(0, int(w * image_scale), int(h * image_scale), pt1[0],
pt1[1], 0)
trackedFaces.append(f)
mf = f
#where to draw face and properties
if (mf.age > 5):
#draw attention line
lnpt1 = (int(mf.xpt * scale), int(mf.ypt * scale - 5) - 5)
if (mf.age > mf.width):
lnpt2 = (int(mf.xpt * scale + mf.width),
int(mf.ypt * scale - 5))
else:
lnpt2 = (int(mf.xpt * scale + mf.age),
int(mf.ypt * scale - 5))
cv2.Rectangle(img, lnpt1, lnpt2, RED, 4, 8,
0) ## drawing bolded attention line
### draw eyes
cv2.Rectangle(img, mf.eyeLeft1, mf.eyeLeft2, MAGENTA, 3, 8, 0)
cv2.Rectangle(img, mf.eyeRight1, mf.eyeRight2, MAGENTA, 3, 8,
0)
#
### draw mouth
cv2.Rectangle(img, mf.mouthTopLeft, mf.mouthBotRight, ORANGE,
3, 8, 0)
#
### draw face
cv2.Rectangle(img, pt1, pt2, getColor(mf), 3, 8, 0)
#cv2.Rectangle( img, pt3, pt4, MAGENTA, 1, 8, 0 ) #forehead
drawline = mf.age
if (CAPTURING): saveAsJPG(img)
if (osName == "nt"): cv2.Flip(img, img, 0)
cv2.ShowImage('Camera', img)
t = cv2.GetTickCount() - t ## counter for FPS
print("%i fps." % (cv2.GetTickFrequency() * 1000000. / t)) ## print FPS
def imgresult = imgmatch(imgfile):
import numpy as np
import cv2 as cv
s1 = 'DeepLearning.JPG';s2 = 'ImageVideo.JPG';
s3 = 'ModenPhoto.JPG'; s4 = 'PatternRecognition.JPG';
booklist = [s1,s2,s3,s4];
s11 = 'deep_goodfellow';s22 = 'handbook_bovik';
s33 = 'modern_mikhail'; s44 = 'pattern_bishop';
newbook = [s11,s22,s33,s44];
for a < len(booklist)
imgRGB = cv.imread(booklist(a));
imgRGB = cv.Resize(imgRGB, [1000,NaN]);
img = single(rgb2gray(imgRGB));
[fcover,dcover] = vl_sift(img);
#imgfile = imread('IMG_0212.JPG');
imgfile = cv.resize(imgfile, [1000,NaN]);
Ia = single(rgb2gray(imgfile));
[fa, da] = vl_sift(Ia) ;
[matches, scores] = vl_ubcmatch(dcover, da) ;
#figure(1) ; clf ;
#imagesc(cat(2, Ia, img)) ;
xa = fa(1,matches(2,:)) ;
xcover = fcover(1,matches(1,:)) + size(Ia,2) ;
ya = fa(2,matches(2,:)) ;
ycover = fcover(2,matches(1,:)) ;
def resizeImage(im, width, height):
#It appears to me that resize an image can be significant for the ocr engine to detect characters
res = cv.CreateImage((width, height), im.depth, im.channels)
cv.Resize(im, res)
return res
def meanshiftUsingPCA(path):
# Load original image given the image path
im = cv2.LoadImageM(path)
#convert image to YUV color space
cv.CvtColor(im, im, cv2.CV_BGR2YCrCb)
# Load bank of filters
filterBank = lmfilters.loadLMFilters()
# Resize image to decrease dimensions during clustering
resize_factor = 1
thumbnail = cv2.CreateMat(im.height / resize_factor,
im.width / resize_factor, cv2.CV_8UC3)
cv2.Resize(im, thumbnail)
# now work with resized thumbnail image
response = np.zeros(shape=((thumbnail.height) * (thumbnail.width), 51),
dtype=float)
for f in range(0, 48):
filter = filterBank[f]
# Resize the filter with the same factor for the resized image
dst = cv2.CreateImage(cv2.GetSize(thumbnail), cv2.IPL_DEPTH_32F, 3)
resizedFilter = cv2.CreateMat(filter.height / resize_factor,
filter.width / resize_factor,
filter.type)
cv2.Resize(filter, resizedFilter)
# Apply the current filter
cv2.Filter2D(thumbnail, dst, resizedFilter)
for j in range(0, thumbnail.height):
for i in range(0, thumbnail.width):
# Select the max. along the three channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
if maxRes > response[thumbnail.width * j + i, f]:
# Store the max. response for the given feature index
response[thumbnail.width * j + i, f] = maxRes
#YUV features
count = 0
for j in range(0, thumbnail.height):
for i in range(0, thumbnail.width):
response[count, 48] = thumbnail[j, i][0]
response[count, 49] = thumbnail[j, i][1]
response[count, 50] = thumbnail[j, i][2]
count += 1
#get the first 4 primary components using pca
pca = PCA(response)
pcaResponse = zeros([thumbnail.height * thumbnail.width, 4])
for i in range(0, thumbnail.height * thumbnail.width):
pcaResponse[i] = pca.getPCA(response[i], 4)
# Create new mean shift instance
ms = MeanShift(bandwidth=10, bin_seeding=True)
# Apply the mean shift clustering algorithm
ms.fit(pcaResponse)
labels = ms.labels_
n_clusters_ = np.unique(labels)
print("Number of clusters: ", len(n_clusters_))
repaintImage(thumbnail, labels)
cv2.Resize(thumbnail, im)
return im
frame_copy = cv.CreateImage((frame.width, frame.height),
cv.IPL_DEPTH_8U, frame.nChannels)
if frame.origin == cv.IPL_ORIGIN_TL:
cv.Flip(frame, frame, -1)
# Our operations on the frame come here
gray = cv.CreateImage((frame.width, frame.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
frame.width / image_scale), cv.Round(frame.height / image_scale)), 8,
1)
# convert color input image to grayscale
cv.CvtColor(frame, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
midFace = None
if (cascade):
t = cv.GetTickCount()
# HaarDetectObjects takes 0.02s
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
if faces:
lights(50 if len(faces) == 0 else 0, 50 if len(faces) > 0 else 0,
0, 50)
def resize_image(image, height = 240, width = 320):
imageBuffer = image;
smallerImage = cv.CreateImage((width, height), imageBuffer.depth, imageBuffer.nChannels);
cv.Resize(imageBuffer, smallerImage, interpolation=cv.CV_INTER_CUBIC);
return smallerImage;
import cv2 imageBuffer = cv2.LoadImage( 'images/digits_sudoku2.png' ) nW = 468 nH = 99 smallerImage = cv2.CreateImage( (nH, nW), imageBuffer.depth, imageBuffer.nChannels ) cv2.Resize( imageBuffer, smallerImage , interpolation=cv2.CV_INTER_CUBIC ) cv2.SaveImage( 'images/digits_sudoku3.png', smallerImage )