Beispiel #1
0
def import_faces(path=''):
    "call import_faces() to obtain a list of images of faces"
    faces = {}
    for i in range(1, 21):
        name = path + ('faces/img%02d.png' % i)
        print('Reading '+name)
        faces[i-1] = image.file2image(name)
    return faces
Beispiel #2
0
def loadImageRotateAndPlot(imageFile, theta):
    data = image.color2gray(image.file2image(imageFile))
    row = len(data) 
    col = len(data[0])
    
    S = rotate([ x+(y*1j) for y in range(len(data)) for x in range(len(data[y])) if data[row-y-1][x] < 120 ], theta)

    plotting.plot(S, max(row * 1.5, col * 1.5), 1)
Beispiel #3
0
def loadImageAndPlot(imageFile):
    data = image.color2gray(image.file2image(imageFile))
    row = len(data) 
    col = len(data[0])
    
    S = [ x+(y*1j) for y in range(len(data)) for x in range(len(data[y])) if data[row-y-1][x] < 120 ]
    
    plotting.plot(S, max(row, col), 1)
Beispiel #4
0
def load_images(directoryname, num_faces=20):
    #loads the given number of image files from the classified files
    #returns a dict of face number to image files
    return {
        i:
        color2gray(file2image(os.path.join(directoryname, "img%02d.png" % i)))
        for i in range(num_faces)
    }
Beispiel #5
0
def import_unclassified(path=''):
    "call import_faces() to obtain a list of images of things including faces"
    unclassified = {}
    for i in range(1, 12):
        name = path + ('unclassified/img%02d.png' % i)
        print('Reading '+name)
        unclassified[i-1] = image.file2image(name)
    return unclassified
def T2410(filename):
    data = image.file2image(filename)
    pts = set()
    for x in range(166):
        for y in range(189):
            if data[y][x][0] < (0.5*255):
                pts.add(x-(y-189)*1j)
    return pts
Beispiel #7
0
def T2410(filename):
    data = image.file2image(filename)
    pts = set()
    for x in range(166):
        for y in range(189):
            if data[y][x][0] < (0.5 * 255):
                pts.add(x - (y - 189) * 1j)
    return pts
def load_images(path, n = 20):
    '''
    Input:
        - path: path to directory containing img*.png
        - n: number of images to load
    Output:
        - dict mapping numbers 0 to (n-1) to a list of rows,
          each of which is a list of pixel brightnesses
    '''
    return {i:color2gray(file2image(os.path.join(path,"img%02d.png" % i))) for i in range(n)}
def png2graymatrix(filename):
    """
    Converts an image file to a Matrix object where each value is the
    grayscale value of a pixel.
    Uses functions from image.py by Philip N. Klein.
    """
    image_data = file2image(filename)
    if (isgray(image_data) == False):
        image_data = color2gray(image_data)
    return Matrix(image_data)
def png2graymatrix(filename):

    #FIXME: a single line of code should go here
    image_data = image.file2image(filename)

    if not image.isgray(image_data):
        image_data = image.color2gray(
            image_data)  #FIXME: make the image grayscale

    return Matrix(image_data)  #FIXME
def png2graymatrix(filename):
    """
    takes a png file and returns a Matrix object of the pixels 
    INPUT: filename - the path and filename of the png file
    OUTPUT: a Matrix object with dimensions m x n, assuming the png file has width = n and height = m, 
    """
    #FIXME: a single line of code should go here
    image_data=image.file2image(filename)
    if not image.isgray(image_data):
        image_data = image.color2gray(image_data)#FIXME: make the image grayscale
    return Matrix(image_data) #FIXME
Beispiel #12
0
def loadImageRotateCenterAndPlot(imageFile, theta):
    data = image.color2gray(image.file2image(imageFile))
    row = len(data) 
    col = len(data[0])
    
    yCenter = int(row / 2)
    xCenter = int(col / 2)
    
    toCenter = 0 - xCenter - yCenter * 1j
    
    S = rotate([ x+(y*1j)+toCenter for y in range(len(data)) for x in range(len(data[y])) if data[row-y-1][x] < 120 ], theta)

    plotting.plot(S, max(yCenter * 1.5, xCenter * 1.5), 1)
Beispiel #13
0
def loadImageAndPlotToCenterRotateAndScale(imageFile):
    data = image.color2gray(image.file2image(imageFile))
    row = len(data) 
    col = len(data[0])
    
    yCenter = int(row / 2)
    xCenter = int(col / 2)
    
    toCenter = 0 - xCenter - yCenter * 1j
    
    S = rotateAndScaled([ x+(y*1j)+toCenter for y in range(len(data)) for x in range(len(data[y])) if data[row-y-1][x] < 120 ])
    
    plotting.plot(S, max(yCenter, xCenter), 1)
Beispiel #14
0
def loadImageRotateCenterScaleAndPlot(imageFile, theta, scale):
    data = image.color2gray(image.file2image(imageFile))
    row = len(data) 
    col = len(data[0])
    
    yCenter = int(row / 2)
    xCenter = int(col / 2)
    
    toCenter = 0 - xCenter - yCenter * 1j
    
    S = [ math.e**(theta*1j)*scale*(x+(y*1j)+toCenter) for y in range(len(data)) for x in range(len(data[y])) if data[row-y-1][x] < 120 ]

    plotting.plot(S, max(yCenter * 1.5, xCenter * 1.5), 1)
Beispiel #15
0
def task1410(filename):
	# Errata mentions to use color2gray to convert the 3-tuples that file2image gives into a single number
	data = color2gray(file2image(filename))
	# Original Pseudo-code
	# for y = 0; y < len(data); y++
	#	for x = 0; x < len(data[y]); x++
	#		if(data[y][x] < 120)
	#			pts.add(x + yj)
	# pts = {x + yj for {y,x} in data if data[y][x] < 120}
	# Fix this by subtracting the y we get from the height (length of data)
	pts = [x+(len(data)-y)*1j for y, datay in enumerate(data) for x, intensity in enumerate(datay) if data[y][x] < 120]
	plot(pts, 190)
	return pts # Not specified in task, but useful for later manipulation
Beispiel #16
0
def image2complex(img_name):
    import image
    
    NP = 0
    CP = 0
    
    data = image.color2gray(image.file2image("img01.png"))
    
    output = set()
    for i in reversed(data):
            
        for ii in i:
            NP = NP + 1
            if ii < 120:
                output.add(complex( NP,CP))
        NP = 0
        CP = CP + 1
        
    return output
def image2complex(img_name):
    """
    IN: img_name - the name of the image to read
    OUT: set of complex numbers x+yi where the intensity of pixel (x,y) is greater than 120
    """
    import image
    NormalPart = 0
    ComplexPart = 0
    # data is a list of lists such that the intensity of pixel (x,y) is given by data[h-1-y][x]
    # where h = height of the image
    data = image.color2gray(image.file2image("img01.png"))
    output = set()
    for i in reversed(data):

        for ii in i:
            NormalPart += 1
            if ii < 120:
                output.add(complex(NormalPart, ComplexPart))
        NormalPart = 0
        ComplexPart += 1
    return output
Beispiel #18
0
def read_image(fname):
    return color2gray(file2image(fname))
Beispiel #19
0
x = [x.real for x in m + t]
y = [y.imag for y in m + t]

# Plotting the Vectors
plt.xlabel("Real")
plt.ylabel("Complex")
plt.scatter(x, y)
plt.xlim(-1, 1)
plt.ylim(-1, 1)
plt.show()

################################## NUMBER 2 ###################################
from image import file2image
from plotting import plot

data = file2image("img01.png")

Y = list(range(0, 189, 1))
X = list(range(0, 166, 1))
pts = [x + (189j + y * -1j) for x in X for y in Y if data[y][x][0] < 120]
plot(pts, 300)

# translation by 189j and multiplication by -1 was used to make the image
# reflect the expected result

# Y is the set of numbers from 0-188, as the image is 189 pixels tall

# X is the set of numbers from 0-165, as the image is 166 pixels across

################################## NUMBER 3 ###################################
data = file2image("img01.png")
def read_image(filepath):
    return file2image(filepath)
Beispiel #21
0
# comprehension to assign to a list pts the set of complex numbers x+yi such
# that the image intensity of pixel (x,y) is less than 120, and plot the list
# pts.
'''
    Keep these in mind:
    Something to do with this statement: [[x for x in row] for row in image]
    
    S={2+2j,3+2j,1.75+1j, 2+1j, 2.25+1j, 2.5+1j, 2.75+1j, 3+1j, 3.25+1j}
    plot(S,4)

    Use enumerate(List) to return a tuple of (index,List(item))
'''

import image

data = image.file2image('img01.png')
bw_data = image.color2gray(data)

pts = {
    complex(col_ind, 189 - row_ind)
    for (row_ind, row) in enumerate(bw_data)
    for (col_ind, intensity) in enumerate(row) if intensity < 120
}

plot(pts, 200, 1)


# Task 1.4.11: Write a Python procedure f(z) that takes as an argument a
# complex number z so that when f(z) applied to each of the complex numbers in
# S, the set of resulting numbers is centered at the origin. Write a
# comprehension in terms of S and f whose value is the set of translated
Beispiel #22
0
# ROTAING BY 90 DEGREES
# a point located at (x,y) must be moved to  (-y,x) the complex number located
# at(x,y) is x + iy. Multiplying by i yields ix + i^2y, which is ix-y
# which is the complex number represented by the point (-y, x) 
rot_90_deg = {1j*z for z in S}
# plot(rot_180_deg|rot_90_deg, 4)

# Task 1.4.9: Using a compr(ehension, create a new plot in which the points of S are rotated by
# 90 degrees, scaled by 1/2, and then shifted down by one unit and to the right two units. Use
# a comprehension in which the points of S are multiplied by one complex number and added to
# another.
T = { 1j*z * 0.5 + 2-1j for z in S}
# plot(T|S,4)

# Task 1.4.10:
data = file2image('../Material/img01.png')
# print(data)
height = len(data)
width =len(data[0])
pts=[x+(189j+y*-1j) for x in range(width) for y in range(height) if data[y][x][0]<120]
print(len(pts))
# points = {x+(y*-1j) for x in range(len(data)) for y in range(len(data[0])) if data[x][y][0] < 120}
# print(points)``
# points_rot = {-1j*x for x in points}
# plot(points, 200, 1)
# plot(set(points|points_rot), 200, 1)

# Task 1.4.11: Write a Python procedure f(z) that takes as argument a complex number z so
# that when f(z) is applied to each of the complex numbers in S, the set of resulting numbers
# is centered at the origin.
# def center_at_origin(S):
def file2mat(path, row_labels=('x', 'y', 'u')):
    """input: a filepath to an image in .png format
output: the pair (points, matrix) of matrices representing the image."""
    return image2mat(image.file2image(path), row_labels)
Beispiel #24
0
def plot_image():
    data = file2image("img01.png")
    plot({ x + ((len(data) - y) * 1j) for x in range(len(data[0])) for y in range(len(data)) if sum(data[y][x]) / 3 < 120 }, 200)
Beispiel #25
0
for i in range(2, 8):
    b = i - 2
    print("\n" + "=" * b + " + " + "=" * b)
    plus_chart({x for x in range(i)})
    print("\n" + "=" * b + " * " + "=" * b)
    mult_chart({x for x in range(i)})


def myplot(numset):
    X = [x.real for x in numset]
    Y = [x.imag for x in numset]
    plt.scatter(X, Y, color='red')
    plt.show()


face = img.file2image('img01.png')
height = len(face)
width = len(face[0])

complixels = [(width - x) + (height - y) * 1j for y, row in enumerate(face)
              for x, tup in enumerate(row) if tup[0] < (127.5)]
rot90 = [num * 1j for num in complixels]
center = [num - (width / 2) - ((height / 2) * 1j) for num in complixels]

# myplot(complixels)
# myplot(rot90)
# myplot(center)
plot(complixels)
print(face[98][45])

Beispiel #26
0
    b = i - 2
    print("\n" + "="*b + " + " + "="*b)
    plus_chart({x for x in range(i)})
    print("\n" + "="*b + " * " + "="*b)
    mult_chart({x for x in range(i)})


def myplot(numset):
    X = [x.real for x in numset]
    Y = [x.imag for x in numset]
    plt.scatter(X,Y, color='red')
    plt.show()



face       = img.file2image('img01.png')
height     = len(face)
width      = len(face[0])

complixels = [(width - x) + (height - y) * 1j for y, row in enumerate(face) 
              for x, tup in enumerate(row) if tup[0] < (127.5)]
rot90 = [num * 1j for num in complixels]
center = [num - (width / 2) - ((height / 2) * 1j) for num in complixels]

# myplot(complixels)
# myplot(rot90)
# myplot(center)        
plot(complixels)
print(face[98][45])

# 1.7.1
Beispiel #27
0
Created on Sun May 12 12:24:03 2019

@author: naveenpc
"""
from plotting import plot as _plot
import image
S = {
    2 + 2j, 3 + 2j, 1.75 + 1j, 2 + 1j, 2.25 + 1j, 2.5 + 1j, 2.75 + 1j, 3 + 1j,
    3.25 + 1j
}
#_plot(S,4)
#print(abs(3+4j))
#print((3+4j).conjugate())
#_plot(set(z+1+2j for z in S)|set(z*(0.5j) for z in S)|set((z*(0.5j))+2-1j for z in S),5)
#_plot([z for z in S],5)
img_data = image.file2image(r"C:\Users\naveenpc\img01.png")
width = len(img_data[0])
height = len(img_data)
intensity = 100
#_plot([])
pts = list(
    complex(w, height - h) for (h, row) in list(enumerate(img_data))
    for (w, p) in list(enumerate(row)) if p[0] < intensity)
#_plot(pts,200)
#n=80
#w=pow(math.e,complex(0,((2*math.pi)/n)))
#nthpow = list(pow(w,i) for i in range(n))
#_plot(nthpow,2)
#z0=complex(sum([z.real for z in pts])/len(pts),sum([z.imag for z in pts])/len(pts))
#plot(list(z-z0 for z in pts),170)
#_plot(list(z*pow(math.e,complex(0,math.pi/4)) for z in S),5)
Beispiel #28
0
#task 1.4.3
#plot({1+2j+z for z in S}, scale=5, hpath='htmls/task143.html', plot='plot - translation')

#task 1.4.7
#plot({z/2 for z in S}, scale=5, hpath='htmls/task147.html', title='plot - scaled by 1/2')

#task 1.4.8
#plot({z*0.5j for z in S}, scale=5, hpath='htmls/task148.html', title='plot - rotated by 90 degree and scaled by 1/2')

#task 1.4.9
#plot({z*0.5j+2-1j for z in S}, scale=5, dot_size=2, hpath='htmls/task149.html', title='plot - rotate scale and shift')



data = list(reversed(file2image('img01.png')))
#print(len(data))
data = color2gray(data)
width = len(data[0])
height = len(data)
print(width, height)
pts =[complex(x,y) for y in range(len(data)) for x in range(len(data[y])) if data[y][x] < 120]
#print(pts)


#task 1.4.10
#plot(pts, scale=len(data), dot_size=2, hpath='htmls/task1410.html', title='image filter')


#task 1.4.11
Beispiel #29
0
def sparsity2d(D_dict):
    return sum([sum([1 if abs(D_dict[kn][km]) != 0 else 0 for km in D_dict[kn]]) for kn in D_dict]) / len(D_dict) / len(list(D_dict.values())[0])


def listdict2dict(L_dict, i):
    return dict((k, L_dict[k][i]) for k in L_dict)


def listdict2dictlist(listdict):
    return [listdict2dict(listdict, i) for i in range(len(list(listdict.values())[0]))]


def backward2d(dictdict):
    D_list = dict((k, backward(dictdict[k])) for k in dictdict)
    L_dict = listdict2dictlist(D_list)
    L_list = [backward(v) for v in L_dict]
    return L_list


def image_round(image):
    return [[min(255, abs(round(n))) for n in row] for row in image]

from image import file2image, color2gray, image2display
img = color2gray(file2image('Dali.png'))
# image2display(img)
wave_comp = forward2d(img)
wave_comp = suppress2d(wave_comp, 100)
print('sparsity is %f' % sparsity2d(wave_comp))
dump_img = image_round(backward2d(wave_comp))
image2display(dump_img)
def import_flag():
    loaded = image.file2image('special_bases/flag.png')
    return image.color2gray(loaded)
Beispiel #31
0
def file2mat(path, row_labels = ('x', 'y', 'u')):
    """input: a filepath to an image in .png format
    output: the pair (points, matrix) of matrices representing the image."""
    return image2mat(image.file2image(path), row_labels)
Beispiel #32
0
def f_2(z):
    data = file2image("img01.png")
    data_set = { x + ((len(data) - y) * 1j) for x in range(len(data[0])) for y in range(len(data)) if sum(data[y][x]) / 3 < 120 }
    return { (s - z) for s in data_set }
Beispiel #33
0
def file2cmlx(fname):
    img = file2image(fname)
    return [ complex(col_i, len(img) - row_i)
             for row_i, row in enumerate(img) \
             for col_i, (intensity, _, _) in enumerate(row) \
             if intensity < 120]
Beispiel #34
0
#2-3
#def solve1(a,b,c): return (c-b)/a
#print solve1(10+5j, 5, 20)

#2-4
#plot(S, 4)

#P.48 2.4.2 Task 2.4.3 
#plot({1+2j+z for z in S}.union(S), 4) # add original set use union function

#P.50 2.4.3 Task 2.4.7
#half
#plot({(1+2j+z)/2 for z in S}.union(S), 4) # add original set use union function
#180 degree
#plot({-(1+2j+z) for z in S}.union(S), 4) # add original set use union function

#P.52 2.4.5 Task 2.4.8
#90 degree
#plot({-1/2j*(1+2j+z) for z in S}.union(S), 4) # add original set use union function

#P.52 2.4.5 Task 2.4.10
data = file2image('img01.png')
data = color2gray(data)     # if occur error, make comment in "image.py" at line 98 
#pts = [[x + y * 1j for x, pixel in enumerate(row) if pixel < 120] for y, row in enumerate(data)]
#pts1 = sum(pts, [])
#plot(pts1, 200, 1)
pts = [[x + y * 1j for x, pixel in enumerate(row) if pixel < 120] for y, row in enumerate(reversed(data))]
pts1 = sum(pts, [])
plot(pts1, 200, 1)
Beispiel #35
0
# imported method that coverts image file into a 2D list, each element
#   contains the intesity of pixel(x,y)
# =============================================================================


# convert 2D list into a set of complex points.
def listList2set(L):
    points = []
    for y in range(len(L)):
        for x in range(len(L[0])):
            if L[y][x][0] < 120:
                points.append(complex(x, len(L) - y))
    return points


image = image.file2image('img01.png')
plotimg = listList2set(image)
# scaling the image to .20 of its size"
setImg = transform(plotimg, 0.20, 0 + 0j)
plotting.plot(setImg)

# =============================================================================
# Task 1.4.19 - rotate the above image
# =============================================================================


def rotateRad(L, rd):
    # use euler's method to change the angle's radius (translate the points)
    return [
        complex(
            z.real * math.cos(rd * math.pi) - z.imag * math.sin(rd * math.pi),
Beispiel #36
0
def image():
    import image
    im=image.file2image("dance.png")
    return im
Beispiel #37
0
#Task 1.4.3
def t3():
    plot({1 + 2j + z for z in S}, 4)


#Task 1.4.8
def t8():
    plot(scale(S, (1 / 2) * 1j))


#Task 1.4.9
def t9():
    plot(translate(scale(S, (1 / 2) * 1j), 2 - 1j))


data = color2gray(file2image("./img01.png"))
pts = {(x - (1j * (y - len(data))))
       for y in range(len(data)) for x in range(len(data[0]))
       if data[y][x] < 120}


#Task 1.4.10
def t10():
    plot(pts, len(data))


#No idea what this task is even asking.
#Task 1.4.11
#def t11()