added findHorizontalSeam() to SeamCarverLib.py

Author: LeslieK

ResizeDemo.py

@@ -0,0 +1,28 @@
+import argparse, png, array
+from readPNG_2 import Picture
+from SeamCarverLib import SeamCarver
+import SeamCarverUtilities
+
+parser = argparse.ArgumentParser()
+parser.add_argument("filename", help="filename of image", type=str)
+parser.add_argument("rowsToRemove", help="number of rows to remove from image", type=int)
+parser.add_argument("colsToRemove", help="number of cols to remove from image", type=int)
+args = parser.parse_args()
+
+print "build energy array for {}".format(args.filename)
+pic = Picture(args.filename)
+
+print "build graph of pixels from energy array"
+sc = SeamCarver(pic)
+
+#print pic.energyArray, '\nlen = ', len(pic.energyArray)
+
+print "print vertical seam\n"
+SeamCarverUtilities.printVerticalSeam(sc)
+print "print horizontal seam\n"
+SeamCarverUtilities.printHorizontalSeam(sc)
+
+
+#print "remove {} rows".format(args.rowsToRemove)
+#print "remove {} cols".format(args.colsToRemove)
+

SeamCarverLib.py

@@ -48,7 +48,27 @@ def findVerticalSeam(self):
 
 	def findHorizontalSeam(self):
 		"return horizontal seam in image"
-		pass
+		# tranpose dimensions
+		self._exchDims()
+
+		# horizontal seam = sequence of rows; seam[0] is row of col 0
+		# col-indexed seam
+		seam = [-1 for _ in range(self._height)]
+		self._buildGraph(transposed=True)
+		row = self._height - 1
+		v = self._edgeTo[self._sink]
+		while (v != self._source):
+			seam[row] = v % self._width  # seam[row] = col
+			v = self._edgeTo[v]
+			row -= 1
+		self._exchDims()
+		return seam
+
+	def _exchDims(self):
+		"exchange self._width and self._height"
+		swap = self._width
+		self._width = self._height
+		self._height = swap
 
 	def _toLinear(self, col, row):
 		"converts pixel from (col, row) to single index"
@@ -64,7 +84,7 @@ def _toGrid(self, num):
 
 	def _isValid(self, col, row=None):
 		if row is None:
-			if (col < 0) or (col > self._width * self._height):
+			if (col < 0) or (col > self._width * self._height - 1):
 				return False
 			else:
 				return True
@@ -74,7 +94,7 @@ def _isValid(self, col, row=None):
 			else:
 				return True
 
-	def _buildGraph(self):
+	def _buildGraph(self, transposed=False):
 		"pixels are nodes; edges define precedence constraints in a seam"
 
 		# for row 0 pixels: distTo[] is 0; edgeTo[] is _source vertex 
@@ -89,45 +109,58 @@ def _buildGraph(self):
 		for v in range(self._width, self._num_pixels):
 			if (v % self._width == 0):
 				# pixel is on left edge
-				self._edgeTodistTo(v, edgeL=True)
+				self._edgeTodistTo(v, transposed=transposed, edgeL=True)
 			elif (v % self._width == self._width - 1):
 				# pixel is on right edge
-				self._edgeTodistTo(v, edgeR=True)
+				self._edgeTodistTo(v, transposed=transposed, edgeR=True)
 			else:
-				self._edgeTodistTo(v)
+				self._edgeTodistTo(v, transposed=transposed)
 		# for sink vertex
 		index, min_energy = min(enumerate(self._distTo[self._num_pixels - self._width:self._num_pixels]), key=lambda (x, y): y)
 		self._distTo[self._sink] = min_energy
-		self._edgeTo[self._sink] = (self._height-1) * self._width + index
+		self._edgeTo[self._sink] = (self._height - 1) * self._width + index
 
 
-	def _edgeTodistTo(self, v, edgeL=False, edgeR=False):
+	def _edgeTodistTo(self, v, edgeL=False, edgeR=False, transposed=False):
 		# returns pixel connected to v with min energy
+
 		if edgeL:
 			# left edge
 			vC = v - self._width
-			vR = v - self._width + 1
-			vL = vC
+			vRD = v - self._width + 1
+			vLU = vC
 		elif edgeR:
 			# right edge
-			vL = v - self._width - 1
+			vLU = v - self._width - 1
 			vC = v - self._width
-			vR = vC
+			vRD = vC
 		else:
 			# pixels connect to v
-			vL = v - self._width - 1
+			vLU = v - self._width - 1
 			vC = v - self._width
-			vR = v - self._width + 1
+			vRD = v - self._width + 1
 		# energy of pixels connected to v
-		eL = self._energy[vL]
-		eC = self._energy[vC]
-		eR = self._energy[vR]
-		if eL <= min(eC, eR):
-			self._edgeTo[v] = vL
-			self._distTo[v] = self._distTo[vL] + eL
-		elif eR <= min(eL, eC):
-			self._edgeTo[v] = vR
-			self._distTo[v] = self._distTo[vR] + eR
+		if transposed:
+			(colU, rowU) = self._toGrid(vLU)
+			(colC, rowC) = self._toGrid(vC)
+			(colD, rowD) = self._toGrid(vRD)
+			# read energy
+			eLU = self._energy[self._height * colU + rowU]
+			eC = self._energy[self._height * colC + rowC]
+			eRD = self._energy[self._height * colD + rowD]
+			
+		else:
+			# read energy directly from energy array
+			eLU = self._energy[vLU]
+			eC = self._energy[vC]
+			eRD = self._energy[vRD]
+
+		if eLU <= min(eC, eRD):
+			self._edgeTo[v] = vLU
+			self._distTo[v] = self._distTo[vLU] + eLU
+		elif eRD <= min(eLU, eC):
+			self._edgeTo[v] = vRD
+			self._distTo[v] = self._distTo[vRD] + eRD
 		else:
 			self._edgeTo[v] = vC
 			self._distTo[v] = self._distTo[vC] + eC

readPNG_2.py

@@ -0,0 +1,83 @@
+import png, array
+
+class Picture(object):
+	"reads a png image from a filename"
+	#_BORDER_ENERGY = 195075
+
+	def __init__(self, pngfilename):
+		"reads in a .png image"
+		_BORDER_ENERGY = 195075
+		_CH = 3		# number of channels (R,G,B = 3; R,G,B,A = 4)
+		_r = png.Reader(filename=pngfilename)
+		res = _r.read()
+	# 	res = (width, height, iterator-over-pixels, 
+	# 	    	{'alpha': False, 'bitdepth': 8, greyscale': True,
+	#        	'interlace': 0, 'planes': 1, size':(255, 1)})
+
+		self.num_cols = res[0]
+		self.num_rows = res[1]
+
+		if res[3]['alpha']:
+			_CH = 4
+
+		self.num_channels = _CH
+
+		self.energyArray = array.array("L")
+		self.imageArray = array.array("B")
+		
+		# row 0 of image
+		_row_prev = res[2].next()
+		self.energyArray.extend([_BORDER_ENERGY] * self.num_cols)
+		self.imageArray.extend(_row_prev)
+
+		if (self.num_rows == 1):
+			return
+
+		# row 1 of image
+		_row_curr = res[2].next()
+		self.imageArray.extend(_row_curr)
+		if (self.num_rows == 2):
+			self.energyArray.extend([_BORDER_ENERGY] * self.num_cols)
+			return
+		
+		# for images with more than 2 rows
+		for _row_next in res[2]:
+			"build image array and energy array"
+
+			# add _row_next to image array
+			self.imageArray.extend(_row_next)
+
+			# calculate gradient of current row
+			_gradRv = map(self._diff_squared, _row_prev[0::_CH], _row_next[0::_CH])
+			_gradGv = map(self._diff_squared, _row_prev[1::_CH], _row_next[1::_CH])
+			_gradBv = map(self._diff_squared, _row_prev[2::_CH], _row_next[2::_CH])
+			n = self.num_cols * _CH
+			_gradRh = map(self._diff_squared, _row_curr[0:(n - 2*_CH):_CH], _row_curr[2*_CH:(n - _CH)+1:_CH])
+			_gradGh = map(self._diff_squared, _row_curr[1:(n - 2*_CH):_CH], _row_curr[2*_CH+1:(n - _CH)+2:_CH])
+			_gradBh = map(self._diff_squared, _row_curr[2:(n - 2*_CH):_CH], _row_curr[2*_CH+2:(n - _CH)+3:_CH])
+
+			_gradR = map(int.__add__, _gradRv[1:-1], _gradRh)
+			_gradG = map(int.__add__, _gradGv[1:-1], _gradGh)
+			_gradB = map(int.__add__, _gradBv[1:-1], _gradBh)
+
+			# calculate energy of current row
+			_energy = map(sum, zip(_gradR, _gradG, _gradB))
+
+			# left border pixel energy 
+			self.energyArray.append(_BORDER_ENERGY)
+			# non-border pixel energy
+			self.energyArray.extend(_energy)
+			# right border pixel energy
+			self.energyArray.append(_BORDER_ENERGY)
+
+			_row_prev = _row_curr
+			_row_curr = _row_next
+
+		# bottom row of energy array
+		print 'i am in Picture'
+		self.energyArray.extend([_BORDER_ENERGY] * self.num_cols)
+
+
+	def _diff_squared(self, x, y):
+		return (x-y)**2
+