def get_image_op(figures, orientation):
xor = transformation.op_transform(figures[0], figures[1], 'xor')
xor_similarity = ('xor', algorithm.calc_rms(xor, figures[2]))
intersect = transformation.op_transform(figures[0], figures[1],
'intersect')
intersect_similarity = ('intersect',
algorithm.calc_rms(intersect, figures[2]))
subtract = transformation.op_transform(figures[0], figures[1], 'subtract')
subtract_similarity = ('subtract',
algorithm.calc_rms(subtract, figures[2]))
union = transformation.op_transform(figures[0], figures[1], 'union')
union_similarity = ('union', algorithm.calc_rms(union, figures[2]))
modified_subtract = transformation.op_transform(
figures[0], figures[1], 'modified-subtract-' + orientation)
modified_subtract_similarity = ('modified-subtract-' + orientation,
algorithm.calc_rms(modified_subtract,
figures[2]))
comparisons = [
xor_similarity, intersect_similarity, union_similarity,
subtract_similarity, modified_subtract_similarity
]
m = min(comparisons, key=lambda t: t[1])
return m[0]
def image_op_solver(figures, solutions, problem):
operation = determine_single_image_op(figures)
horizontal_tester = transformation.op_transform(figures[6], figures[7],
operation)
vertical_tester = transformation.op_transform(figures[2], figures[5],
operation)
horizontal_scores = []
vertical_scores = []
for i, solution in enumerate(solutions):
x = algorithm.calc_rms(horizontal_tester, solution)
horizontal_scores.append((i, x))
for i, solution in enumerate(solutions):
x = algorithm.calc_rms(vertical_tester, solution)
vertical_scores.append((i, x))
m_horizontal = min(horizontal_scores, key=lambda t: t[1])
m_vertical = min(vertical_scores, key=lambda t: t[1])
if m_horizontal[0] == m_vertical[
0] or operation == 'modified-subtract-horizontal':
scores = utility.get_score(m_horizontal, problem)
return scores
else:
# need to determine which one to choose ?
scores = utility.get_score(m_vertical, problem)
return scores
def image_op_solver(figures, solutions, problem):
operation = determine_single_image_op(figures)
horizontal_tester = transformation.op_transform(figures[6], figures[7], operation)
vertical_tester = transformation.op_transform(figures[2], figures[5], operation)
horizontal_scores = []
vertical_scores = []
for i, solution in enumerate(solutions):
x = algorithm.calc_rms(horizontal_tester, solution)
horizontal_scores.append( (i, x) )
for i, solution in enumerate(solutions):
x = algorithm.calc_rms(vertical_tester, solution)
vertical_scores.append( (i, x) )
m_horizontal = min(horizontal_scores, key=lambda t: t[1])
m_vertical = min(vertical_scores, key=lambda t: t[1])
if m_horizontal[0] == m_vertical[0] or operation == 'modified-subtract-horizontal':
scores = utility.get_score(m_horizontal, problem)
return scores
else:
# need to determine which one to choose ?
scores = utility.get_score(m_vertical, problem)
return scores
def compare_top_bottom(scores, figures, solutions, problem):
if not scores:
scores = [.125, .125, .125, .125, .125, .125, .125, .125]
g_blobs = algorithm.get_blobs(algorithm.find_regions(figures[6]))
h_blobs = algorithm.get_blobs(algorithm.find_regions(figures[7]))
top_g = g_blobs[algorithm.get_top(g_blobs)]
bottom_h = h_blobs[algorithm.get_bottom(h_blobs)]
possible_answers = []
for i, score in enumerate(scores):
if score != 0.0:
possible_answers.append((i, solutions[i]))
comparisons = []
for answer in possible_answers:
solution_blobs = algorithm.get_blobs(algorithm.find_regions(answer[1]))
top_solution = solution_blobs[algorithm.get_top(solution_blobs)]
bottom_solution = solution_blobs[algorithm.get_bottom(solution_blobs)]
x = (answer[0], algorithm.calc_rms(top_g, top_solution) +
algorithm.calc_rms(bottom_h, bottom_solution))
comparisons.append(x)
m = min(comparisons, key=lambda t: t[1])
return m
def compare_top_bottom(scores, figures, solutions, problem):
if not scores:
scores = [.125, .125, .125, .125, .125, .125, .125, .125]
g_blobs = algorithm.get_blobs(algorithm.find_regions(figures[6]))
h_blobs = algorithm.get_blobs(algorithm.find_regions(figures[7]))
top_g = g_blobs[algorithm.get_top(g_blobs)]
bottom_h = h_blobs[algorithm.get_bottom(h_blobs)]
possible_answers = []
for i, score in enumerate(scores):
if score != 0.0:
possible_answers.append( (i, solutions[i]))
comparisons = []
for answer in possible_answers:
solution_blobs = algorithm.get_blobs(algorithm.find_regions(answer[1]))
top_solution = solution_blobs[algorithm.get_top(solution_blobs)]
bottom_solution = solution_blobs[algorithm.get_bottom(solution_blobs)]
x = ( answer[0], algorithm.calc_rms(top_g, top_solution) + algorithm.calc_rms(bottom_h, bottom_solution))
comparisons.append(x)
m = min(comparisons, key=lambda t: t[1])
return m
def compare_union(scores, figures, solutions, problem):
comparisons = []
for i, score in enumerate(scores):
if score != 0.0:
if problem.problemType == '3x3':
merged = utility.image_union(figures[5], figures[7])
solution = Image.open(solutions[i].visualFilename)
x = (i, algorithm.calc_rms(merged, solution))
else:
merged = utility.image_union(figures[1], figures[2])
solution = Image.open(solutions[i].visualFilename)
x = (i, algorithm.calc_rms(merged, solution))
comparisons.append(x)
m = min(comparisons, key=lambda t: t[1])
return m
def compare_union(scores, figures, solutions, problem):
comparisons = []
for i, score in enumerate(scores):
if score != 0.0:
if problem.problemType == '3x3':
merged = utility.image_union(figures[5], figures[7])
solution = Image.open(solutions[i].visualFilename)
x = (i, algorithm.calc_rms(merged, solution))
else:
merged = utility.image_union(figures[1], figures[2])
solution = Image.open(solutions[i].visualFilename)
x = (i, algorithm.calc_rms(merged, solution))
comparisons.append(x)
m = min(comparisons, key=lambda t: t[1])
return m
def get_image_op(figures, orientation):
xor = transformation.op_transform(figures[0], figures[1], 'xor')
xor_similarity = ('xor', algorithm.calc_rms(xor, figures[2]))
intersect = transformation.op_transform(figures[0], figures[1], 'intersect')
intersect_similarity = ('intersect', algorithm.calc_rms(intersect, figures[2]))
subtract = transformation.op_transform(figures[0], figures[1], 'subtract')
subtract_similarity = ('subtract', algorithm.calc_rms(subtract, figures[2]))
union = transformation.op_transform(figures[0], figures[1], 'union')
union_similarity = ('union', algorithm.calc_rms(union, figures[2]))
modified_subtract = transformation.op_transform(figures[0], figures[1], 'modified-subtract-' + orientation)
modified_subtract_similarity = ('modified-subtract-' + orientation, algorithm.calc_rms(modified_subtract, figures[2]))
comparisons = [xor_similarity, intersect_similarity, union_similarity, subtract_similarity, modified_subtract_similarity]
m = min(comparisons, key=lambda t: t[1])
return m[0]
def compare_diagonal(scores, figures, solutions, problem):
if not scores:
scores = [.125, .125, .125, .125, .125, .125, .125, .125]
possible_answers = []
for i, score in enumerate(scores):
if score != 0.0:
possible_answers.append((i, solutions[i]))
comparisons = []
for answer in possible_answers:
x = (answer[0], algorithm.calc_rms(figures[4], answer[1]))
comparisons.append(x)
m = min(comparisons, key=lambda t: t[1])
return m
def compare_diagonal(scores, figures, solutions, problem):
if not scores:
scores = [.125, .125, .125, .125, .125, .125, .125, .125]
possible_answers = []
for i, score in enumerate(scores):
if score != 0.0:
possible_answers.append( (i, solutions[i]))
comparisons = []
for answer in possible_answers:
x = ( answer[0], algorithm.calc_rms(figures[4], answer[1]))
comparisons.append(x)
m = min(comparisons, key=lambda t: t[1])
return m
def equality(source, compare):
if round(algorithm.calc_rms(source, compare), 0) < 970.0:
return True
else:
return False
