Dump of book code and initial examples.

Author: jesolem

LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012, Jan Erik Solem
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

PCV/__init__.py

@@ -0,0 +1,6 @@
+from PCV.classifiers import *
+from PCV.clustering import *
+from PCV.geometry import *
+from PCV.imagesearch import *
+from PCV.localdescriptors import *
+from PCV.tools import *

PCV/__init__.pyc

@@ -0,0 +1,63 @@
+from numpy import * 
+
+
+class BayesClassifier(object):
+    
+	def __init__(self):
+		""" Initialize classifier with training data. """
+		
+		self.labels = []	# class labels
+		self.mean = []		# class mean
+		self.var = []		# class variances
+		self.n = 0			# nbr of classes
+		
+	def train(self,data,labels=None):
+		""" Train on data (list of arrays n*dim). 
+			Labels are optional, default is 0...n-1. """
+		
+		if labels==None:
+			labels = range(len(data))
+		self.labels = labels
+		self.n = len(labels)
+				
+		for c in data:
+			self.mean.append(mean(c,axis=0))
+			self.var.append(var(c,axis=0))
+		
+	def classify(self,points):
+		""" Classify the points by computing probabilities 
+			for each class and return most probable label. """
+        
+		# compute probabilities for each class
+		est_prob = array([gauss(m,v,points) for m,v in zip(self.mean,self.var)])
+				
+		print 'est prob',est_prob.shape,self.labels
+		# get index of highest probability, this gives class label
+		ndx = est_prob.argmax(axis=0)
+		
+		est_labels = array([self.labels[n] for n in ndx])
+		
+		return est_labels, est_prob
+
+
+def gauss(m,v,x):
+	""" Evaluate Gaussian in d-dimensions with independent 
+		mean m and variance v at the points in (the rows of) x. 
+		http://en.wikipedia.org/wiki/Multivariate_normal_distribution """
+	
+	if len(x.shape)==1:
+		n,d = 1,x.shape[0]
+	else:
+		n,d = x.shape
+			
+	# covariance matrix, subtract mean
+	S = diag(1/v)
+	x = x-m
+	# product of probabilities
+	y = exp(-0.5*diag(dot(x,dot(S,x.T))))
+	
+	# normalize and return
+	return y * (2*pi)**(-d/2.0) / ( sqrt(prod(v)) + 1e-6)
+
+
+

PCV/classifiers/__init__.py

@@ -0,0 +1,35 @@
+from numpy import * 
+
+class KnnClassifier(object):
+	
+	def __init__(self,labels,samples):
+		""" Initialize classifier with training data. """
+		
+		self.labels = labels
+		self.samples = samples
+	
+	def classify(self,point,k=3):
+		""" Classify a point against k nearest 
+			in the training data, return label. """
+		
+		# compute distance to all training points
+		dist = array([L2dist(point,s) for s in self.samples])
+		
+		# sort them
+		ndx = dist.argsort()
+		
+		# use dictionary to store the k nearest
+		votes = {}
+		for i in range(k):
+			label = self.labels[ndx[i]]
+			votes.setdefault(label,0)
+			votes[label] += 1
+		    
+		return max(votes)
+
+
+def L2dist(p1,p2):
+	return sqrt( sum( (p1-p2)**2) )
+
+def L1dist(v1,v2):
+	return sum(abs(v1-v2))

PCV/classifiers/__init__.pyc

@@ -0,0 +1,146 @@
+from numpy import *
+from itertools import combinations
+
+
+class ClusterNode(object):
+	def __init__(self,vec,left,right,distance=0.0,count=1):
+		self.left = left
+		self.right = right
+		self.vec = vec
+		self.distance = distance
+		self.count = count # only used for weighted average
+
+	def extract_clusters(self,dist):
+		""" Extract list of sub-tree clusters from 
+			hcluster tree with distance<dist. """
+		if self.distance < dist:
+			return [self]
+		return self.left.extract_clusters(dist) + self.right.extract_clusters(dist)
+
+	def get_cluster_elements(self):
+		"""	Return ids for elements in a cluster sub-tree. """
+		return self.left.get_cluster_elements() + self.right.get_cluster_elements()
+
+	def get_height(self):
+		"""	Return the height of a node, 
+			height is sum of each branch. """
+		return self.left.get_height() + self.right.get_height()
+
+	def get_depth(self):
+		"""	Return the depth of a node, depth is 
+			max of each child plus own distance. """
+		return max(self.left.get_depth(), self.right.get_depth()) + self.distance
+
+	def draw(self,draw,x,y,s,imlist,im):
+		"""	Draw nodes recursively with image 
+			thumbnails for leaf nodes. """
+	
+		h1 = int(self.left.get_height()*20 / 2)
+		h2 = int(self.right.get_height()*20 /2)
+		top = y-(h1+h2)
+		bottom = y+(h1+h2)
+		
+		# vertical line to children    
+		draw.line((x,top+h1,x,bottom-h2),fill=(0,0,0))    
+		
+		# horizontal lines 
+		ll = self.distance*s
+		draw.line((x,top+h1,x+ll,top+h1),fill=(0,0,0))    
+		draw.line((x,bottom-h2,x+ll,bottom-h2),fill=(0,0,0))        
+		
+		# draw left and right child nodes recursively    
+		self.left.draw(draw,x+ll,top+h1,s,imlist,im)
+		self.right.draw(draw,x+ll,bottom-h2,s,imlist,im)
+	
+
+class ClusterLeafNode(object):
+	def __init__(self,vec,id):
+		self.vec = vec
+		self.id = id
+
+	def extract_clusters(self,dist):
+		return [self] 
+
+	def get_cluster_elements(self):
+		return [self.id]
+
+	def get_height(self):
+		return 1
+
+	def get_depth(self):
+		return 0
+	
+	def draw(self,draw,x,y,s,imlist,im):
+		nodeim = Image.open(imlist[self.id])
+		nodeim.thumbnail([20,20])
+		ns = nodeim.size
+		im.paste(nodeim,[int(x),int(y-ns[1]//2),int(x+ns[0]),int(y+ns[1]-ns[1]//2)])
+
+
+def L2dist(v1,v2):
+	return sqrt(sum((v1-v2)**2))
+
+    
+def L1dist(v1,v2):
+	return sum(abs(v1-v2))
+
+
+def hcluster(features,distfcn=L2dist):
+	""" Cluster the rows of features using 
+		hierarchical clustering. """
+	
+	# cache of distance calculations
+	distances = {}
+	
+	# initialize with each row as a cluster 
+	node = [ClusterLeafNode(array(f),id=i) for i,f in enumerate(features)]
+	
+	while len(node)>1:
+		closest = float('Inf')
+		
+		# loop through every pair looking for the smallest distance
+		for ni,nj in combinations(node,2):
+			if (ni,nj) not in distances: 
+				distances[ni,nj] = distfcn(ni.vec,nj.vec)
+				
+			d = distances[ni,nj]
+			if d<closest:
+				closest = d 
+				lowestpair = (ni,nj)
+		ni,nj = lowestpair
+		
+		# average the two clusters
+		new_vec = (ni.vec + nj.vec) / 2.0
+		
+		# create new node
+		new_node = ClusterNode(new_vec,left=ni,right=nj,distance=closest)
+		node.remove(ni)
+		node.remove(nj)
+		node.append(new_node)
+	
+	return node[0]
+
+
+from PIL import Image,ImageDraw
+ 
+def draw_dendrogram(node,imlist,filename='clusters.jpg'):
+	"""	Draw a cluster dendrogram and save to a file. """
+	
+	# height and width
+	rows = node.get_height()*20
+	cols = 1200
+	
+	# scale factor for distances to fit image width
+	s = float(cols-150)/node.get_depth()
+	
+	# create image and draw object
+	im = Image.new('RGB',(cols,rows),(255,255,255))
+	draw = ImageDraw.Draw(im)
+	
+	# initial line for start of tree
+	draw.line((0,rows/2,20,rows/2),fill=(0,0,0))    
+	
+	# draw the nodes recursively
+	node.draw(draw,20,(rows/2),s,imlist,im)
+	im.save(filename)
+	im.show()

PCV/classifiers/bayes.py

@@ -0,0 +1,74 @@
+from numpy import *
+from scipy import linalg
+
+
+class Camera(object):
+	""" Class for representing pin-hole cameras. """
+	
+	def __init__(self,P):
+		""" Initialize P = K[R|t] camera model. """
+		self.P = P
+		self.K = None # calibration matrix
+		self.R = None # rotation
+		self.t = None # translation
+		self.c = None # camera center
+		
+	
+	def project(self,X):
+		"""	Project points in X (4*n array) and normalize coordinates. """
+		
+		x = dot(self.P,X)
+		for i in range(3):
+			x[i] /= x[2]	
+		return x
+		
+		
+	def factor(self):
+		"""	Factorize the camera matrix into K,R,t as P = K[R|t]. """
+		
+		# factor first 3*3 part
+		K,R = linalg.rq(self.P[:,:3])
+		
+		# make diagonal of K positive
+		T = diag(sign(diag(K)))
+		if linalg.det(T) < 0:
+			T[1,1] *= -1
+		
+		self.K = dot(K,T)
+		self.R = dot(T,R) # T is its own inverse
+		self.t = dot(linalg.inv(self.K),self.P[:,3])
+		
+		return self.K, self.R, self.t
+		
+	
+	def center(self):
+		"""	Compute and return the camera center. """
+    
+		if self.c is not None:
+			return self.c
+		else:
+			# compute c by factoring
+			self.factor()
+			self.c = -dot(self.R.T,self.t)
+			return self.c
+
+
+
+# helper functions	
+
+def rotation_matrix(a):
+	"""	Creates a 3D rotation matrix for rotation
+		around the axis of the vector a. """
+	R = eye(4)
+	R[:3,:3] = linalg.expm([[0,-a[2],a[1]],[a[2],0,-a[0]],[-a[1],a[0],0]])
+	return R
+	
+
+def rq(A):
+	from scipy.linalg import qr
+	
+	Q,R = qr(flipud(A).T)
+	R = flipud(R.T)
+	Q = Q.T
+	
+	return R[:,::-1],Q[::-1,:]