assert orientation == "upper" or orientation == "lower", "orientation parameter to displayImage must be \"upper\" or \"lower\"."

plt.interactive(True)

plt.imshow(image, origin=orientation)

plt.title(imgTitle)

# See [http://scikit-image.org/docs/dev/api/skimage.segmentation.html?highlight=slic#skimage.segmentation.felzenszwalb]

# Function usage: skimage.segmentation.felzenszwalb(image, scale=1, sigma=0.8, min_size=20)

# Produces an oversegmentation of a multichannel (i.e. RGB) image using a fast, minimum spanning tree based clustering on the image grid. The parameter scale sets an observation level. Higher scale means less and larger segments. sigma is the diameter of a Gaussian kernel, used for smoothing the image prior to segmentation.

# image : (width, height, 3) or (width, height) ndarray. Input image.

# scale : float. Free parameter. Higher means larger clusters.

# sigma : float. Width of Gaussian kernel used in preprocessing.

# min_size : int. Minimum component size. Enforced using postprocessing.

superPixelImage = skimage.segmentation.felzenszwalb(image, scale=25, sigma=1.0, min_size=50)

# See [http://scikit-image.org/docs/dev/api/skimage.segmentation.html?highlight=slic#skimage.segmentation.quickshift]

# image : (width, height, channels) ndarray. Input image.

# ratio : float, optional, between 0 and 1 (default 1). Balances color-space proximity and image-space proximity. Higher values give more weight to color-space.

# kernel_size : float, optional (default 5). Width of Gaussian kernel used in smoothing the sample density. Higher means fewer clusters.

# max_dist : float, optional (default 10). Cut-off point for data distances. Higher means fewer clusters.

# return_tree : bool, optional (default False). Whether to return the full segmentation hierarchy tree and distances.

# sigma : float, optional (default 0). Width for Gaussian smoothing as preprocessing. Zero means no smoothing.

# convert2lab : bool, optional (default True). Whether the input should be converted to Lab colorspace prior to segmentation. For this purpose, the input is assumed to be RGB.

# random_seed : None (default) or int, optional. Random seed used for breaking ties.

superPixelImage = skimage.segmentation.quickshift(image)

# Function returns an image with superpixel boundaries displayed as lines. It is assumed that the image was the source for the segmentation mask.

# See [http://scikit-image.org/docs/dev/api/skimage.segmentation.html?highlight=slic#skimage.segmentation.mark_boundaries]

# Function signature: skimage.segmentation.mark_boundaries(image, label_img, color=(1, 1, 0), outline_color=(0, 0, 0))

superPixelImage = mark_boundaries(image, segmentationMask)

# get unique labels

vertices = np.unique(grid)

# map unique labels to [1,...,num_labels]

reverse_dict = dict(zip(vertices,np.arange(len(vertices))))

grid = np.array([reverse_dict[x] for x in grid.flat]).reshape(grid.shape)

# create edges

down = np.c_[grid[:-1, :].ravel(), grid[1:, :].ravel()]

right = np.c_[grid[:, :-1].ravel(), grid[:, 1:].ravel()]

all_edges = np.vstack([right, down])

all_edges = all_edges[all_edges[:, 0] != all_edges[:, 1], :]

all_edges = np.sort(all_edges,axis=1)

num_vertices = len(vertices)

edge_hash = all_edges[:,0] + num_vertices * all_edges[:, 1]

# find unique connections

edges = np.unique(edge_hash)

# undo hashing

edges = [[vertices[x%num_vertices],

vertices[x/num_vertices]] for x in edges]

# compute region centers:

gridx, gridy = np.mgrid[:grid.shape[0], :grid.shape[1]]

centers = dict()

for v in vertices:

centers[v] = [gridy[grid == v].mean(), gridx[grid == v].mean()]

# plot labels

plt.imshow(grid,interpolation='None')

# overlay graph:

for edge in edges:

plt.plot([centers[edge[0]][0],centers[edge[1]][0]],

lenaImg = skimage.data.lena()

spMask = getSuperPixels_SLIC(lenaImg, numSuperPixels, compactness)

lena_superPixels_SLIC = generateImageWithSuperPixelBoundaries(lenaImg, spMask )

if (superPixelAlgoName == "SLIC" or superPixelAlgoName == "Quickshift" or superPixelAlgoName == "Graph" ):

print "\tINFO: Using " + str(superPixelAlgoName) + " with default settings to generate superpixel over-segmentation"

else:

print "\tWARN: Defaulting to SLIC algorithm with default settings to generate superpixel over-segmentation"

if(superPixelAlgoName == "SLIC"):

spMask = getSuperPixels_SLIC(image, 400, 10)

displayImage( generateImageWithSuperPixelBoundaries(image, spMask) , imgTitle="Car SLIC" , orientation="lower" )

elif(superPixelAlgoName == "Quickshift"):

displayImage( generateImageWithSuperPixelBoundaries(image, getSuperPixels_Quickshift(image) ) , imgTitle="Car Quickshift" , orientation="lower" )

elif(superPixelAlgoName == "Graph"):

def __init__(self,labels,nodes,edges):

self.m_labels = labels

self.m_nodes = nodes

self.m_edges = edges

# for now all our code relies on the superpixels being consecutive.

assert np.all(self.m_nodes == np.arange(len(self.m_nodes)))

def draw(self):

show_graph(self.m_labels, self.m_nodes, self.m_edges)

def imageFromSuperPixelData( self, data ):

# data is an nxD matrix, where n is the number of superpixels.

if type(data) == list or data.ndim==1:

data = np.array( [ data ] ).transpose()

#print data

assert data.ndim == 2 and data.shape[0] == self.getNumSuperPixels(), \

'dodgy data shape = %s' % data.shape

D = data.shape[1]

H,W = self.m_labels.shape

# for a given region, make the data same for all pixels in that region

res = data[ self.m_labels.ravel(), : ]

res = res.reshape( (H,W,D) )

if res.shape[2] == 1:

# essentially 2D in this case

res = res.squeeze()

return res

# Returns: (adjMatrix,nbAdjInvolvingVoid,nbAdj)

def countClassAdjacencies( self, nbClasses, allSPClassLabels ):

counts = np.zeros( ( nbClasses, nbClasses ) )

voidLabel = pomio.getVoidIdx()

adjVoidCount = 0

adjCount = len(self.m_edges)

for (ei, ej) in self.m_edges:

ci = allSPClassLabels[ ei ]

cj = allSPClassLabels[ ej ]

# Not doing stats for void

if ci != voidLabel and cj != voidLabel:

counts[ ci-1, cj-1 ] += 1

counts[ cj-1, ci-1 ] += 1

else:

adjVoidCount += 1

return (counts, adjVoidCount, adjCount)

def getNumSuperPixels( self ):

if method == 'slic':

nbSegments, compactness = params[0], params[1]

labels = getSuperPixels_SLIC(imgRGB, nbSegments, compactness)

nodes, edges = make_graph(labels)

else:

raise Exception('invalid superpixel method %s' % method)