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