def stage3_extract_plant_parts(**args):
'''
Extract out possible plant parts to be clustered in next stage.
args should match the names and descriptions of command line parameters,
but unlike command line, all arguments must be present.
'''
# Copy args so we can archive them to a file when function is finished.
args_copy = args.copy()
# Convert arguments to local variables of the correct type.
input_filepath = args.pop('input_filepath')
out_directory = args.pop('output_directory')
pad = float(args.pop('pad'))
special_pad = float(args.pop('special_pad'))
min_leaf_size = float(args.pop('min_leaf_size'))
max_leaf_size = float(args.pop('max_leaf_size'))
min_stick_part_size = float(args.pop('min_stick_part_size'))
max_stick_part_size = float(args.pop('max_stick_part_size'))
min_tag_size = float(args.pop('min_tag_size'))
max_tag_size = float(args.pop('max_tag_size'))
disable_sticks = args.pop('disable_sticks').lower() == 'true'
disable_tags = args.pop('disable_tags').lower() == 'true'
use_marked_image = args.pop('marked_image').lower() == 'true'
debug_start = args.pop('debug_start')
debug_stop = args.pop('debug_stop')
if len(args) > 0:
print "Unexpected arguments provided: {}".format(args)
return ExitReason.bad_arguments
rows, geo_images = unpickle_stage2_output(input_filepath)
if len(rows) == 0 or len(geo_images) == 0:
print "No rows or no geo images could be loaded from {}".format(input_filepath)
return ExitReason.no_rows
ImageWriter.level = ImageWriter.NORMAL
# Write images out to subdirectory to keep separated from pickled results.
image_out_directory = os.path.join(out_directory, 'images/')
if not os.path.exists(image_out_directory):
os.makedirs(image_out_directory)
rows = sorted(rows, key=lambda r: r.number)
# Sort geo images so they're processed by time.
geo_images = sorted(geo_images, key=lambda img: img.image_time)
# Look for start/stop filenames so user doesn't have to process all images.
start_geo_index, stop_geo_index = get_subset_of_geo_images(geo_images, debug_start, debug_stop)
print "Processing geo images {} through {}".format(start_geo_index, stop_geo_index)
geo_images = geo_images[start_geo_index : stop_geo_index+1]
num_images_not_in_segment = 0
num_images_without_path = 0
leaf_finder = LeafFinder(min_leaf_size, max_leaf_size)
if disable_sticks:
stick_finder = None
else:
stick_finder = BlueStickFinder(min_stick_part_size, max_stick_part_size)
if disable_tags:
tag_finder = None
else:
tag_finder = TagFinder(min_tag_size, max_tag_size)
all_segments = all_segments_from_rows(rows)
for segment in all_segments:
if segment.is_special:
segment.lrud = calculate_special_segment_lrud(segment, special_pad)
else:
segment.lrud = calculate_segment_lrud(segment, pad)
num_matched = [] # keep track of how many segments each image maps to.
num_leaves = [] # how many leaves are in each processed image
num_sticks = [] # how many sticks are in each processed images
num_tags = [] # how many tags are in each processed images
for k, geo_image in enumerate(geo_images):
if not geo_image.file_path:
num_images_without_path += 1
continue
# Check if image east/west/north/south (lrud) overlaps with any segments.
image_lrud = calculate_image_lrud(geo_image)
overlapping_segments = [seg for seg in all_segments if is_overlapping_segment(image_lrud, seg)]
if len(overlapping_segments) == 0:
num_images_not_in_segment += 1
continue
print "{} [{} / {}]".format(geo_image.file_name, k, len(geo_images))
leaves, sticks, tags = process_geo_image_to_find_plant_parts(geo_image, leaf_finder, stick_finder, tag_finder, image_out_directory, use_marked_image)
# Remove any false positive items that came from codes.
geo_codes = geo_image.items['codes']
leaves = dont_overlap_with_items(geo_codes, leaves)
sticks = dont_overlap_with_items(geo_codes, sticks)
tags = dont_overlap_with_items(geo_codes, tags)
geo_image.items['leaves'] = leaves
geo_image.items['stick_parts'] = sticks
geo_image.items['tags'] = tags
print "Found {} leaves, {} stick parts and {} tags".format(len(leaves), len(sticks), len(tags))
for segment in overlapping_segments:
segment.geo_images.append(geo_image)
num_matched.append(len(overlapping_segments))
num_leaves.append(len(leaves))
num_sticks.append(len(sticks))
num_tags.append(len(tags))
print "\nProcessed {}".format(len(num_matched))
print "Not in segment {}".format(num_images_not_in_segment)
print "Invalid path {}".format(num_images_without_path)
print "Matched images were in average of {} segments".format(np.mean(num_matched))
print "Average of {} leaves, {} stick parts and {} tags per image".format(np.mean(num_leaves), np.mean(num_sticks), np.mean(num_tags))
if not os.path.exists(out_directory):
os.makedirs(out_directory)
# Pickle
dump_filename = "stage3_output.s3"
print "\nSerializing {} rows to {}".format(len(rows), dump_filename)
pickle_results(dump_filename, out_directory, rows)
# Write arguments out to file for archiving purposes.
write_args_to_file("stage3_args.csv", out_directory, args_copy)
def stage1_extract_codes(**args):
'''
Extract codes from set of images and write out results to file.
args should match the names and descriptions of command line parameters,
but unlike command line, all arguments must be present.
'''
# Copy args so we can archive them to a file when function is finished.
args_copy = args.copy()
# Convert arguments to local variables of the correct type.
image_directory = args.pop('image_directory')
image_geo_file = args.pop('image_geo_file')
out_directory = args.pop('output_directory')
postfix_id = args.pop('postfix_id')
code_min_size = float(args.pop('code_min_size'))
code_max_size = float(args.pop('code_max_size'))
provided_resolution = float(args.pop('resolution'))
camera_height = float(args.pop('camera_height'))
use_marked_image = args.pop('marked_image').lower() == 'true'
debug_start = args.pop('debug_start')
debug_stop = args.pop('debug_stop')
if len(args) > 0:
print "Unexpected arguments provided: {}".format(args)
return ExitReason.bad_arguments
if code_max_size <= 0 or code_min_size <= 0:
print "\nError: code sizes must be greater than zero.\n"
return ExitReason.bad_arguments
if code_max_size <= code_min_size:
print "\nError: Max code size must be greater than min.\n"
return ExitReason.bad_arguments
if provided_resolution <= 0:
print "\nError: Resolution must be greater than zero."
return ExitReason.bad_arguments
if camera_height <= 0:
print "\nError: Specified camera height must be greater than zero."
return ExitReason.bad_arguments
image_filenames = list_images(image_directory, ['tiff', 'tif', 'jpg', 'jpeg', 'png'])
if len(image_filenames) == 0:
print "No images found in directory: {}".format(image_directory)
return ExitReason.no_images
print "\nFound {} images to process".format(len(image_filenames))
geo_images = parse_geo_file(image_geo_file, provided_resolution, camera_height)
print "Parsed {} geo images".format(len(geo_images))
if len(geo_images) == 0:
print "No geo images. Exiting."
return ExitReason.no_geo_images
# Look for start/stop filenames so user doesn't have to process all images.
start_geo_index, stop_geo_index = get_subset_of_geo_images(geo_images, debug_start, debug_stop)
print "Processing geo images {} through {}".format(start_geo_index, stop_geo_index)
geo_images = geo_images[start_geo_index : stop_geo_index+1]
print "Sorting images by timestamp."
geo_images = sorted(geo_images, key=lambda image: image.image_time)
geo_images, missing_image_count = verify_geo_images(geo_images, image_filenames)
if missing_image_count > 0:
print "Warning {} geo images do not exist and will be skipped.".format(missing_image_count)
if len(geo_images) == 0:
print "No images match up with any geo images. Exiting."
return ExitReason.no_geo_images
missed_code_finder = MissedCodeFinder()
code_finder = CodeFinder(code_min_size, code_max_size, missed_code_finder)
ImageWriter.level = ImageWriter.NORMAL
# Write images out to subdirectory to keep separated from pickled results.
image_out_directory = os.path.join(out_directory, 'images/')
if not os.path.exists(image_out_directory):
os.makedirs(image_out_directory)
# Find and extract all codes from images.
codes = []
try:
for i, geo_image in enumerate(geo_images):
print "Analyzing image {} [{}/{}]".format(geo_image.file_name, i+1, len(geo_images))
newly_found_codes = process_geo_image(geo_image, [code_finder], image_directory, image_out_directory, use_marked_image)
geo_image.items["codes"] = newly_found_codes
for code in newly_found_codes:
print "Found {}: {}".format(code.type, code.name)
codes += newly_found_codes
except KeyboardInterrupt:
print "\nKeyboard interrupt detected."
answer = raw_input("\nType y to save results or anything else to quit: ").strip()
if answer.lower() != 'y':
return ExitReason.user_interrupt
# Write possibly missed codes out to separate directory
missed_codes_out_directory = os.path.join(out_directory, 'missed_codes_{}/'.format(postfix_id))
if not os.path.exists(missed_codes_out_directory):
os.makedirs(missed_codes_out_directory)
print "Writing out missed codes"
missed_code_filename = "missed_codes_{}.txt".format(postfix_id)
missed_code_finder.write_out_missed_codes(codes, missed_code_filename, missed_codes_out_directory)
dump_filename = "stage1_output_{}_{}_{}.s1".format(postfix_id, int(geo_images[0].image_time), int(geo_image.image_time))
print "Serializing {} geo images and {} codes to {}.".format(len(geo_images), len(codes), dump_filename)
pickle_results(dump_filename, out_directory, geo_images, codes)
# Display code stats for user.
merged_codes = merge_items(codes, max_distance=500)
if len(merged_codes) == 0:
print "No codes found."
else:
print "There were {} codes found and {} were unique. Average code is in {} images.".format(len(codes), len(merged_codes), float(len(codes)) / len(merged_codes))
print "Merged codes not being saved. Just for user information."
# Write arguments out to file for archiving purposes.
args_filename = "stage1_args_{}_{}_{}.csv".format(postfix_id, int(geo_images[0].image_time), int(geo_image.image_time))
write_args_to_file(args_filename, out_directory, args_copy)
return ExitReason.success
