def print_R_script(scene, tree, classifier, step_size):
print "# " + scene.filename + "\n"
# Some R functions for plotting.
print "library(scales)" # for alpha blending
rtools.print_plot_focus_measures(scene.fvalues)
# The correct classifications.
classes = [ "left" if classifier(scene, lens_pos) else "right"
for lens_pos in range(2 * step_size, scene.step_count) ]
# What we actually get.
results = []
for lens_pos in range(2 * step_size, scene.step_count):
initial_positions = featuresfirststep.first_three_lens_pos(
lens_pos, step_size)
first, second, third = scene.get_focus_values(initial_positions)
norm_lens_pos = float(lens_pos) / (scene.step_count - 1)
evaluator = featuresfirststep.firststep_feature_evaluator(
first, second, third, norm_lens_pos)
evaluation = evaluatetree.evaluate_tree(tree, evaluator)
results.append(evaluation)
rtools.print_classification_points(classes, results, ["left", "right"])
print "# Plot me!\n"
def _get_first_direction(self):
"""Direction in which we should start sweeping initially."""
first, second, third = self.camera.get_fvalues(
self.camera.visited_positions[-3:])
norm_lens_pos = float(self.initial_pos) / (self.scene.step_count - 1)
evaluator = featuresfirststep.firststep_feature_evaluator(
first, second, third, norm_lens_pos)
return Direction(evaluatetree.evaluate_tree(
self.params.left_right_tree, evaluator))
def print_R_script(scene, tree, step_size):
print "# " + scene.filename + "\n"
# Some R functions for plotting.
print "library(scales)" # for alpha blending
rtools.print_plot_focus_measures(scene.fvalues)
classes = []
results = []
for lens_pos in range(2 * step_size, scene.step_count):
# The correct classification.
go_left = featuresfirststep.nearest_on_left(scene, lens_pos)
initial_positions = featuresfirststep.first_three_lens_pos(
lens_pos, step_size)
if go_left:
initial_positions.reverse()
last_pos = initial_positions[-1]
if scene.distance_to_closest_left_peak(last_pos) <= 15:
classes.append("fine")
else:
classes.append("coarse")
else:
last_pos = initial_positions[-1]
if scene.distance_to_closest_right_peak(last_pos) <= 15:
classes.append("fine")
else:
classes.append("coarse")
# The classification obtained by evaluating the decision tree.
first, second, third = scene.get_focus_values(initial_positions)
norm_lens_pos = float(lens_pos) / (scene.step_count - 1)
evaluator = featuresfirststep.firststep_feature_evaluator(
first, second, third, norm_lens_pos)
evaluation = evaluatetree.evaluate_tree(tree, evaluator)
results.append(evaluation)
rtools.print_classification_points(classes, results, ["coarse", "fine"])
print "# Plot me!\n"
def _sweep(self, direction):
"""Sweep the lens in one direction and return a
tuple (success state, number of steps taken) along the way.
"""
initial_position = self.camera.last_position()
sweep_fvalues = [ self.camera.last_fmeasure() ]
while not self.camera.will_hit_edge(direction):
# Move the lens forward.
self.camera.move_coarse(direction)
sweep_fvalues.append(self.camera.last_fmeasure())
# Take at least two steps before we allow turning back.
if len(sweep_fvalues) < 3:
continue
if self.perfect_classification is None:
# Obtain the ML classification at the new lens position.
evaluator = featuresturn.action_feature_evaluator(
sweep_fvalues, self.scene.step_count)
classification = evaluatetree.evaluate_tree(
self.params.action_tree, evaluator)
else:
key = featuresturn.make_key(str(direction), initial_position,
self.camera.last_position())
classification = self.perfect_classification[key]
if classification != "continue":
assert (classification == "turn_peak" or
classification == "backtrack")
return classification, len(sweep_fvalues) - 1
# We've reached an edge, but the decision tree still does not want
# to turn back, so what do we do now?
# After thinking a lot about it, I think the best thing to do is to
# introduce a condition manually. It's a bit ad-hoc, but we really need
# to be able to handle this case robustly, as there are lot of cases
# (i.e., landscape shots) where peaks will be at the edge.
min_val = min(self.camera.get_fvalues(self.camera.visited_positions))
max_val = max(self.camera.get_fvalues(self.camera.visited_positions))
if float(min_val) / max_val > 0.8:
return "backtrack", len(sweep_fvalues) - 1
else:
return "turn_peak", len(sweep_fvalues) - 1
