#===========================================
#
#Bluring Edge Detection Algorithim
#
#===========================================

#--
# This algorithim blurs the image and then looks for pixel darkness differences across a large pixel gap
#--

import Image
img = Image.open("pronation1.jpg")
img.show()
img = img.convert("L")
out = img.copy()
size = img.size
width = size[0]
height = size[1]

edges=[]
edgesx=[]
edgesy=[]

ts = 500

# image bluring method
def blur(img):
	size=img.size
	width=size[0]
	height=size[1]
	out=img.copy()
	bdif=3
	for x in range(bdif,width-bdif):
		for y in range(bdif,height-bdif):
			count=0
			imgcount=0
			for ix in range(x-bdif,x+bdif):
				for iy in range(y-bdif,y+bdif):
					imgcount+=img.getpixel((ix,iy))
					count+=1

			val=imgcount/count
			out.putpixel((x,y),val)
	print "BLURRED"
	out.show()
	return out

#Difference method that gets pixel darkness difference over a given pixel gap, delta
def getDiff(img,pos,delta):
	xp=pos[0]
	yp=pos[1]
	diff=0
	
	diff=img.getpixel((xp-delta,yp))-img.getpixel((xp+delta,yp))

	if diff<0:
		diff=diff*-1
	return diff


img=blur(img)

#assign values to delta and the difference threshhold
delta=3
ts=35
yc=0
#carry out edge detection
for y in range(delta,height-delta):
	edgesy.append([])
	for x in range(delta,width-delta):
		diff = getDiff(img,(x,y),delta)
		if diff<0:
			diff*=-1
		if(diff>ts):
			out.putpixel((x,y),0)
			edges.append((x,y))
			edgesy[yc].append(x)
			
		else:
			out.putpixel((x,y),256)
	yc+=1
outerlist=[]
outerleft=[]
outerright=[]
outercoorright=[]
outercoorleft=[]
yc=0

#Records the outermost pixels in the outline

for y in edgesy:
	if len(y)>1:
		left=y.pop(0)
		right=y.pop()
		y=[left,right]
		outerlist.append(y)
		outercoorleft.append((yc,left))
		outercoorright.append((yc,right))
		outerleft.append(left)
		outerright.append(right)
	else:
		outerlist.append([])
	yc+=1
print outerlist

#create new output imae

ow=width-(2*delta)
oh=height-(2*delta)
outerimg=Image.new("L",(ow,oh))

#sort the outermost pixels
#Then take the median and use that median to find outliers, ie noise in the outline

outerleft.sort()
outerright.sort()
print outerleft
print outerright
leftmid=outerleft[len(outerleft)/2]
rightmid=outerright[len(outerright)/2]

def valDelta(a,b):
	diff=a-b
	if diff<0:
		diff=diff*-1
	return diff

ic=0
diffdelta=10

#put new outline pixels on new image, excluding outlier pixels from noise

for i in outerlist:
	if len(i)>1:
		if valDelta((i[0]-delta),leftmid)<diffdelta:
			outerimg.putpixel((i[0]-delta,ic),100)
		if valDelta((i[1]-delta),rightmid)<diffdelta:
			outerimg.putpixel((i[1]-delta,ic),100)
	ic+=1

out.show()
outerimg.show()