def locateMarker(self, frame):
self.frameReal = cv.CloneImage(frame)
self.frameImag = cv.CloneImage(frame)
self.frameRealThirdHarmonics = cv.CloneImage(frame)
self.frameImagThirdHarmonics = cv.CloneImage(frame)
# Calculate convolution and determine response strength.
cv.Filter2D(self.frameReal, self.frameReal, self.matReal)
cv.Filter2D(self.frameImag, self.frameImag, self.matImag)
cv.Mul(self.frameReal, self.frameReal, self.frameRealSq)
cv.Mul(self.frameImag, self.frameImag, self.frameImagSq)
cv.Add(self.frameRealSq, self.frameImagSq, self.frameSumSq)
# Calculate convolution of third harmonics for quality estimation.
#cv.Filter2D(self.frameRealThirdHarmonics, self.frameRealThirdHarmonics, self.matRealThirdHarmonics)
#cv.Filter2D(self.frameImagThirdHarmonics, self.frameImagThirdHarmonics, self.matImagThirdHarmonics)
min_val, max_val, min_loc, max_loc = cv.MinMaxLoc(self.frameSumSq)
self.lastMarkerLocation = max_loc
(xm, ym) = max_loc
self.determineMarkerOrientation(frame)
#self.determineMarkerQuality()
return max_loc
def main():
'''Testing Main method'''
import sys, cv
if len(sys.argv) == 1:
print 'No image.'
sys.exit(1)
im_file = sys.argv[1]
image = cv.LoadImageM(im_file, cv.CV_LOAD_IMAGE_GRAYSCALE)
size = 3
ori = (pi * 1) / 4
ste = 0.75
kern = cv.fromarray(SteerableFilter.get_filter(ori, size, False, ste))
kern_t = cv.fromarray(SteerableFilter.get_filter(ori, size, True, ste))
kernel = cv.CreateMat(size, size, cv.CV_32F)
kernel_t = cv.CreateMat(size, size, cv.CV_32F)
cv.Convert(kern, kernel)
cv.Convert(kern_t, kernel_t)
dst = cv.CreateMat(image.rows, image.cols, image.type)
dst_t = cv.CreateMat(image.rows, image.cols, image.type)
cv.Filter2D(image, dst, kernel)
cv.Filter2D(image, dst_t, kernel_t)
cv.ShowImage('Source', image)
cv.ShowImage('Result', dst)
cv.ShowImage('Result (Transpose)', dst_t)
cv.WaitKey(0)
cv.WaitKey(0)
cv.WaitKey(0)
def kmeansUsingLM(im, k, iterations, epsilon):
#array of filter kernels
filterBank = lmfilters.loadLMFilters()
#create the samples and labels vector
col = cv.Reshape(im, 3, im.width * im.height)
samples = cv.CreateMat(col.height, 48, cv.CV_32FC1)
for f in xrange(0, 48):
filter = filterBank[f]
dst = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Filter2D(im, dst, filter)
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
#take the maximum response from the 3 channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
samples[count, f] = maxRes
count += 1
labels = cv.CreateMat(col.height, 1, cv.CV_32SC1)
crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, iterations, epsilon)
cv.KMeans2(samples, k, labels, crit)
clusters = getClusters(col, samples, labels)
means = {}
for c in clusters:
means[c] = [0.0, 0.0, 0.0]
for v in clusters[c]:
means[c][0] += v[0]
means[c][1] += v[1]
means[c][2] += v[2]
means[c][0] /= len(clusters[c])
means[c][1] /= len(clusters[c])
means[c][2] /= len(clusters[c])
for m in means:
print m, means[m], len(clusters[m])
#apply clustering to the image
for i in xrange(0, col.rows):
lbl = labels[i, 0]
col[i, 0] = means[lbl]
def calc_retinal_layer(input_file,
retina_w,
retina_h,
is_random=False,
detailed=False):
''' calc_retinal_layer(): calculates the values for each ganglion cell in the retinal layer
1) read in image
2) resize if necessary
3) run retinal layer:
a) run difference-of-gaussian (Laplace seems to be similar/identical) on image
b) extract given number of pixels
NOTE: always call build_kernel before calling this function the first time
inputs:
input_file: the filename for the input image
returns:
numpy array of floats, such that each is the value of a ganglion cell
effects:
none
'''
global dog_2d_mat, dog_2d_mat_detailed
if detailed: raise Exception('detailed no longer supported')
# load image, convert to grayscale
image = load_input(input_file)
# do difference of gaussian filtering
im_w, im_h = image.cols, image.rows
dog_mat = cv.CreateMat(im_h, im_w, cv.CV_32FC1)
dog_2d_filter = dog_2d_mat
cv.Filter2D(image, dog_mat, dog_2d_filter)
# crop image
dog_mat_small = crop_image(dog_mat, retina_w, retina_h)
# convert to numpy and cap at [-1.0,1.0]
dog_np = np.asarray(dog_mat_small)
dog_np = np.minimum(dog_np, np.ones(dog_np.shape))
dog_np = np.maximum(dog_np, -np.ones(dog_np.shape))
# print_stats('dog',dog_np)
# show_image('input image',image)
# show_image('d-o-g filtered',dog_mat)
return dog_np
def meanshiftUsingILM(path):
# Load original image given the image path
im = cv.LoadImageM(path)
# Load bank of filters
filterBank = lmfilters.loadLMFilters()
# Resize image to decrease dimensions during clustering
resize_factor = 1
thumbnail = cv.CreateMat(im.height / resize_factor,
im.width / resize_factor, cv.CV_8UC3)
cv.Resize(im, thumbnail)
# now work with resized thumbnail image
response = np.zeros(shape=((thumbnail.height) * (thumbnail.width), 4),
dtype=float)
for f in xrange(0, 48):
filter = filterBank[f]
# Resize the filter with the same factor for the resized image
dst = cv.CreateImage(cv.GetSize(thumbnail), cv.IPL_DEPTH_32F, 3)
resizedFilter = cv.CreateMat(filter.height / resize_factor,
filter.width / resize_factor, filter.type)
cv.Resize(filter, resizedFilter)
# Apply the current filter
cv.Filter2D(thumbnail, dst, resizedFilter)
featureIndex = getFilterTypeIndex(f)
for j in xrange(0, thumbnail.height):
for i in xrange(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)
cv.Resize(thumbnail, im)
return im
def doIt(args):
try:
img = cv.LoadImage(args[0])
except IOError:
print "Error: cannot load image " + args[0]
return 1
imgGray = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(img, imgGray, cv.CV_RGB2GRAY)
imgFilt = cv.CreateImage(cv.GetSize(imgGray), cv.IPL_DEPTH_8U, 1)
kernel = cv.CreateMat(3, 3, cv.CV_32F)
for r in xrange(3):
for c in xrange(3):
kernel[r, c] = 1. / 9.
## kernel[0,0] = 1
## kernel[0,1] = 1
## kernel[0,2] = 1
## kernel[1,0] = 1
## kernel[1,1] = 1
## kernel[1,2] = 1
## kernel[2,0] = 1
## kernel[2,1] = 1
## kernel[2,2] = 1
#kernel = numpy.array([[1, 1, 1],[1, 1, 1],[1, 1, 1]])
cv.Filter2D(imgGray, imgFilt, kernel)
if len(args) > 1:
cv.SaveImage(args[1], imgFilt)
else:
cv.NamedWindow(args[0])
cv.ShowImage(args[0], imgGray)
cv.NamedWindow("filtered")
cv.ShowImage("filtered", imgFilt)
cv.WaitKey(0)
return 0
def convolveImg(self, data, isPrint):
_, wavelet = self.createGabor(isPrint)
finalData = cv.CreateMat(data.height, data.width, cv.CV_8UC1)
dataVect = cv.CreateMat(1, data.width, cv.CV_8UC1)
for i in range(0, data.height):
for j in range(0, data.width):
dataVect[0, j] = data[i, j]
reshData = cv.Reshape(dataVect, 0, self.pca.sizeImg)
if (isPrint == True and i == 0):
cv.NamedWindow("img", 1)
cv.ShowImage("img", reshData)
cv.Filter2D(reshData, reshData, wavelet)
temp = cv.Reshape(reshData, 0, 1)
for j in range(0, temp.width):
finalData[i, j] = temp[0, j]
if (isPrint == True and i == 0):
cv.NamedWindow("response", 1)
cv.ShowImage("response", reshData)
print "press any key.." + str(i)
cv.WaitKey()
return finalData
def kmeansUsingPCA(im, k, iterations, epsilon):
#convert image to YUV color space
cv.CvtColor(im, im, cv.CV_BGR2YCrCb)
#array of filter kernels
filterBank = lmfilters.loadLMFilters()
#create the samples and labels vector
col = cv.Reshape(im, 3, im.width * im.height)
#samples = cv.CreateMat(col.height, 51, cv.CV_32FC1)
samples = zeros([col.height, 51])
for f in xrange(0, 48):
filter = filterBank[f]
dst = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Filter2D(im, dst, filter)
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
#take the maximum response from the 3 channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
samples[count, f] = maxRes
count += 1
#YUV features
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
samples[count, 48] = im[j, i][0]
samples[count, 49] = im[j, i][1]
samples[count, 50] = im[j, i][2]
count += 1
#get the first 4 primary components using pca
pca = PCA(samples)
pcaSamples = zeros([col.height, 4])
for i in xrange(0, col.height):
pcaSamples[i] = pca.getPCA(samples[i], 4)
samples = cv.fromarray(pcaSamples)
samplesMat = cv.CreateMat(col.height, 4, cv.CV_32FC1)
cv.Scale(samples, samplesMat)
labels = cv.CreateMat(col.height, 1, cv.CV_32SC1)
crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, iterations, epsilon)
cv.KMeans2(samplesMat, k, labels, crit)
clusters = getClusters(col, samplesMat, labels)
means = {}
for c in clusters:
means[c] = [0.0, 0.0, 0.0]
for v in clusters[c]:
means[c][0] += v[0]
means[c][1] += v[1]
means[c][2] += v[2]
means[c][0] /= len(clusters[c])
means[c][1] /= len(clusters[c])
means[c][2] /= len(clusters[c])
for m in means:
print m, means[m], len(clusters[m])
#apply clustering to the image
for i in xrange(0, col.rows):
lbl = labels[i, 0]
col[i, 0] = means[lbl]
uberlaplace = giveMeCV([[-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1],
[-1, -1, 24, -1, -1], [-1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1]])
d = cv.CreateMat(5, 5, 1)
# Applied Kernel
kernel = laplace
start = time() # for framerate checking (usu. ~30)
for i in range(dur * 30):
# Capture Frame from Webcam
frame = cv.QueryFrame(wc)
# Mirror Image
cv.Flip(frame, flipMode=1)
# Display raw image
cv.ShowImage('Camera', frame)
# Apply Kernel Filter
kernel = giveMeCV(random_kernel(3, 1, 0)) # Uncomment for random kernel
cv.Filter2D(frame, frame, kernel)
#cv.Invert(frame, frame)
# Display transformed image
cv.ShowImage('Kernel', frame)
cv.WaitKey(1)
# Frame Rate
print(dur / (time() - start))
def constructFeatureVector(image, feature_type):
v = None
if feature_type == "INTENSITY":
v = zeros((image.height,image.width,1))
elif feature_type == "INTENSITY+LOC":
v = zeros((image.height,image.width,3))
elif feature_type == "RGB":
v = zeros((image.height,image.width,3))
elif feature_type == "YUV":
v = zeros((image.height,image.width,3))
elif feature_type == "ILM":
v = zeros((image.height,image.width,4))
elif feature_type == "PCA":
v = zeros((image.height,image.width,4))
def getFilterTypeIndex(index):
if index >=0 and index <= 17:
return 0
elif index >= 18 and index <= 35:
return 1
elif index >= 36 and index <= 45:
return 2
else:
return 3
if feature_type in ["INTENSITY","INTENSITY+LOC","RGB","YUV"]:
for y in range(0,image.height):
for x in range(0, image.width):
if feature_type == "INTENSITY":
v[y,x,0] = image[y,x]
elif feature_type == "INTENSITY+LOC":
v[y,x,0] = image[y,x]
v[y,x,1] = y
v[y,x,2] = x
elif feature_type == "RGB" or feature_type == "YUV":
v[y,x,0] = image[y,x][0]
v[y,x,1] = image[y,x][1]
v[y,x,2] = image[y,x][2]
elif feature_type == "ILM":
filterBank = lmfilters.loadLMFilters()
for f in xrange(0,48):
filter = filterBank[f]
dst = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 3)
cv.Filter2D(image,dst,filter)
featureIndex = getFilterTypeIndex(f)
for j in xrange(0,image.height):
for i in xrange(0,image.width):
#take the maximum response from the 3 channels
maxRes = max(dst[j,i])
if math.isnan(maxRes):
maxRes = 0.0
#take the maximun over this feature
if maxRes > v[j,i,featureIndex]:
v[j,i,featureIndex] = maxRes
elif feature_type == "PCA":
filterBank = lmfilters.loadLMFilters()
samples = zeros([image.width*image.height,51])
#lm filters features
for f in xrange(0,48):
filter = filterBank[f]
dst = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 3)
cv.Filter2D(image,dst,filter)
count = 0
for j in xrange(0,image.height):
for i in xrange(0,image.width):
#take the maximum response from the 3 channels
maxRes = max(dst[j,i])
if math.isnan(maxRes):
maxRes = 0.0
samples[count,f] = maxRes
count+=1
#yuv features
count = 0
for j in xrange(0,image.height):
for i in xrange(0,image.width):
samples[count,48] = image[j,i][0]
samples[count,49] = image[j,i][1]
samples[count,50] = image[j,i][2]
count+=1
#get the first 4 primary components using pca
count = 0
pca = PCA(samples)
for j in xrange(0,image.height):
for i in xrange(0,image.width):
v[j,i] = pca.getPCA(samples[count],4)
count+=1
return v
