def detect_slope_intercept(image):
space = common.init_space(CONVERTED_SIZE, CONVERTED_SIZE)
line = common.Line()
point_list = get_points(image)
for row in range(CONVERTED_SIZE):
for point in point_list:
# Change m range from [0, 2000] to [-10, 10]
m = row / 100 - 10
b = point[1] - m * point[0] # y = mx + b => b = y - mx
# Change b range from [-1000, 1000] to [0, 2000]
b_cast = int(b + 1000)
# Change m range from [-10, 10] to [0, 2000]
m_cast = int((m + 10) * 100)
if 0 <= b_cast < CONVERTED_SIZE and 0 <= m_cast < CONVERTED_SIZE:
space[b_cast][m_cast] += 1
max_value = -1
for b in range(CONVERTED_SIZE):
for m in range(CONVERTED_SIZE):
if space[b][m] > max_value:
max_value = space[b][m]
line.b = b - 1000
line.m = m / 100 - 10
return line
def detect_slope_intercept(image):
line = common.Line()
m_values = [x * 0.01 for x in range(-1000, 1000)]
votes = common.init_space(2000, 2000)
hough = common.init_space(2000, 2000)
for i in range(2000):
for j in range(2000):
hough[i][j] = (0, 0)
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
pixel = (image[0][y][x], image[1][y][x], image[2][y][x])
if pixel == (0, 0, 0):
i = 0
for m in m_values:
b = -x * m + y
if b >= -1000 and b < 1000:
votes[i][int(b) + 1000] = votes[i][int(b) + 1000] + 1
hough[i][int(b) + 1000] = (m, b)
i = i + 1
max_votes = votes[0][0]
for m in range(2000):
for b in range(2000):
if votes[m][b] >= max_votes:
max_votes = votes[m][b]
max_m = hough[m][b][0]
max_b = hough[m][b][1]
line.m = max_m
line.b = max_b
return line
def detect_circles(image):
space = common.init_space(HEIGHT, WIDTH)
circle = common.Line()
circle.r = 30
circles_num = 0
point_list = get_points(image)
tot_steps = 2 * 360
angle_per_step = 2 * math.pi / tot_steps
for theta in range(tot_steps):
for point in point_list:
# (x - a)^2 + (y - b)^2 = r^2
a = int(point[0] + circle.r * math.cos(angle_per_step * theta) + 1)
b = int(point[1] - circle.r * math.sin(angle_per_step * theta) + 1)
if 0 <= a < HEIGHT and 0 <= b < WIDTH:
space[a][b] += 1
for a in range(HEIGHT):
for b in range(WIDTH):
if space[a][b] > 650:
circles_num += 1
return circles_num
def detect_slope_intercept(image):
# PUT YOUR CODE HERE
# access the image using "image[chanel][y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.m and line.b
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
hough_space = common.init_space(2000, 2000)
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
if ((image[0][y][x] == 0) and (image[1][y][x] == 0)
and (image[2][y][x] == 0)):
for m_space in range(0, 2000):
m = float(m_space) / float(100) - 10
b = -(m * x) + y
if (b > -1000 and b < 1000):
hough_space[m_space][int(b) + 1000] += 1
maximum = -1
for y in range(2000):
for x in range(2000):
if hough_space[y][x] > maximum:
maximum = hough_space[y][x]
m = float(y) / 100 - 10
b = x - 1000.4
line.m = m
line.b = b
return line
def detect_normal(image):
line = common.Line()
pi = 3.14
theta_values = [pi * (x / 1800.0) for x in range(0, 1800)]
votes = common.init_space(2000, 2000)
hough = common.init_space(2000, 2000)
for i in range(1800):
for j in range(1800):
hough[i][j] = (0, 0)
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
pixel = (image[0][y][x], image[1][y][x], image[2][y][x])
if pixel == (0, 0, 0):
i = 0
for theta in theta_values:
r = x * math.cos(theta) + y * math.sin(theta)
if r >= -900 and r < 900:
votes[i][int(r) + 900] = votes[i][int(r) + 900] + 1
hough[i][int(r) + 900] = (theta, r)
i = i + 1
max_votes = votes[0][0]
for theta in range(1800):
for r in range(1800):
if votes[theta][r] > max_votes:
max_votes = votes[theta][r]
max_theta = hough[theta][r][0]
max_r = hough[theta][r][1]
line.r = max_r
line.theta = max_theta
return line
def detect_normal(image):
# PUT YOUR CODE HERE
# access the image using "image[chanel][y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.theta and line.r
# to create an auxiliar bidimentional structure
# you can use "space=common.init_spa
line = common.Line()
hough_space = common.init_space(1800, 1800)
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
if ((image[0][y][x] == 0) and (image[1][y][x] == 0)
and (image[2][y][x] == 0)):
for theta_space in range(0, 1800):
theta = math.radians(float(theta_space) / float(10))
r = x * math.cos(theta) - y * math.sin(theta)
if (r > -900 and r < 900):
hough_space[theta_space][int(r) + 900] += 1
maximum = -1
for y in range(1800):
for x in range(1800):
if hough_space[y][x] > maximum:
maximum = hough_space[y][x]
theta = math.pi - math.radians(float(y) / float(10))
r = 900 - x
line.r = r
line.theta = theta
return line
def detect_slope_intercept(image):
# PUT YOUR CODE HERE
# access the image using "image[y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.m and line.b
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
line.m = 0
line.b = 0
space = common.init_space(2000, 2000)
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
if image[y][x] == 0:
for each in range(2000):
# scaling to get from xy to mb scale
m = (each / 100) - 10
b = -m * x + y
if 1000 > b > -1000:
space[each][int(b) + 100] += 1
maxi = float("-inf")
for y in range(2000):
for x in range(2000):
if space[y][x] > maxi:
maxi = space[y][x]
# scale m according to y, so divide by 100, 20 vs 2000, and then -10 for x axis adjustment.
line.m = (y / 100) - 10
line.b = x - 100
return line
def detect_slope_intercept(image):
# PUT YOUR CODE HERE
# access the image using "image[y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.m and line.b
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
line.m = 0
line.b = 0
(max_b, max_m) = (None, None)
vote_space = [[0 for i in range(2000)] for j in range(2000)]
for y in range(common.constants.WIDTH):
for x in range(common.constants.HEIGHT):
if image[y][x] == 0:
m = -10 #init m value
while (m <= 9.99):
b = y - m * x
if b >= -1000 and b <= 1000:
# print(f"b = {int(b)}, m = {m} at {round(100*(m + 10))}")
vote_space[round(b)][round(100 * (m + 10))] += 1
m += 0.01
line.b, max_x = max_votespace(vote_space)
# print(f"max vote: (b,m) = ({line.b, line.m})")
line.m = round((max_x / 100) - 10, 3)
return line
def detect_slope_intercept(image): # PUT YOUR CODE HERE # access the image using "image[y][x]" # where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT # set line.m and line.b # to create an auxiliar bidimentional structure # you can use "space=common.init_space(heigh, width)" line=common.Line() line.m=0 line.b=0 return line
def detect_normal(image, x_range, y_range):
vote_box = [[0 for col in range(1800)] for row in range(1800)]
for x in range(x_range):
for y in range(y_range):
if image[0][y][x] == 0 and image[1][y][x] == 0 and image[2][y][
x] == 0:
vote_functions.vote_normal(x, y, vote_box)
line = common.Line()
data = auxiliary_functions.find_largest(vote_box, 1800)
line.r = convert_values.index_to_value(data[1], 1800, -900, 900)
line.theta = convert_values.index_to_value(data[0], 1800, 0, 3.14159)
return line
def detect_slope_intercept(image, x_range, y_range):
vote_box = [[0 for col in range(2000)] for row in range(2000)]
for x in range(x_range):
for y in range(y_range):
if image[0][y][x] == 0 and image[1][y][x] == 0 and image[2][y][
x] == 0:
vote_functions.vote_slope(x, y, vote_box)
data = auxiliary_functions.find_largest(vote_box, 2000)
line = common.Line()
line.m = convert_values.index_to_value(data[0], 2000, -10, 10)
line.b = convert_values.index_to_value(data[1], 2001, -1000, 1000)
return line
def detect_normal(image):
# PUT YOUR CODE HERE
# access the image using "image[chanel][y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.theta and line.r
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
line.r = 0
line.theta = 0
max_x = 0
max_y = 0
H = [[[0.0 for x in range(3)] for x in range(1800)] for x in range(1800)]
pi = 3.14159265
incr = pi / 1800.0
for i in range(len(image[0])):
for j in range(len(image[0][0])):
if ((image[2][i][j] == 0) and (image[0][i][j] == image[1][i][j])
and (image[1][i][j] == image[2][i][j])):
theta = 0.0
while theta < pi:
w = j * math.cos(theta) + i * math.sin(theta)
if (w >= -900.0 and w < 900.0):
y = int(theta * (1.0 / incr))
x = int(w + 900.0)
H[y][x][0] = H[y][x][0] + theta
H[y][x][1] = H[y][x][1] + w
H[y][x][2] = H[y][x][2] + 1.0
if (H[y][x][2] > H[max_y][max_x][2]):
max_y = y
max_x = x
theta += incr
line.theta = H[max_y][max_x][0] / H[max_y][max_x][2]
line.r = H[max_y][max_x][1] / H[max_y][max_x][2]
return line
def detect_slope_intercept(image):
# PUT YOUR CODE HERE
# access the image using "image[chanel][y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.m and line.b
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
line.m = 0
line.b = 0
hough_space = [[[0.0 for x in range(3)] for x in range(2000)]
for x in range(2000)]
#print("done")
max_x = 0
max_y = 0
incr = 20.0 / 2000.0
for i in range(len(image[0])):
for j in range(len(image[0][0])):
if ((image[2][i][j] == 0) and (image[0][i][j] == image[1][i][j])
and (image[1][i][j] == image[2][i][j])):
m = -10.0
while (m < 10.0):
b = (m * -j) + i
if (b >= -1000.0 and b < 1000.0):
# select bin[y][x]
y = int((b + 1000))
x = int((m + 10) * 100)
hough_space[y][x][0] = hough_space[y][x][0] + b
hough_space[y][x][1] = hough_space[y][x][1] + m
hough_space[y][x][2] = hough_space[y][x][2] + 1
if (hough_space[y][x][2] >
hough_space[max_y][max_x][2]):
max_y = y
max_x = x
m += incr
max_vote = hough_space[max_y][max_x]
line.b = max_vote[0] / max_vote[2]
line.m = max_vote[1] / max_vote[2]
return line
def detect_slope_intercept(image):
# PUT YOUR CODE HERE
# access the image using "image[chanel][y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.m and line.b
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
bmin = -1000
bmax = 1000
mmin = -10
mmax = 10
#line_space = {}
space = common.init_space(2000, 2000)
bestm = 0
bestb = 0
maxval = 0
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
r = image[0][y][x]
g = image[1][y][x]
b = image[2][y][x]
if r == 0 and g == 0 and b == 0: # black pixel
# find feasible lines
#b = y - m*x
for m in range(2000):
mval = (m - 1000) * 0.01
b = y - mval * x
if b >= bmin and b <= bmax:
b = int(b)
space[m][b] += 1
if space[m][b] >= maxval:
bestb = b
bestm = mval
maxval = space[m][b]
# find the highest voted line
line.m = bestm
line.b = bestb
return line
def detect_normal(image):
# PUT YOUR CODE HERE
# access the image using "image[chanel][y][x]"
# where 0 <= y < common.constants.WIDTH and 0 <= x < common.constants.HEIGHT
# set line.theta and line.r
# to create an auxiliar bidimentional structure
# you can use "space=common.init_space(heigh, width)"
line = common.Line()
space = common.init_space(1800, 1800)
for y in range(common.constants.HEIGHT):
for x in range(common.constants.WIDTH):
r = image[0][y][x]
g = image[1][y][x]
b = image[2][y][x]
if r == 0 and g == 0 and b == 0: # black pixel
for deg in range(1800):
R = x * math.cos(deg * math.pi / 1800) + y * math.sin(
deg * math.pi / 1800)
if R <= 900 and R >= -900:
R = int(R) + 900
space[R][deg] += 1
bestR = 0
bestdeg = 0
maxval = 0
for deg in range(1800):
for R in range(1800):
val = space[R][deg]
if val >= maxval:
maxval = val
bestdeg = deg
bestR = R
line.r = bestR - 900
line.theta = (bestdeg * math.pi / 1800)
return line
