if DEBUG:

print "We are in draw_circles"

for i in range(0,len(storage)):

radius = storage[i, 2]

center = (storage[i, 0], storage[i, 1])

if DEBUG:

print "Radius: " + str(radius)

print "Center: " + str(center)

cv.Circle(output, center, radius, CIRCLE_COLOR,

""" This class has attributes :

"""

def __init__(self, photo, region):

""" Initializes eyePhoto and eyeRegion and calls findPupil, findSclera, and

if DEBUG:

print "We're here in eye's __init__"

print "And our region is: " + str(region)

print "This photo is a " + str(type(photo))

#photo.show()

# Initalize whole eye attributes to the values passed in

self.eyePhoto = photo

self.eyeRegion = region

# Initialize the rest of the attributes to None so that they exist

self.eyePupil = None

# Set the rest of the attributes by finding them

self.findPupil()

def findPupil(self):

""" Detects a pupil in a photo of an eye and constructs a Pupil object

# Load the source image and convert to cv mat

# eyePhoto is already stored as a mat. There is no need to convert

#eye = cv.GetMat(self.eyePhoto)

if DEBUG:

print "We're here in findPupil()"

print "EYE: " + str(self.eyePhoto)

print "The type of eyePhoto is: " + str(type(self.eyePhoto))

if not self.eyePhoto:

return False

# Convert to a numpy array

eyeArr = np.asarray(self.eyePhoto)

# Find the red in the photo

thresh = cv2.inRange(eyeArr,LOWER_RED_RANGE,UPPER_RED_RANGE)

if DEBUG:

cv.ShowImage("Binary", cv.fromarray(thresh))

cv.WaitKey(0)

cv.DestroyWindow("Binary")

# Invert the threshholded photo

rows = len(thresh)

for i in range(0,rows):

for j in range(0,len(thresh[i])):

thresh[i][j] = 255 - thresh[i][j]

if DEBUG:

cv.ShowImage("Inverted Thresh", cv.fromarray(thresh))

cv.WaitKey(0)

cv.DestroyWindow("Inverted Thresh")

# Erode and dilate the image to get rid of noise

erode = cv2.erode(thresh,None,iterations = ERODE_ITERATIONS)

if DEBUG:

cv.ShowImage("Erode", cv.fromarray(erode))

cv.WaitKey(0)

cv.DestroyWindow("Erode")

dilate = cv2.dilate(erode,None,iterations = DILATE_ITERATIONS)

if DEBUG:

cv.ShowImage("Dilate", cv.fromarray(dilate))

cv.WaitKey(0)

cv.DestroyWindow("Dilate")

# Find countours in the image

contours, hierarchy = cv2.findContours(dilate,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)

# Draw the contours in white

cv2.drawContours(dilate,contours,-1,(255,255,255),-1)

if DEBUG:

cv.ShowImage("Contours", cv.fromarray(dilate))

cv.WaitKey(0)

cv.DestroyWindow("Contours")

smooth = cv.fromarray(dilate)

cv.Smooth(cv.fromarray(dilate),smooth,

cv.CV_GAUSSIAN,APERTURE_WIDTH,APERTURE_HEIGHT)

if DEBUG:

cv.ShowImage("Smooth", smooth)

cv.WaitKey(0)

cv.DestroyWindow("Smooth")

cv.Canny(smooth, smooth, CANNY_THRESHOLD_1, CANNY_THRESHOLD_2)

if DEBUG:

cv.ShowImage("Canny", smooth)

cv.WaitKey(0)

cv.DestroyWindow("Canny")

storage = cv.CreateMat((self.eyePhoto).width, 1, cv.CV_32FC3)

CIRCLE_MAX_RADIUS = self.eyePhoto.width

cv.HoughCircles(smooth, storage, cv.CV_HOUGH_GRADIENT, CIRCLE_RESOLUTION_RATIO, CIRCLE_MIN_DISTANCE,

CIRCLE_THRESHOLD_1, CIRCLE_THRESHOLD_2, CIRCLE_MIN_RADIUS, CIRCLE_MAX_RADIUS)

if DEBUG:

print "STORAGE: " + str(storage)

print np.asarray(storage)

finalCircle = None

if storage.rows != 0 and storage.cols != 0:

# NOTE: Each circle is stored as centerX, centerY, radius

storage = np.asarray(storage)

# Find the most centered circle

centerX = self.eyePhoto.width / 2

centerY = self.eyePhoto.height / 2

if DEBUG:

print "CenterX = " + str(centerX)

print "CenterY = " + str(centerY)

minDist = maxint

minCircleIndex = -1

for i in range(len(storage) - 1):

#radius = storage[i, 0, 2]

if DEBUG:

print "We're on circle elimination with i = " + str(i)

print "MinDist = " + str(minDist)

print "minCircleIndex = " + str(minCircleIndex)

x = storage[i, 0, 0]

y = storage[i, 0, 1]

dist = math.hypot(centerX - x, centerY - y)

if dist < minDist:

minDist = dist

minCircleIndex = i

if DEBUG:

#draw all the potential circles

draw_circles(np.array([[storage[i, 0, 0], storage[i, 0, 1],storage[i, 0, 2]]]),self.eyePhoto)

if DEBUG:

cv.ShowImage("Eye with all circles", self.eyePhoto)

cv.WaitKey(0)

cv.DestroyWindow("Eye with all circles")

if minCircleIndex != -1:

finalCircle = np.array([[storage[minCircleIndex, 0, 0], storage[minCircleIndex, 0, 1],storage[minCircleIndex, 0, 2]]])

if DEBUG:

print "Final Circle = " + str(finalCircle)

print "We're drawin some circles now"

draw_circles(finalCircle,self.eyePhoto)

if DEBUG:

cv.ShowImage("Eye with Circles",self.eyePhoto)

cv.WaitKey(0)

cv.DestroyWindow("Eye with Circles")

# Do the various setting that needs to be done for the class structure

if finalCircle != None:

# The pupil region is stored as a tuple : (centerXCoor, centerYCoor, radius)

region = (finalCircle[0,0], finalCircle[0,1], finalCircle[0,2])

self.setPupil(region)

return True

else:

#region = None

#self.setPupil(region)

# A pupil was not found

return False

def pupilRemove(self, region):

""" Crops the eye photo to show only the pupil

# TODO: Should these be rows - 1 and cols -1 to avoid going

# off the edge of the picture?

maxX = self.eyePhoto.rows

maxY = self.eyePhoto.cols

if DEBUG:

print "In pupilRemove starting boundary checking"

print "region: " + str(region)

# Converting to (topLeftX, topLeftY, width, height)

# and boundary checking

if region[0]-region[2] < 0:

topLeftX = 0

elif region[0]-region[2] > maxX:

topLeftX = maxX

else:

topLeftX = region[0]-region[2]

if region[1]-region[2] < 0:

topLeftY = 0

elif region[1]-region[2] > maxY:

topLeftY = maxY

else:

topLeftY = region[1]-region[2]

if region[2] <= 0:

width = 1

height = 1

elif topLeftX + (2 * region[2]) > maxX:

width = maxX - topLeftX

else:

width = 2 * region[2]

if topLeftY + (2 * region[2]) > maxY:

height = maxY - topLeftY

else:

height = 2 * region[2]

if DEBUG:

print "In pupilRemove ending boundary checking"

# These calculations will often give long (decimal) values. Pixel based coordinates

# must be ints so we cast them

crop = (np.int(topLeftX), np.int(topLeftY), np.int(width), np.int(height))

if DEBUG:

print "In pupilRemove. Crop is: " + str(crop)

print "Region passed to pupil remove: " + str(region)

print "And here's crop: " + str(crop)

print "Before crop we have type: " + str(type(self.eyePhoto))

print self.eyePhoto

print "The num of rows is " + str(self.eyePhoto.rows)

cv.ShowImage("We're cropping", self.eyePhoto)

cv.WaitKey(0)

cv.DestroyWindow("We're cropping")

'''

if DEBUG:

print "Finally doing cv subrect"

pupil = cv.GetSubRect(self.eyePhoto, crop)

if DEBUG:

print "After crop we have type: " + str(type(pupil))

cv.ShowImage("Cropped", pupil)

cv.WaitKey(0)

cv.DestroyWindow("Cropped")

return pupil

def getEyePhoto(self):

""" Returns a photo of the eye """

return self.eyePhoto

def getEyeRegion(self):

""" Returns a region representing the eye """

return self.eyeRegion

def getPupil(self):

""" Returns the Pupil object for this eye """

return self.eyePupil

def setEyePhoto(self,photo):

""" Sets eyePhoto to the photo passed in as argument"""

self.eyePhoto = photo

def setEyeRegion(self,region):

""" Sets eyeRegion to the region passed in as argument"""

self.eyeRegion = region

def setPupil(self,region):

""" Sets eyePupil to a new Pupil object constructed from

if DEBUG:

print "We're in set pupil just before pupilRemove and our region is: " + str(region)

pupilPhoto = self.pupilRemove(region)

if DEBUG:

print "We're in setPupil just before making a new pupil object"