def generate_points(img, usesourcemethod=True): """ Generate annotation points for the Image img, and delete any points that had previously existed. Does nothing if the image already has human annotations, because we don't want to delete any human work. """ # If there are any human annotations for this image, # abort point generation. human_annotations = Annotation.objects.filter(image = img).exclude(user = get_robot_user()).exclude(user = get_alleviate_user()) if human_annotations: return # Find the annotation area, expressed in pixels. d = AnnotationAreaUtils.db_format_to_numbers(img.metadata.annotation_area) annoarea_type = d.pop('type') if annoarea_type == AnnotationAreaUtils.TYPE_PERCENTAGES: annoarea_dict = AnnotationAreaUtils.percentages_to_pixels(width=img.original_width, height=img.original_height, **d) elif annoarea_type == AnnotationAreaUtils.TYPE_PIXELS: annoarea_dict = d else: raise ValueError("Can't generate points with annotation area type '{0}'.".format(annoarea_type)) # Calculate points. if usesourcemethod: point_gen_method = img.source.default_point_generation_method else: point_gen_method = img.point_generation_method new_points = calculate_points( img, annotation_area=annoarea_dict, **PointGen.db_to_args_format(point_gen_method) ) # Delete old points for this image, if any. old_points = Point.objects.filter(image=img) for old_point in old_points: old_point.delete() # Save the newly calculated points. for new_point in new_points: Point(row=new_point['row'], column=new_point['column'], point_number=new_point['point_number'], image=img, ).save() # Update image status. # Make sure the image goes through the feature-making step again. status = img.status status.hasRandomPoints = True status.save()
def pointgen_check(self, image_id): """ Check that an image had annotation points generated as specified in the point generation method field. :param image_id: The id of the image to check. """ img = Image.objects.get(pk=image_id) img_width = img.original_width img_height = img.original_height pointgen_args = PointGen.db_to_args_format(img.point_generation_method) points = Point.objects.filter(image=img) self.assertEqual(points.count(), pointgen_args['simple_number_of_points']) # Find the expected annotation area, expressed in pixels. d = AnnotationAreaUtils.db_format_to_numbers(img.metadata.annotation_area) annoarea_type = d.pop('type') if annoarea_type == AnnotationAreaUtils.TYPE_PERCENTAGES: area = AnnotationAreaUtils.percentages_to_pixels(width=img_width, height=img_height, **d) elif annoarea_type == AnnotationAreaUtils.TYPE_PIXELS: area = d elif annoarea_type == AnnotationAreaUtils.TYPE_IMPORTED: area = dict(min_x=1, max_x=img_width, min_y=1, max_y=img_height) else: raise ValueError("Unknown annotation area type.") if settings.UNIT_TEST_VERBOSITY >= 1: print "{pointgen_method}".format( pointgen_method=img.point_gen_method_display(), ) print "{annotation_area}".format( annotation_area=img.annotation_area_display(), ) print "Image dimensions: {width} x {height} pixels".format( width=img_width, height=img_height, ) print "X bounds: ({min_x}, {max_x}) Y bounds: ({min_y}, {max_y})".format( **area ) for pt in points: self.assertTrue(area['min_x'] <= pt.column) self.assertTrue(pt.column <= area['max_x']) self.assertTrue(area['min_y'] <= pt.row) self.assertTrue(pt.row <= area['max_y']) if settings.UNIT_TEST_VERBOSITY >= 1: print "({col}, {row})".format(col=pt.column, row=pt.row)
def __init__(self, *args, **kwargs): """ Dynamically generate help text. """ source = kwargs.pop('source') super(ImageUploadOptionsForm, self).__init__(*args, **kwargs) # Dynamically generate help text. # Show the filename format that should be used, # and an example of a filename adhering to that format. filenameFormatArgs = dict(year='YYYY', month='MM', day='DD') filenameExampleArgs = dict(year='2010', month='08', day='23') sourceKeys = source.get_key_list() exampleSuffixes = ['A', ' 7', ' 2-2', 'C', '1'][0 : len(sourceKeys)] filenameFormatArgs['values'] = sourceKeys filenameExampleArgs['values'] = [a+b for a,b in zip(sourceKeys, exampleSuffixes)] filenameFormatStr = metadata_to_filename(**filenameFormatArgs) filenameExampleStr = metadata_to_filename(**filenameExampleArgs) + ".jpg" self.fields['specify_metadata'].help_text = \ "Required filename format: %s" % filenameFormatStr # Use JavaScript to show/hide this additional help text self.metadata_extra_help_text = ( "\n" "For example, let's say your source has the following location keys: " "Site, Depth, Transect Line and Quadrant. " "If you want to upload a .jpg image that was taken at " "Site: sharkPoint, Depth: 10m, Transect Line: 3, and Quadrant: qu4, " "on 14 January 2010, the filename for upload should be:\n\n" "sharkPoint_10m_3_qu4_2010-01-14.jpg\n\n" "Alternatively, if you also want to store the original filename - say it's " "IMG_0032.jpg - you can use:\n\n" "sharkPoint_10m_3_qu4_2010-01-14_IMG_0032.jpg\n\n" "The original file name is not used by CoralNet, but could be " "useful for your own reference." ) self.additional_details = [ """Annotation points will be automatically generated for your images. Your Source's point generation settings: %s Your Source's annotation area settings: %s""" % ( PointGen.db_to_readable_format(source.default_point_generation_method), AnnotationAreaUtils.db_format_to_display(source.image_annotation_area) ) ]
def source_new(request): """ Page with the form to create a new Source. """ # We can get here one of two ways: either we just got to the form # page, or we just submitted the form. If POST, we submitted; if # GET, we just got here. if request.method == 'POST': # A form bound to the POST data sourceForm = ImageSourceForm(request.POST) pointGenForm = PointGenForm(request.POST) annotationAreaForm = AnnotationAreaPercentsForm(request.POST) # is_valid() calls our ModelForm's clean() and checks validity source_form_is_valid = sourceForm.is_valid() point_gen_form_is_valid = pointGenForm.is_valid() annotation_area_form_is_valid = annotationAreaForm.is_valid() if source_form_is_valid and point_gen_form_is_valid and annotation_area_form_is_valid: # After calling a ModelForm's is_valid(), an instance is created. # We can get this instance and add a bit more to it before saving to the DB. newSource = sourceForm.instance newSource.default_point_generation_method = PointGen.args_to_db_format(**pointGenForm.cleaned_data) newSource.image_annotation_area = AnnotationAreaUtils.percentages_to_db_format(**annotationAreaForm.cleaned_data) newSource.labelset = LabelSet.getEmptyLabelset() newSource.save() # Make the user a source admin newSource.assign_role(request.user, Source.PermTypes.ADMIN.code) # Add a success message messages.success(request, 'Source successfully created.') # Redirect to the source's main page return HttpResponseRedirect(reverse('source_main', args=[newSource.id])) else: # Show the form again, with error message messages.error(request, 'Please correct the errors below.') else: # An unbound form (empty form) sourceForm = ImageSourceForm() pointGenForm = PointGenForm() annotationAreaForm = AnnotationAreaPercentsForm() # RequestContext needed for CSRF verification of POST form, # and to correctly get the path of the CSS file being used. return render_to_response('images/source_new.html', { 'sourceForm': sourceForm, 'pointGenForm': pointGenForm, 'annotationAreaForm': annotationAreaForm, }, context_instance=RequestContext(request) )
def __init__(self, *args, **kwargs): image = kwargs.pop('image') if image.metadata.annotation_area: d = AnnotationAreaUtils.db_format_to_numbers(image.metadata.annotation_area) annoarea_type = d.pop('type') if annoarea_type == AnnotationAreaUtils.TYPE_PERCENTAGES: kwargs['initial'] = AnnotationAreaUtils.percentages_to_pixels(width=image.original_width, height=image.original_height, **d) elif annoarea_type == AnnotationAreaUtils.TYPE_PIXELS: kwargs['initial'] = d elif annoarea_type == AnnotationAreaUtils.TYPE_IMPORTED: raise ValueError("Points were imported; annotation area should be un-editable.") super(AnnotationAreaPixelsForm, self).__init__(*args, **kwargs) self.fields['min_x'] = IntegerField( label="Left boundary X", required=False, min_value=1, max_value=image.original_width, widget=TextInput(attrs={'size': 3}) ) self.fields['max_x'] = IntegerField( label="Right boundary X", required=False, min_value=1, max_value=image.original_width, widget=TextInput(attrs={'size': 3}) ) self.fields['min_y'] = IntegerField( label="Top boundary Y", required=False, min_value=1, max_value=image.original_height, widget=TextInput(attrs={'size': 3}) ) self.fields['max_y'] = IntegerField( label="Bottom boundary Y", required=False, min_value=1, max_value=image.original_height, widget=TextInput(attrs={'size': 3}) ) self.form_help_text = Metadata._meta.get_field('annotation_area').help_text
def source_edit(request, source_id): """ Edit a source: name, visibility, location keys, etc. """ source = get_object_or_404(Source, id=source_id) if request.method == 'POST': # Cancel cancel = request.POST.get('cancel', None) if cancel: messages.success(request, 'Edit cancelled.') return HttpResponseRedirect(reverse('source_main', args=[source_id])) # Submit sourceForm = ImageSourceForm(request.POST, instance=source) pointGenForm = PointGenForm(request.POST) annotationAreaForm = AnnotationAreaPercentsForm(request.POST) # Make sure is_valid() is called for all forms, so all forms are checked and # all relevant error messages appear. source_form_is_valid = sourceForm.is_valid() point_gen_form_is_valid = pointGenForm.is_valid() annotation_area_form_is_valid = annotationAreaForm.is_valid() if source_form_is_valid and point_gen_form_is_valid and annotation_area_form_is_valid: editedSource = sourceForm.instance editedSource.default_point_generation_method = PointGen.args_to_db_format(**pointGenForm.cleaned_data) editedSource.image_annotation_area = AnnotationAreaUtils.percentages_to_db_format(**annotationAreaForm.cleaned_data) editedSource.save() messages.success(request, 'Source successfully edited.') return HttpResponseRedirect(reverse('source_main', args=[source_id])) else: messages.error(request, 'Please correct the errors below.') else: # Just reached this form page sourceForm = ImageSourceForm(instance=source) pointGenForm = PointGenForm(source=source) annotationAreaForm = AnnotationAreaPercentsForm(source=source) return render_to_response('images/source_edit.html', { 'source': source, 'editSourceForm': sourceForm, 'pointGenForm': pointGenForm, 'annotationAreaForm': annotationAreaForm, }, context_instance=RequestContext(request) )
def __init__(self, *args, **kwargs): """ If a Source is passed in as an argument, then get the annotation area of that Source, and use that to fill the form fields' initial values. """ if kwargs.has_key('source'): source = kwargs.pop('source') if source.image_annotation_area: kwargs['initial'] = AnnotationAreaUtils.db_format_to_percentages(source.image_annotation_area) self.form_help_text = Source._meta.get_field('image_annotation_area').help_text super(AnnotationAreaPercentsForm, self).__init__(*args, **kwargs)
def test_post_success(self): """ Successful creation of a new source. """ datetime_before_creation = datetime.datetime.now().replace(microsecond=0) response = self.client.post(reverse('source_new'), self.source_args) source_id = Source.objects.latest('create_date').pk self.assertRedirects(response, reverse('source_main', kwargs={ 'source_id': source_id, } )) new_source = Source.objects.get(pk=source_id) self.assertEqual(new_source.name, self.source_args['name']) self.assertEqual(new_source.visibility, self.source_args['visibility']) self.assertEqual(new_source.labelset, LabelSet.getEmptyLabelset()) self.assertEqual(new_source.key1, self.source_args['key1']) self.assertEqual(new_source.key2, '') self.assertEqual(new_source.key3, '') self.assertEqual(new_source.key4, '') self.assertEqual(new_source.key5, '') self.assertEqual(new_source.default_point_generation_method, PointGen.args_to_db_format( point_generation_type=self.source_args['point_generation_type'], simple_number_of_points=self.source_args['simple_number_of_points'], )) self.assertEqual(new_source.image_height_in_cm, self.source_args['image_height_in_cm']) self.assertEqual(new_source.image_annotation_area, AnnotationAreaUtils.percentages_to_db_format( min_x=self.source_args['min_x'], max_x=self.source_args['max_x'], min_y=self.source_args['min_y'], max_y=self.source_args['max_y'], )) self.assertEqual(new_source.longitude, self.source_args['longitude']) self.assertEqual(new_source.latitude, self.source_args['latitude']) self.assertEqual(new_source.enable_robot_classifier, True) # This check is of limited use since database datetimes (in # MySQL 5.1 at least) get truncated to whole seconds. But it still # doesn't hurt to check. self.assertTrue(datetime_before_creation <= new_source.create_date) self.assertTrue(new_source.create_date <= datetime.datetime.now().replace(microsecond=0))
def image_upload(request, source_id): """ This view serves the image upload page. It doesn't actually do any upload processing, though; that's left to the Ajax views. """ source = get_object_or_404(Source, id=source_id) images_form = MultiImageUploadForm() options_form = ImageUploadOptionsForm(source=source) csv_import_form = CSVImportForm() annotation_import_form = AnnotationImportForm() annotation_import_options_form = AnnotationImportOptionsForm(source=source) proceed_to_manage_metadata_form = ImageSpecifyForm( initial=dict(specify_method='image_ids'), source=source, ) auto_generate_points_message = ( "We will generate points for the images you upload.\n" "Your Source's point generation settings: {pointgen}\n" "Your Source's annotation area settings: {annoarea}").format( pointgen=PointGen.db_to_readable_format(source.default_point_generation_method), annoarea=AnnotationAreaUtils.db_format_to_display(source.image_annotation_area, ), ) return render_to_response('upload/image_upload.html', { 'source': source, 'images_form': images_form, 'options_form': options_form, 'csv_import_form': csv_import_form, 'annotation_import_form': annotation_import_form, 'annotation_import_options_form': annotation_import_options_form, 'proceed_to_manage_metadata_form': proceed_to_manage_metadata_form, 'auto_generate_points_message': auto_generate_points_message, }, context_instance=RequestContext(request) )
def test_post_success(self): """ Successful edit of an existing source. """ original_source = Source.objects.get(pk=self.source_id) original_create_date = original_source.create_date original_enable_robot = original_source.enable_robot_classifier response = self.client.post(reverse('source_edit', kwargs={'source_id': self.source_id}), self.source_args, ) self.assertRedirects(response, reverse('source_main', kwargs={'source_id': self.source_id} )) edited_source = Source.objects.get(pk=self.source_id) self.assertEqual(edited_source.name, self.source_args['name']) self.assertEqual(edited_source.visibility, self.source_args['visibility']) self.assertEqual(edited_source.create_date, original_create_date) self.assertEqual(edited_source.labelset, LabelSet.getEmptyLabelset()) self.assertEqual(edited_source.key1, self.source_args['key1']) self.assertEqual(edited_source.key2, '') self.assertEqual(edited_source.key3, '') self.assertEqual(edited_source.key4, '') self.assertEqual(edited_source.key5, '') self.assertEqual(edited_source.default_point_generation_method, PointGen.args_to_db_format( point_generation_type=self.source_args['point_generation_type'], simple_number_of_points=self.source_args['simple_number_of_points'], )) self.assertEqual(edited_source.image_height_in_cm, self.source_args['image_height_in_cm']) self.assertEqual(edited_source.image_annotation_area, AnnotationAreaUtils.percentages_to_db_format( min_x=self.source_args['min_x'], max_x=self.source_args['max_x'], min_y=self.source_args['min_y'], max_y=self.source_args['max_y'], )) self.assertEqual(edited_source.longitude, self.source_args['longitude']) self.assertEqual(edited_source.latitude, self.source_args['latitude']) self.assertEqual(edited_source.enable_robot_classifier, original_enable_robot)
def annotation_area_edit(request, image_id): """ Edit an image's annotation area. """ image = get_object_or_404(Image, id=image_id) source = image.source metadata = image.metadata old_annotation_area = metadata.annotation_area if request.method == 'POST': # Cancel cancel = request.POST.get('cancel', None) if cancel: messages.success(request, 'Edit cancelled.') return HttpResponseRedirect(reverse('image_detail', args=[image.id])) # Submit annotationAreaForm = AnnotationAreaPixelsForm(request.POST, image=image) if annotationAreaForm.is_valid(): metadata.annotation_area = AnnotationAreaUtils.pixels_to_db_format(**annotationAreaForm.cleaned_data) metadata.save() if metadata.annotation_area != old_annotation_area: generate_points(image, usesourcemethod=False) image.after_annotation_area_change() messages.success(request, 'Annotation area successfully edited.') return HttpResponseRedirect(reverse('image_detail', args=[image.id])) else: messages.error(request, 'Please correct the errors below.') else: # Just reached this form page annotationAreaForm = AnnotationAreaPixelsForm(image=image) # Scale down the image to have a max width of 800 pixels. MAX_DISPLAY_WIDTH = 800 # jQuery UI resizing with containment isn't subpixel-precise, so # the display height is rounded to an int. Thus, need to track # width/height scaling factors separately for accurate calculations. display_width = min(MAX_DISPLAY_WIDTH, image.original_width) width_scale_factor = float(display_width) / image.original_width display_height = int(round(image.original_height * width_scale_factor)) height_scale_factor = float(display_height) / image.original_height dimensions = dict( displayWidth = display_width, displayHeight = display_height, fullWidth = image.original_width, fullHeight = image.original_height, widthScaleFactor = width_scale_factor, heightScaleFactor = height_scale_factor, ) thumbnail_dimensions = (display_width, display_height) return render_to_response('annotations/annotation_area_edit.html', { 'source': source, 'image': image, 'dimensions': simplejson.dumps(dimensions), 'thumbnail_dimensions': thumbnail_dimensions, 'annotationAreaForm': annotationAreaForm, }, context_instance=RequestContext(request) )
def annotation_area_display(self): """ Display the annotation area parameters in templates. Usage: {{ myimage.annotation_area_display }} """ return AnnotationAreaUtils.db_format_to_display(self.metadata.annotation_area)
def image_annotation_area_display(self): """ Display the annotation-area parameters in templates. Usage: {{ mysource.annotation_area_display }} """ return AnnotationAreaUtils.db_format_to_display(self.image_annotation_area)
def source_new(request): """ Page with the form to create a new Source. """ # We can get here one of two ways: either we just got to the form # page, or we just submitted the form. If POST, we submitted; if # GET, we just got here. if request.method == 'POST': # Bind the forms to the submitted POST data. sourceForm = ImageSourceForm(request.POST) location_key_form = LocationKeyForm(request.POST) pointGenForm = PointGenForm(request.POST) annotationAreaForm = AnnotationAreaPercentsForm(request.POST) # <form>.is_valid() calls <form>.clean() and checks field validity. # Make sure is_valid() is called for all forms, so all forms are checked and # all relevant error messages appear. source_form_is_valid = sourceForm.is_valid() location_key_form_is_valid = location_key_form.is_valid() point_gen_form_is_valid = pointGenForm.is_valid() annotation_area_form_is_valid = annotationAreaForm.is_valid() if source_form_is_valid and location_key_form_is_valid \ and point_gen_form_is_valid and annotation_area_form_is_valid: # Since sourceForm is a ModelForm, after calling sourceForm's # is_valid(), a Source instance is created. We retrieve this # instance and add the other values to it before saving to the DB. newSource = sourceForm.instance for key_field in ['key1', 'key2', 'key3', 'key4', 'key5']: if key_field in location_key_form.cleaned_data: setattr(newSource, key_field, location_key_form.cleaned_data[key_field]) newSource.default_point_generation_method = PointGen.args_to_db_format(**pointGenForm.cleaned_data) newSource.image_annotation_area = AnnotationAreaUtils.percentages_to_db_format(**annotationAreaForm.cleaned_data) newSource.labelset = LabelSet.getEmptyLabelset() newSource.save() # Make the current user an admin of the new source newSource.assign_role(request.user, Source.PermTypes.ADMIN.code) # Add a success message messages.success(request, 'Source successfully created.') # Redirect to the source's main page return HttpResponseRedirect(reverse('source_main', args=[newSource.id])) else: # Show the form again, with error message messages.error(request, 'Please correct the errors below.') else: # Unbound (empty) forms sourceForm = ImageSourceForm() location_key_form = LocationKeyForm() pointGenForm = PointGenForm() annotationAreaForm = AnnotationAreaPercentsForm() # RequestContext is needed for CSRF verification of the POST form, # and to correctly get the path of the CSS file being used. return render_to_response('images/source_new.html', { 'sourceForm': sourceForm, 'location_key_form': location_key_form, 'pointGenForm': pointGenForm, 'annotationAreaForm': annotationAreaForm, }, context_instance=RequestContext(request) )