def _read_catalyst(self, process_box):
bw = bio.make_bw(process_box)
mask = bw[30:90, 10:40] > 0
if np.sum(mask) < 50:
return 'no catalyst'
else:
catalyst_box = process_box[40:85, 20:70, :]
mask = bio.make_bw(catalyst_box, th=170) > 0
avg_color = bio.avg_color(catalyst_box, mask)
return bio.recognize_color(avg_color, self.catalyst_palette)
def _find_remove_box(self, ingredient_box):
bw_box = bio.make_bw(ingredient_box)
positions = bio.find_shapes(bw_box, self.remove_text_kernel, th=1100)
assert len(positions) <= 1, 'At most one "Remove" text is allowed'
if len(positions) == 0:
return None
x = int(positions[0][0])
y = int(positions[0][1])
x0 = x - 85
x1 = x - 30
y0 = y - 10
y1 = y + 15
is_cannot = np.sum(bw_box[y0:y1, x0:x1] > 0) > 100
if is_cannot:
upper_edge = y - 24
lower_edge = y + 24
remove_box = None
else:
x0 = x - 165
x1 = x + 165
y0 = y + 15
y1 = y + 144
upper_edge = y0 - 31
lower_edge = y1
remove_box = bio.cut(ingredient_box, ((x0, x1), (y0, y1)))
return remove_box, upper_edge, lower_edge
def _read_hoover_cure_concentrations(self, cure_box):
box_bw = bio.make_bw(cure_box)
active_range_text_position = bio.find_shapes(
box_bw, self.active_range_text_kernel, 1850)
assert len(active_range_text_position) == 1
# max_text_position = bio.find_shapes(box_bw, self.max_text_kernel, 700)
# assert len(max_text_position) == 1
# flask_positions = bio.find_shapes(box_bw, self.flask_kernel, 500)
# assert len(flask_positions) == 2
arx, ary = active_range_text_position[0]
# mx, my = max_text_position[0]
# f1x, f1y = flask_positions[0]
# f2x, f2y = flask_positions[1]
# range_coordinates = [[arx + 50, f1x - 12], [ary - 10, ary + 10]]
# max_coordinates = [[mx + 20, f2x - 12], [my - 10, my + 10]]
slider_coordinates = [[arx - 51, arx + 189], [ary + 25, ary + 42]]
# conc_optimal = self._read_concentration(bio.cut(cure_box, max_coordinates))
# conc_range = self._read_concentration_range(bio.cut(cure_box, range_coordinates))
conc_range_slider, conc_optimal_slider = self._read_cure_slider(
bio.cut(cure_box, slider_coordinates))
return conc_range_slider, conc_optimal_slider
def _read_catalyst(self, catalyst_box):
bw = bio.make_bw(catalyst_box)
mask = bw > 0
if np.sum(mask) < 50:
return 'no catalyst'
else:
avg_color = bio.avg_color(catalyst_box, mask)
return bio.recognize_color(avg_color, self.catalyst_palette)
def _cut_machine(self, process_box):
kernel = self.upgrade_with_text_kernel
im_bw = bio.make_bw(process_box)
upgrade_with_position = bio.find_shapes(im_bw, kernel, th=1750)
if len(upgrade_with_position) != 1:
return None
x, y = upgrade_with_position[0]
segment = bio.cut(process_box, [[x - 50, x + 50], [y + 10, y + 111]])
return segment
def _recognize_machine(self, remove_box):
segment = bio.make_bw(self._cut_machine(remove_box))
min_distance = np.inf
closest_machine = None
for name, kernel in self.machine_dict.items():
distance = np.sum(np.abs(kernel - segment))
if distance < min_distance:
min_distance = distance
closest_machine = name
return closest_machine
def read_digits_by_kernels(segment, list_of_digit_kernels):
im_bw = bio.make_bw(segment, th=200)
digits = []
for digit in range(0, 10, 1):
kernel = list_of_digit_kernels[digit]
positions = bio.find_shapes(im_bw, kernel, th=160)
for pos in positions:
x = pos[0]
digits.append((x, digit))
digits.sort()
return tuple([d[1] for d in digits])
def _get_slider(self, ingredient_box, effect_idx):
effect_box_height = 65
slider_height = 18
slider_width = 240
x0 = 280
x1 = x0 + slider_width
i = effect_idx
y0 = 161 + (i + 1) * effect_box_height - slider_height
y1 = y0 + slider_height
slider = ingredient_box[y0:y1, x0:x1, :]
if np.sum(bio.make_bw(slider) > 0) > 50:
return slider
else:
return None
def _read_cure_name(self, effect_box):
"""
Recognize the name of the cure, with the aid of a
list of known cure names
"""
cure_name_bw = bio.make_bw(effect_box[15:35, 5:200, :], th=132)
best_match = None
min_distance = np.inf
for cure_name, kernel in self.known_cure_kernels.items():
distance = np.sum(np.abs(cure_name_bw - kernel))
if distance < min_distance:
min_distance = distance
best_match = cure_name
return best_match
def _cut_price(self, cure_box):
"""
Selects the part of the image that contains
the price of the cure after the dollar sign
"""
bw = bio.make_bw(cure_box)
dollar_centers = bio.find_shapes(bw, self.dollar_kernel, th=650)
if len(dollar_centers) != 1:
return None
x, y = dollar_centers[0]
height = 20
padding = 10
return cure_box[int(y) - height // 2:int(y) + height // 2,
int(x) + padding:]
def _cut_concentration(self, remove_box):
"""
Selects the part of the image that contain concentration range,
using the position of the flask icon in a process box,
from the Cures screen.
"""
bw = bio.make_bw(remove_box)
kernel = self.flask_kernel
flask_center = bio.find_shapes(bw, kernel, 465)
if len(flask_center) != 1:
return None
x, y = flask_center[0]
height = 20
padding = 5
length = 60
return remove_box[int(y) - height // 2:int(y) + height // 2 + 2,
int(x) - length - padding:int(x) - padding]
def cut_boxes(im):
"""
Locates ingredient boxes and process boxes
"""
main_im = bio.cut_main_screen(im)
bw_im = bio.make_bw(main_im)
kernel = np.load('./kernels/Import-text.npy')
import_positions = bio.find_shapes(bw_im, kernel, th=5700)
kernel = np.load('./kernels/Upgrade-text.npy')
upgrade_positions = bio.find_shapes(bw_im, kernel, th=1950)
x_offsets = {'import': -512, 'upgrade': -145}
y_offsets = {'import': -80, 'upgrade': -395}
if len(import_positions) >= len(upgrade_positions):
x_offset = x_offsets['import']
y_offset = y_offsets['import']
positions = import_positions
else:
x_offset = x_offsets['upgrade']
y_offset = y_offsets['upgrade']
positions = upgrade_positions
width = 580
height = 430
boxes = []
for pos in positions:
x0 = int(pos[0] + x_offset)
y0 = int(pos[1] + y_offset)
x1 = x0 + width
y1 = y0 + height
if x0 < 0 or y0 < 0 or \
x1 > main_im.shape[1] or y1 > main_im.shape[0]:
continue
box = main_im[y0:y1, x0:x1, :]
boxes.append(box)
return boxes
def _is_empty(self, effect_box):
bw = bio.make_bw(effect_box)
return np.sum(bw > 0) < 50
def cut_boxes(im):
"""
Locates effect boxes and process boxes on the b&w
screen shot of the Cures screen.
"""
im_main_screen = bio.cut_main_screen(im)
im_bw = bio.make_bw(im_main_screen)
# find triangles
kernel = np.load('./kernels/triangle.npy')
triangle_centers = bio.find_shapes(im_bw, kernel, 950)
triangle_centers.sort()
# group triangles into columns
columns_of_triangles = []
columns_of_triangles.append([triangle_centers[0]])
for triangle in triangle_centers[1:]:
if np.abs(columns_of_triangles[-1][0][0] - triangle[0]) < 50:
columns_of_triangles[-1].append(triangle)
else:
columns_of_triangles.append([triangle])
cure_box_height = 63
process_box_height = 125
box_width = 290
padding = 15
last_padding = 22
cure_box_gap = cure_box_height + 2 * padding
process_box_gap = process_box_height + 2 * padding
columns_of_box_identities = [] # 'drug' or 'process'
columns_of_box_coordinates = [] # (x1, x2, y1, y2)
for idx, col in enumerate(columns_of_triangles):
if len(col) < 2:
print('Warning: missing triangles in column ' + str(idx))
break
box_identities = []
box_coordinates = []
columns_of_box_identities.append(box_identities)
columns_of_box_coordinates.append(box_coordinates)
for i in range(len(col) - 1):
gap = col[i + 1][1] - col[i][1]
gap_identity = identify_gap(gap, cure_box_gap, process_box_gap)
if gap_identity in ['cure', 'process']:
box_identities.append(gap_identity)
y1 = col[i][1] + padding
y2 = col[i + 1][1] - padding
x1 = col[i][0] - box_width // 2
x2 = col[i][0] + box_width // 2
box_coordinates.append((x1, x2, y1, y2))
else:
box_identities.append('cure')
x, y = col[i]
y1 = y + last_padding
y2 = y + last_padding + cure_box_height
x1 = x - box_width // 2
x2 = x + box_width // 2
box_coordinates.append((x1, x2, y1, y2))
box_identities.append('cure')
x, y = col[i + 1]
y1 = y - padding - cure_box_height
y2 = y - padding
x1 = x - box_width // 2
x2 = x + box_width // 2
box_coordinates.append((x1, x2, y1, y2))
# revise first box revision
if box_identities[0] == 'cure':
box_identity = 'process'
box_height = process_box_height
elif box_identities[0] == 'process':
box_identity = 'cure'
box_height = cure_box_height
x, y = col[0]
y1 = y - padding - box_height
y2 = y - padding
x1 = x - box_width // 2
x2 = x + box_width // 2
if y1 > 0 and y2 < im_main_screen.shape[0]:
box_identities.insert(0, box_identity)
box_coordinates.insert(0, (x1, x2, y1, y2))
# revise last box
if box_identities[-1] == 'cure':
box_identity = 'process'
box_height = process_box_height
elif box_identities[-1] == 'process':
box_identity = 'cure'
box_height = cure_box_height
x, y = col[-1]
y1 = y + last_padding
y2 = y + last_padding + box_height
x1 = x - box_width // 2
x2 = x + box_width // 2
if y1 > 0 and y2 < im_main_screen.shape[0]:
box_identities.append(box_identity)
box_coordinates.append((x1, x2, y1, y2))
# cut from image
columns_of_boxes = []
for box_coordinates in columns_of_box_coordinates:
boxes = []
columns_of_boxes.append(boxes)
for box_coord in box_coordinates:
x1, x2, y1, y2 = box_coord
boxes.append(im_main_screen[int(y1):int(y2), int(x1):int(x2), :])
return columns_of_boxes, columns_of_box_identities