def newFigure(self):
if self.nextFigure == None:
self.figure = Figure((self.width // 2) - 2, 0)
else:
self.figure = self.nextFigure
self.nextFigure = Figure((self.width // 2) - 2, 0) # add a new figure to the game in the middle top
def new_figure(self):
if not self.pass_Figures:
self.pass_Figures = Figure.Figures
pass_figure = randint(0, len(self.pass_Figures) - 1)
self.Figure = Figure(3, 0, pass_figure)
self.figures.append(self.Figure)
if self.intersects():
self.state = "gameover"
def __init__(self, parent):
super().__init__(parent)
self.board = [0 for i in range(200)]
self.timer = QBasicTimer()
self.setFocusPolicy(Qt.StrongFocus)
self.figure = Figure()
self.cube = 20
self.linesRemoved = 0
self.scores = 0
def Solve(self, problem):
print problem.name
problem_name = problem.name
answer = -1
scores = []
#Load all figures and make them black OR white (no grey!)
self.figure_a = Figure(problem.figures['A'].visualFilename)
self.figure_b = Figure(problem.figures['B'].visualFilename)
self.figure_c = Figure(problem.figures['C'].visualFilename)
self.figure_d = Figure(problem.figures['D'].visualFilename)
self.figure_e = Figure(problem.figures['E'].visualFilename)
self.figure_f = Figure(problem.figures['F'].visualFilename)
self.figure_g = Figure(problem.figures['G'].visualFilename)
self.figure_h = Figure(problem.figures['H'].visualFilename)
self.solutions = []
problem_figure_keys = sorted(problem.figures.keys())
num_solutions = 8
for i in range(num_solutions):
figure_sol = Figure(
problem.figures[problem_figure_keys[i]].visualFilename)
self.solutions.append(figure_sol)
answer = self.get_solution()
'''
print problem.name
print "Scores :", scores
print "Correct answer: ", problem.correctAnswer
print "Answer selected: ", answer, '\n'
'''
return answer
def removeFigure(self, Figure):
# if Figure.short == 'k' or Figure.short == 'K':
# return None
#print(Figure in self.getFigures(),self.is_the_piece_on_the_board_pos(Figure.pos) )
if Figure in self.getFigures() and self.is_the_piece_on_the_board_pos(
Figure.pos):
self.figures.remove(Figure)
#print('succesful remove', Figure)
self.board[Figure.getPos()[0]][Figure.getPos()[1]] = '_'
else:
#print('no such figure',Figure, Figure.pos)
pass
def __init__(self, plotNum):
if plotSize == "poster":
fontsize = 14
elif plotSize == "presentation":
fontsize = 14
elif plotSize == "manual":
fontsize = 10
else:
raise ValueError("Unknown plotSize '%s'." % plotSize)
Figure.__init__(self, color=style, fontsize=fontsize)
self.plotNum = plotNum
return
class Game:
def __init__(self):
# set title for the game window
pygame.display.set_caption("Hangman")
# clock that sets the amount of frames per second
self.fps_clock = pygame.time.Clock()
self.settings = Settings()
# create display surface on which everithing is drawn
self.DISPLAY_SURFACE = pygame.display.set_mode((self.settings.WINDOW_WIDTH,
self.settings.WINDOW_HEIGHT))
# create instance of figure class
self.figure = Figure(self.DISPLAY_SURFACE)
self.ta = TextArea(self.DISPLAY_SURFACE)
def run(self):
while True:
self.DISPLAY_SURFACE.fill(self.settings.BLACK)
# check key and mouse events
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN and self.ta.state == "active":
if 97 <= event.key <= 122:
self.ta.check_letter(chr(event.key))
self.ta.check_game_state()
self.figure.guesses = len(self.ta.guessed_wrong)
elif event.type == KEYDOWN and self.ta.state != "active":
if event.key == K_RETURN or event.key == K_SPACE:
self.ta.reset_text()
self.figure.reset_figure()
if self.ta.state == "active":
self.ta.display_textarea()
elif self.ta.state == "win":
self.ta.display_win()
elif self.ta.state == "lost":
self.ta.display_lost()
self.figure.draw_figure()
pygame.display.update()
self.fps_clock.tick(self.settings.FPS)
def __init__(self):
# set title for the game window
pygame.display.set_caption("Hangman")
# clock that sets the amount of frames per second
self.fps_clock = pygame.time.Clock()
self.settings = Settings()
# create display surface on which everithing is drawn
self.DISPLAY_SURFACE = pygame.display.set_mode((self.settings.WINDOW_WIDTH,
self.settings.WINDOW_HEIGHT))
# create instance of figure class
self.figure = Figure(self.DISPLAY_SURFACE)
self.ta = TextArea(self.DISPLAY_SURFACE)
def generate_label_train_samples(c):
"""
Generate label train sample (image patches).
:param c:
:return:
"""
list_file = c.list_file
target_folder = c.labels_folder
print('generate_label_train_samples with list_file={0} and save to {1}'.format(list_file, target_folder))
input("Press Enter to continue...")
with open(list_file) as f:
lines = f.readlines()
# Remove whitespace characters, and then construct the figures
figures = [Figure(line.strip()) for line in lines]
# Clear the folder
if os.path.exists(target_folder):
shutil.rmtree(target_folder)
os.mkdir(target_folder)
for figure in figures:
print("Processing {0}".format(figure.id))
figure.load_gt_annotation(which_annotation='label')
figure.load_image()
if c.color_type == cv2.IMREAD_COLOR:
figure.crop_label_patches(is_gray=False)
else:
figure.crop_label_patches(is_gray=True)
figure.save_label_patches(target_folder)
def newTurn(self):
newFigure = Figure()
self.dropFigure()
used = self._getUsedPlaces()
for i in range(4):
if tuple(newFigure.position[i]) in used:
break
else:
self.figure = newFigure
count = 0
while self.removeFullLines():
self.linesRemoved += 1
count += 1
if count == 1:
self.scoresMsg.emit(100)
elif count == 2:
self.scoresMsg.emit(300)
elif count == 3:
self.scoresMsg.emit(600)
elif count == 4:
self.scoresMsg.emit(1000)
self.msg2statusbar.emit("Lines removed: " + str(self.linesRemoved))
return
self.gameOver()
def Solve(self, problem):
print problem.name
problem_name = problem.name
answer = -1
scores = []
if 'Problem B' in problem_name or 'Problem C' in problem_name:
print problem_name, 'skipped\n'
return answer
start_time = time.time()
# Load all figures and make them black OR white (no grey!)
print 'Loading figures for %s...' % problem_name
self.figure_a = Figure(problem.figures['A'].visualFilename)
self.figure_b = Figure(problem.figures['B'].visualFilename)
self.figure_c = Figure(problem.figures['C'].visualFilename)
self.figure_d = Figure(problem.figures['D'].visualFilename)
self.figure_e = Figure(problem.figures['E'].visualFilename)
self.figure_f = Figure(problem.figures['F'].visualFilename)
self.figure_g = Figure(problem.figures['G'].visualFilename)
self.figure_h = Figure(problem.figures['H'].visualFilename)
self.figures = [self.figure_a, self.figure_b, self.figure_c,
self.figure_d, self.figure_e, self.figure_f,
self.figure_g, self.figure_h]
print 'Identifying objects in each figure...'
for figure in self.figures:
figure.identify_objects()
figure.find_centroids()
print 'Loading all solutions and identifying the objects in each...'
self.solutions = []
problem_figure_keys = sorted(problem.figures.keys())
num_solutions = 8
for i in range(num_solutions):
figure_sol = Figure(problem.figures[problem_figure_keys[i]].visualFilename)
figure_sol.identify_objects()
figure_sol.find_centroids()
self.solutions.append(figure_sol)
print 'Searching for a solution...'
answer = self.get_solution()
print 'Time to find solution: ', time.time() - start_time, ' seconds\n'
return answer
def main(_):
splitter = PanelSplitterObjDet()
with open(FLAGS.eval_path) as f:
lines = f.readlines()
for idx, filepath in enumerate(lines):
print(str(idx) + ': ' + filepath)
filepath = filepath.strip()
figure = Figure(filepath, padding=0)
figure.load_image()
st = time.time()
panel_split(splitter, figure)
print('Elapsed time = {}'.format(time.time() - st))
# save results
figure.save_annotation(FLAGS.result_folder, 'panel')
def __init__(self, name):
app_dir = os.path.dirname(__file__)
sound_folder = 'sound'
sound_line = 'success.wav'
sound_end = 'end.wav'
self.sounds = {
'line': QSound(os.path.join(app_dir, sound_folder, sound_line)),
'end': QSound(os.path.join(app_dir, sound_folder, sound_end))
}
self.board = []
super().__init__()
self.timer = QBasicTimer()
self.speed = 390
self.normal_speed = self.speed
self.need_acceleration = False
self.need_animation = False
self.animation_sleep = False
self.animation_counter = 0
self.lines_to_remove = []
self.need_new_figure = False
self.cur_x = 0
self.cur_y = 0
self.score = 0
self.is_started = False
self.is_stopped = False
self.figure_counter = -1
self.level = 1
self.setFocusPolicy(Qt.StrongFocus)
self.clear()
self.cur_block = Figure()
self.next_block = Figure()
self.result = []
self.name = name
def init():
for x in range(0, winwidth // segsize):
for y in range(0, winheigth // segsize):
positions.append((x * segsize, panel + y * segsize))
for i in range(1, segnumber, 2):
f1, f2 = Figure.createpair()
board.insert(board.index(i), f1)
board.remove(i)
board.insert(board.index(i + 1), f2)
board.remove(i + 1)
def figure_subtract(self, fig1, fig2):
if fig1.image.size != fig2.image.size:
raise Exception('Figures must be same size to SUBTRACT them')
image = copy.deepcopy(fig1.image)
for obj2 in fig2.objects:
for xy in obj2.area:
image.putpixel(xy, 255)
return Figure(image)
def figure3(self):
# create figure object
fig = Figure(self.figurefolder,"figure3", ncols = 2, nrows = 1, figsize = [12/2.54, 7/2.54],bottom = 0.18, top=0.8)
simulationList = []
for i in range(1,7):
case = str(i)
pretext = "ICE" + case
if case in ["5", "6"]:
posttext = "8h"
def __init__(self, problem):
self.verbose = True
self.name = problem.name
self.problemType = problem.problemType
self.figures = {}
for fig in problem.figures.itervalues():
self.figures[fig.name] = Figure(fig, self.name)
self.hasVisual = problem.hasVisual
self.hasVerbal = problem.hasVerbal
self.global_objects = {}
self.set_global_objects()
self.global_objects_count = len(self.global_objects)
def figure_xor(self, fig1, fig2):
im1 = fig1.image
im2 = fig2.image
if im1.size != im2.size:
raise Exception('Images must be same size to XOR them')
size = im1.size
image = Image.new('L', size, color=255)
for x in range(size[0]):
for y in range(size[1]):
xy = x, y
if im1.getpixel(xy) != im2.getpixel(xy):
image.putpixel(xy, 0)
return Figure(image)
def figure_add(self, fig1, fig2):
if fig1.image.size != fig2.image.size:
raise Exception('Figures must be same size to SUBTRACT them')
size = fig1.image.size
image = Image.new('L', size, color=255)
for obj1 in fig1.objects:
for xy in obj1.area:
image.putpixel(xy, 0)
for obj2 in fig2.objects:
for xy in obj2.area:
image.putpixel(xy, 0)
return Figure(image)
def generate_statistics(c):
"""
Generate label statistics for deciding some parameters of the algorithm
:param c:
:return:
"""
list_file = c.list_file
print('generate_statistics with list_file={0}'.format(list_file))
input("Press Enter to continue...")
with open(list_file) as f:
lines = f.readlines()
# Remove whitespace characters, and then construct the figures
figures = [Figure(line.strip()) for line in lines]
print_progress_bar(0, len(figures), prefix='Progress:', suffix='Complete', length=50)
for i, figure in enumerate(figures):
figure.load_gt_annotation(which_annotation='label')
figure.load_image()
print_progress_bar(i + 1, len(figures), prefix='Progress:', suffix='Complete', length=50)
# Figure Image Statistics
image_width, image_height = [], []
for figure in figures:
height, width = figure.image_orig.shape[:2]
image_width.append(width)
image_height.append(height)
print('\nimage width statistics:')
print(pd.Series(image_width).describe())
print('\nimage height statistics:')
print(pd.Series(image_height).describe())
# Label Statistics
label_width, label_height = [], []
for figure in figures:
for panel in figure.panels:
width, height = panel.label_rect[2:]
label_width.append(width)
label_height.append(height)
print('\nLabel width statistics:')
print(pd.Series(label_width).describe())
print('\nLabel height statistics:')
print(pd.Series(label_height).describe())
def test_rpn_hog():
"""
HOG+RPN for panel label recognition
:return:
"""
parser = OptionParser()
parser.add_option("-p", "--path", dest="test_path", help="Path to test data.",
default='/Users/jie/projects/PanelSeg/ExpPython/eval.txt')
parser.add_option("-n", "--num_rois", type="int", dest="num_rois",
help="Number of ROIs per iteration. Higher means more memory use.", default=32)
parser.add_option("--config_filename", dest="config_filename",
help="Location to read the metadata related to the training (generated when training).",
default="config.pickle")
parser.add_option("--network", dest="network", help="Base network to use. Supports nn_cnn_3_layer.",
default='nn_cnn_3_layer')
parser.add_option("--rpn_weight_path", dest="rpn_weight_path", default='./model_rpn.hdf5')
# default='/Users/jie/projects/PanelSeg/ExpPython/models/label+bg_rpn_3_layer_color-0.0374.hdf5')
parser.add_option("--classify_model_path", dest="classify_model_path",
default='/Users/jie/projects/PanelSeg/ExpPython/models/label50+bg_cnn_3_layer_color-0.9910.h5')
parser.add_option("--result_folder", dest="result_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog/rpn_cpu_0.116')
(options, args) = parser.parse_args()
if not options.test_path: # if filename is not given
parser.error('Error: path to test data must be specified. Pass --path to command line')
rpn_c, rpn_model_rpn, rpn_model_classifier, hog = rpn_hog_initialize(options)
with open(options.test_path) as f:
lines = f.readlines()
for idx, filepath in enumerate(lines):
print(str(idx) + ': ' + filepath)
# if 'PMC3664797_gkt198f2p' not in filepath:
# continue
# if idx < 243:
# continue
filepath = filepath.strip()
figure = Figure(filepath)
figure.load_image()
st = time.time()
figure.fg_rois, figure.fg_scores, figure.fg_labels = rpn_hog_detect(figure,
rpn_c, rpn_model_rpn, rpn_model_classifier,
hog, RPN_ONLY)
print('Elapsed time = {}'.format(time.time() - st))
# Save detection results
figure.save_annotation(options.result_folder)
def generate_nonlabel_train_samples(c):
list_file = c.list_file
target_folder = c.nonlabels_folder
print('generate_nonlabel_train_samples with list_file={0} and target_folder={1}'.format(list_file, target_folder))
input("Press Enter to continue...")
with open(list_file) as f:
lines = f.readlines()
# Remove whitespace characters, and then construct the figures
figures = [Figure(line.strip()) for line in lines]
# Clear the folder
if not os.path.exists(target_folder):
os.mkdir(target_folder)
for figure in figures:
print("Processing {0}".format(figure.id))
figure.load_image()
image_height, image_width = figure.image_orig.shape[:2]
for i in range(50):
x, y, s = random.randint(-5, image_width-5), random.randint(-5, image_height-5), round(random.gauss(20, 7))
if (s < 5) or (s > 80):
continue
if (x + s - image_width > s / 2) or (0-x > s/2):
continue
if (y + s - image_height > s / 2) or (0-y > s/2):
continue
rect = (x, y, s, s)
patch_file = figure.id + "_".join(str(x) for x in rect) + ".png"
x += figure.PADDING
y += figure.PADDING
if c.color_type == cv2.IMREAD_COLOR:
patch = figure.image[y:y+s, x:x+s]
else:
patch = figure.image_gray[y:y+s, x:x+s]
# if patch.shape
patch_file = os.path.join(target_folder, patch_file)
cv2.imwrite(patch_file, patch)
def read_samples(path, auto_folder, model_classifier, model_svm):
with open(path) as f:
lines = f.readlines()
# Remove whitespace characters, and then construct the figures
figures = [Figure(line.strip()) for line in lines]
X = []
Y = []
for i, figure in enumerate(figures):
figure.load_image()
# load ground-truth annotation
gt_rois, gt_labels = load_ground_truth_annotation(figure)
# load auto annotation
auto_rois = load_auto_annotation(figure, auto_folder)
# sort auto annotation with respect to distances to left-up corner (0, 0)
distances = [roi[0] + roi[1] for roi in auto_rois]
indexes = np.argsort(distances)
auto_rois = auto_rois[indexes]
# match auto to gt to assign y
y = np.full([auto_rois.shape[0]],
len(LABEL_CLASS_MAPPING)) # initialize as non-label
for gt_i, gt_roi in enumerate(gt_rois):
ious = [iou_rect(auto_roi, gt_roi) for auto_roi in auto_rois]
max_index = np.argmax(ious)
if ious[max_index] > 0.25:
y[max_index] = LABEL_CLASS_MAPPING[map_label(gt_labels[gt_i])]
Y.append(y)
# extract features
x = feature_extraction(figure, auto_rois)
# if len(x) > 0:
# p_label, p_acc, p_val = svmutil.svm_predict(y, x.tolist(), model_svm, '-b 1')
# x = np.array(p_val)
X.append(x)
return X, Y
def main(_):
splitter = PanelSplitterObjDet()
with open(FLAGS.eval_path) as f:
lines = f.readlines()
for idx, filepath in enumerate(lines):
print(str(idx) + ': ' + filepath)
filepath = filepath.strip()
figure = Figure(filepath, padding=0)
figure.load_image()
st = time.time()
panel_split(splitter, figure)
print('Elapsed time = {}'.format(time.time() - st))
# save results
figure.save_annotation(FLAGS.result_folder, 'panel')
def addFigure(self, Figure):
for figure in self.figures:
if figure.pos == Figure.pos and figure.short == Figure.short:
#print(figure.pos, Figure,' nije uspio add')
if Figure.short == 'K' or Figure.short == 'k':
if self.board[Figure.getPos()[0]][Figure.getPos()
[1]] != Figure.short:
self.board[Figure.getPos()[0]][Figure.getPos()
[1]] = Figure.short
return None
if self.is_the_piece_on_the_board_pos(Figure.pos):
self.board[Figure.getPos()[0]][Figure.getPos()[1]] = Figure.short
self.figures.append(Figure)
#print('uspio add', Figure)
return Figure
return None
def create_figure(self, x1, y1, x2, y2, color):
figure = Figure(x1, y1, x2, y2, color, color, "figure", self.canvas)
self.figures.append(figure)
return Figure(image)
def figure_subtract(fig1, fig2):
if fig1.image.size != fig2.image.size:
raise Exception('Figures must be same size to SUBTRACT them')
image = copy.deepcopy(fig1.image)
for obj2 in fig2.objects:
for xy in obj2.area:
image.putpixel(xy, 255)
return Figure(image)
fig_e10_a = Figure("E-10-A.png")
fig_e10_b = Figure("E-10-B.png")
print 'Identifying objects...'
fig_e10_a.identify_objects()
fig_e10_b.identify_objects()
print 'Doing the maths...'
figure_and(fig_e10_a, fig_e10_b)
figure_xor(fig_e10_a, fig_e10_b)
figure_add(fig_e10_b, fig_e10_a)
figure_subtract(fig_e10_b, fig_e10_a)
print 'Done\n'
def augment(img_data, config, augment=True):
assert 'filepath' in img_data
assert 'bboxes' in img_data
assert 'width' in img_data
assert 'height' in img_data
img_data_aug = copy.deepcopy(img_data)
figure = Figure(img_data_aug['filepath'])
figure.load_image()
# img = cv2.imread(img_data_aug['filepath'])
img = figure.image
if augment:
rows, cols = img.shape[:2]
if config.use_horizontal_flips and np.random.randint(0, 2) == 0:
img = cv2.flip(img, 1)
for bbox in img_data_aug['bboxes']:
x1 = bbox['x1']
x2 = bbox['x2']
bbox['x2'] = cols - x1
bbox['x1'] = cols - x2
if config.use_vertical_flips and np.random.randint(0, 2) == 0:
img = cv2.flip(img, 0)
for bbox in img_data_aug['bboxes']:
y1 = bbox['y1']
y2 = bbox['y2']
bbox['y2'] = rows - y1
bbox['y1'] = rows - y2
if config.rot_90:
angle = np.random.choice([0,90,180,270],1)[0]
if angle == 270:
img = np.transpose(img, (1,0,2))
img = cv2.flip(img, 0)
elif angle == 180:
img = cv2.flip(img, -1)
elif angle == 90:
img = np.transpose(img, (1,0,2))
img = cv2.flip(img, 1)
elif angle == 0:
pass
for bbox in img_data_aug['bboxes']:
x1 = bbox['x1']
x2 = bbox['x2']
y1 = bbox['y1']
y2 = bbox['y2']
if angle == 270:
bbox['x1'] = y1
bbox['x2'] = y2
bbox['y1'] = cols - x2
bbox['y2'] = cols - x1
elif angle == 180:
bbox['x2'] = cols - x1
bbox['x1'] = cols - x2
bbox['y2'] = rows - y1
bbox['y1'] = rows - y2
elif angle == 90:
bbox['x1'] = rows - y2
bbox['x2'] = rows - y1
bbox['y1'] = x1
bbox['y2'] = x2
elif angle == 0:
pass
img_data_aug['width'] = img.shape[1]
img_data_aug['height'] = img.shape[0]
return img_data_aug, img
def get_solution(self):
answer = -1
# *** REAL CODE ***
# Check for holistic symmetry
vertical_symmetry_measures = []
horizontal_symmetry_measures = []
for solution in self.solutions:
self.figure_sol = solution
holistic_image = self.create_merged_image()
vertical_symmetry_measures.append(
self.get_vertical_symmetry_measure(holistic_image))
horizontal_symmetry_measures.append(
self.get_horizontal_symmetry_measure(holistic_image))
# Check vertical
max_measure = max(vertical_symmetry_measures)
if max_measure > self.threshold:
return vertical_symmetry_measures.index(max_measure) + 1
# Check horizontal
max_measure = max(horizontal_symmetry_measures)
if max_measure > self.threshold:
return horizontal_symmetry_measures.index(max_measure) + 1
# Horizontal transforms alone have been sufficient for the practice problems encountered
transform = self.get_transform(self.figure_a, self.figure_b,
self.figure_c)
# These values used later on
self.figure_g.identify_objects()
self.figure_g.find_centroids()
self.figure_h.identify_objects()
self.figure_h.find_centroids()
if transform[0] == 'resize':
# if at this point, only 2 objects in figure
# Get size of object in question and get scale factor from transform data
obj = self.figure_h.objects[1]
width_obj, height_obj = obj.size()
width_trans, height_trans = transform[1]
scale = (1 + width_trans / float(width_obj),
1 + height_trans / float(height_obj))
im = self.figure_h.image
width, height = im.size
im_resized = im.resize(
(int(width * scale[0]), int(height * scale[1])),
Image.BILINEAR)
width_new, height_new = im_resized.size
width_diff = width_new - width
height_diff = height_new - height
box = (width_diff / 2, height_diff / 2, width_new - width_diff / 2,
height_new - height_diff / 2)
fig = Figure(im_resized.crop(box))
answer = self.find_most_similar_solution(fig)
elif transform[0] == 'add and translate':
translate_distance = transform[1]
obj1 = self.figure_g.objects[1]
size = self.figure_g.image.size
init_l_val = 255
obj1_new = Object((0, 0), 0)
obj2_new = Object((0, 0), 0)
obj1_new.remove_pixel((0, 0))
obj2_new.remove_pixel((0, 0))
# Slide first two objects away from each other
for coord in obj1.area:
obj1_new.add_pixel(
(coord[0] + translate_distance * 2, coord[1]))
obj2_new.add_pixel(
(coord[0] - translate_distance * 2, coord[1]))
# Make new image with translated objects
image_new = Image.new('L', size, color=init_l_val)
for xy in obj1_new.area:
image_new.putpixel(xy, 0)
for xy in obj2_new.area:
image_new.putpixel(xy, 0)
for xy in obj1.area:
image_new.putpixel(xy, 0)
fig = Figure(image_new)
answer = self.find_most_similar_solution(fig)
elif transform[0] == 'horizontal pass through':
for solution in self.solutions:
solution.identify_objects()
num_dark_obj = 0
for obj in solution.objects:
if obj.l_val < 128:
num_dark_obj += 1
if num_dark_obj < 2:
continue
size = solution.image.size
im_centroid = (size[0] / 2, size[1] / 2)
max_distance = size[0] / 2
for i in xrange(2, max_distance, 2):
objects_new = []
for obj in solution.objects:
if obj.l_val < 128:
# On the left side
if obj.centroid[0] < im_centroid[0]:
obj_new = self.translate_object(obj, (i, 0))
# On the right side
else:
obj_new = self.translate_object(obj, (-i, 0))
objects_new.append(obj_new)
image_new = self.image_from_objects(size, objects_new)
if self.is_equal(image_new, solution.image):
answer = self.solutions.index(solution) + 1
return answer
return answer
def test_lstm():
parser = OptionParser()
parser.add_option("--eval_path", dest="eval_path", help="Path to eval data.",
default='/Users/jie/projects/PanelSeg/ExpPython/eval.txt')
parser.add_option("--eval_auto_folder", dest="eval_auto_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog/rpn')
parser.add_option("--classify_model_path", dest="classify_model_path",
default='/Users/jie/projects/PanelSeg/ExpPython/models/label50+bg_cnn_3_layer_color-0.9910.h5')
# parser.add_option("--svm_model_path", dest="svm_model_path",
# default='/Users/jie/projects/PanelSeg/Exp/LabelClassifySvmTrain/SVMModel-51classes-with-neg/svm_model_rbf_8.0_0.125')
parser.add_option("--lstm_model_path", dest="lstm_model_path",
default='/Users/jie/projects/PanelSeg/ExpPython/models/lstm_model_train_0.25eval_epoch_9.h5')
parser.add_option("--result_folder", dest="result_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog_lstm/eval')
(options, args) = parser.parse_args()
# model_classifier = load_model(options.classify_model_path)
# model_classifier.summary()
# model_svm = svmutil.svm_load_model(options.svm_model_path)
model_svm = None
model_lstm = load_model(options.lstm_model_path)
model_lstm.summary()
with open(options.eval_path) as f:
lines = f.readlines()
for idx, filepath in enumerate(lines):
print(str(idx) + ': ' + filepath)
# if '1757-1626-0002-0000008402-001' not in filepath:
# continue
# if idx < 37:
# continue
filepath = filepath.strip()
figure = Figure(filepath)
figure.load_image()
st = time.time()
# load detection results by RPN
rois = load_auto_annotation(figure, options.eval_auto_folder)
# sort auto annotation with respect to distances to left-up corner (0, 0)
distances = [roi[0] + roi[1] for roi in rois]
indexes = np.argsort(distances)
rois = rois[indexes]
x = feature_extraction(figure, rois)
if rois.size == 0:
figure.fg_rois, figure.fg_scores, figure.fg_labels = None, None, None
else:
# x = x.tolist()
# y = np.zeros(len(x)).tolist()
# p_label, p_acc, p_val = svmutil.svm_predict(y, x, model_svm, '-b 1')
# x = np.array(p_val)
_x = np.expand_dims(x, axis=0)
y_hat = model_lstm.predict(_x)
# figure.fg_rois, figure.fg_scores, figure.fg_labels = max_y_hat(rois, y_hat[0])
figure.fg_rois, figure.fg_scores, figure.fg_labels = beam_search_with_neg(rois, y_hat[0], 5)
print('Elapsed time = {}'.format(time.time() - st))
# Save detection results
figure.save_annotation(options.result_folder)
def plot4Sets(caseCollection,
simulationCollection,
annotationCollection,
simulationDataFrames,
figurefolder,
figurename,
ncVariable,
designVariable,
conversionNC=1.0,
conversionDesign=1.0,
xmax=1000,
ymax=1000,
xAxisLabel=None,
xAxisUnit=None,
yAxisLabel=None,
yAxisUnit=None,
keisseja=10000,
yPositionCorrection=100,
outlierParameter=0.2):
relativeChangeDict = Data.emptyDictionaryWithKeys(caseCollection)
print(" ")
print(figurename)
# create figure object
fig = Figure(figurefolder,
figurename,
ncols=2,
nrows=2,
sharex=True,
sharey=True)
# plot timeseries with unit conversion
maks = 0
mini = 0
for ind, case in enumerate(caseCollection):
for emul in list(simulationCollection[case])[:keisseja]:
dataset = simulationCollection[case][emul].getTSDataset()
muuttuja = dataset[ncVariable]
alku = simulationDataFrames[case].loc[emul][
designVariable] * conversionDesign
loppu = muuttuja.sel(
time=slice(2.5, 3.5)).mean().values * conversionNC
relChangeParam = loppu / alku
relativeChangeDict[case][emul] = relChangeParam
if relChangeParam > 1 + outlierParameter:
color = Colorful.getDistinctColorList("red")
zorderParam = 10
elif relChangeParam < 1 - outlierParameter:
color = Colorful.getDistinctColorList("blue")
zorderParam = 9
else:
color = "white"
zorderParam = 6
maks = max(relChangeParam, maks)
mini = min(relChangeParam, mini)
fig.getAxes(True)[ind].plot(alku,
loppu,
marker="o",
markerfacecolor=color,
markeredgecolor="black",
markeredgewidth=0.2,
markersize=6,
alpha=0.5,
zorder=zorderParam)
yPositionCorrection=300)
simulationDataFrames = mergeDataFrameWithParam(simulationDataFrames,
cloudTopParameters,
"zcRel")
cloudTopFig.save()
if cloudTopOutliersFlag:
cloutTopOutliers = {}
for ind, case in enumerate(list(simulationDataFrames)):
cloudTopOutliers[case] = simulationDataFrames[case].where(
simulationDataFrames[case]["zcRel"] <
simulationDataFrames[case]["zcRel"])
fig2 = Figure(figurefolder,
"cloudtopOutliers",
ncols=2,
nrows=2,
sharex=True,
sharey=True)
# plot timeseries with unit conversion
cloudTopOutliersColors = Colorful.getIndyColorList(
len(cloudTopOutliers))
for ind, case in enumerate(caseCollection):
for emulInd, emul in enumerate(cloudTopOutliers):
try:
simulation = simulationCollection[case][emul]
except KeyError:
continue
dataset = simulation.getTSDataset()
muuttuja = dataset["zc"][1:] / (
simulationDataFrames[case].loc[emul]["pblh_m"])
def test_lstm():
parser = OptionParser()
parser.add_option(
"--eval_path",
dest="eval_path",
help="Path to eval data.",
default='/Users/jie/projects/PanelSeg/ExpPython/eval.txt')
parser.add_option(
"--eval_auto_folder",
dest="eval_auto_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog/rpn')
parser.add_option(
"--classify_model_path",
dest="classify_model_path",
default=
'/Users/jie/projects/PanelSeg/ExpPython/models/label50+bg_cnn_3_layer_color-0.9910.h5'
)
# parser.add_option("--svm_model_path", dest="svm_model_path",
# default='/Users/jie/projects/PanelSeg/Exp/LabelClassifySvmTrain/SVMModel-51classes-with-neg/svm_model_rbf_8.0_0.125')
parser.add_option(
"--lstm_model_path",
dest="lstm_model_path",
default=
'/Users/jie/projects/PanelSeg/ExpPython/models/lstm_model_train_0.25eval_epoch_9.h5'
)
parser.add_option(
"--result_folder",
dest="result_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog_lstm/eval'
)
(options, args) = parser.parse_args()
# model_classifier = load_model(options.classify_model_path)
# model_classifier.summary()
# model_svm = svmutil.svm_load_model(options.svm_model_path)
model_svm = None
model_lstm = load_model(options.lstm_model_path)
model_lstm.summary()
with open(options.eval_path) as f:
lines = f.readlines()
for idx, filepath in enumerate(lines):
print(str(idx) + ': ' + filepath)
# if '1757-1626-0002-0000008402-001' not in filepath:
# continue
# if idx < 37:
# continue
filepath = filepath.strip()
figure = Figure(filepath)
figure.load_image()
st = time.time()
# load detection results by RPN
rois = load_auto_annotation(figure, options.eval_auto_folder)
# sort auto annotation with respect to distances to left-up corner (0, 0)
distances = [roi[0] + roi[1] for roi in rois]
indexes = np.argsort(distances)
rois = rois[indexes]
x = feature_extraction(figure, rois)
if rois.size == 0:
figure.fg_rois, figure.fg_scores, figure.fg_labels = None, None, None
else:
# x = x.tolist()
# y = np.zeros(len(x)).tolist()
# p_label, p_acc, p_val = svmutil.svm_predict(y, x, model_svm, '-b 1')
# x = np.array(p_val)
_x = np.expand_dims(x, axis=0)
y_hat = model_lstm.predict(_x)
# figure.fg_rois, figure.fg_scores, figure.fg_labels = max_y_hat(rois, y_hat[0])
figure.fg_rois, figure.fg_scores, figure.fg_labels = beam_search_with_neg(
rois, y_hat[0], 5)
print('Elapsed time = {}'.format(time.time() - st))
# Save detection results
figure.save_annotation(options.result_folder)
def getIce4Simulations(self):
return self.ice4simulations
def getAllSimulations(self):
return self.allSimulations
def getUCLALESSALSASimulations(self):
return self.uclalesSimulations
figObject = ManuscriptFigures(
"/home/aholaj/Nextcloud/figures_updated/manuscriptSimulationData_Rad.csv",
os.environ["SIMULATIONFIGUREFOLDER"])
fig = Figure(figObject.figurefolder, "figure2RAD", ncols=2, nrows=3)
simulationList = FigureRadSimulationList()
for k in simulationList.getAllSimulations():
try:
figObject.simulationCollection[k].getTSDataset()
figObject.simulationCollection[k].setTimeCoordToHours()
except FileNotFoundError:
if "ovchinnikov" in str(
figObject.simulationCollection[k].getFolder()).lower():
print(
"Ovchinnikov data is not available. Continue with existingsimulations"
)
continue
else:
def combine_hog_rpn():
"""
Load results from HOG and RPN methods and then combine them
:return:
"""
parser = OptionParser()
parser.add_option("-p", "--path", dest="test_path", help="Path to test data.",
default='/Users/jie/projects/PanelSeg/ExpPython/eval.txt')
parser.add_option("--hog_folder", dest="hog_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog/hog')
parser.add_option("--rpn_folder", dest="rpn_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog/rpn_cpu_0.0374')
parser.add_option("--result_folder", dest="result_folder",
default='/Users/jie/projects/PanelSeg/ExpPython/eval/rpn_hog/hog_rpn')
(options, args) = parser.parse_args()
with open(options.test_path) as f:
lines = f.readlines()
for idx, filepath in enumerate(lines):
print(str(idx) + ': ' + filepath)
# if 'PMC3664797_gkt198f2p' not in filepath:
# continue
# if idx < 243:
# continue
filepath = filepath.strip()
figure = Figure(filepath)
figure.load_image()
# Load HOG result
hog_file_path = os.path.join(options.hog_folder, figure.file).replace('.jpg', '_data.xml')
figure.load_annotation(hog_file_path)
hog_rois = np.empty([len(figure.panels), 4], dtype=int)
for i in range(len(figure.panels)):
hog_rois[i] = figure.panels[i].label_rect
hog_rois[:, 0] += Figure.PADDING
hog_rois[:, 1] += Figure.PADDING
hog_labels = np.full(hog_rois.shape[0], Panel.LABEL_ALL)
hog_scores = np.full(hog_rois.shape[0], 1.0)
# Load RPN result
rpn_file_path = os.path.join(options.rpn_folder, figure.file).replace('.jpg', '_data.xml')
figure.load_annotation(rpn_file_path)
rpn_rois = np.empty([len(figure.panels), 4], dtype=int)
for i in range(len(figure.panels)):
rpn_rois[i] = figure.panels[i].label_rect
rpn_rois[:, 0] += Figure.PADDING
rpn_rois[:, 1] += Figure.PADDING
rpn_labels = np.full(rpn_rois.shape[0], Panel.LABEL_ALL)
rpn_scores = np.full(rpn_rois.shape[0], 1.0)
# Keep all regions detected by both RPN and HOG methods.
# rois, scores, labels = rpn_hog_combine_all(hog_rois, hog_scores, hog_labels, rpn_rois, rpn_scores, rpn_labels)
# Keep only regions agreed by both methods. IOU > 25%
rois, scores, labels = rpn_hog_combine_agreed(hog_rois, hog_scores, hog_labels,
rpn_rois, rpn_scores, rpn_labels, 0.125)
figure.fg_rois, figure.fg_scores, figure.fg_labels = rois, scores, labels
# Save detection results
figure.save_annotation(options.result_folder)
def __init__(self, position, white):
Figure.__init__(self,position)
if( white ):
self.white = True
else:
self.white = False
def load_samples(path):
with open(path) as f:
lines = f.readlines()
# Remove whitespace characters, and then construct the figures
figures = [Figure(line.strip()) for line in lines]
return figures
