def test(self):
resetDb()
rest = ImagingInterface(isManual=False)
# empty table
self.assertIsNone(rest.getAllSubmittedTargets())
# create one target
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId = int(resp.headers['X-Crop-Id'])
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = int(resp.headers['X-Class-Id'])
modelResult = rest.getClassById(classId)
self.assertIsNotNone(modelResult)
targetId = modelResult.target
# post a second crop and classification which goes to a different target:
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId2 = int(resp.headers['X-Crop-Id'])
# since it's shape is different, this should be a different target
classToPost = Classification(cropId2, 'standard', 'NE', 'square',
'orange', 'T', 'black')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId2 = int(resp.headers['X-Class-Id'])
modelResult = rest.getClassById(classId2)
self.assertIsNotNone(modelResult)
targetId2 = modelResult.target
self.assertNotEqual(targetId, targetId2)
self.assertIsNotNone(rest.postSubmitAllTargets())
resp = rest.getAllSubmittedTargets()
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 2)
if resp[0].target == targetId:
self.assertEqual(resp[0].crop_id, cropId)
self.assertEqual(resp[1].crop_id, cropId2)
elif resp[0].target == targetId2:
self.assertEqual(resp[0].crop_id, cropId2)
else:
self.fail(
msg=
"errrmmm. One of the returned target ids does not match what we submitted"
)
def test(self):
resetDb()
rest = ImagingInterface()
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
# get stuff into the cropped and classification table
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
_, cropId, _ = rest.getNextCroppedImage(
) # get the cropId as they would in the gui
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = int(resp.headers['X-Class-Id'])
resp = rest.getClassById(classId)
self.assertIsNotNone(resp)
self.assertIsInstance(resp, Classification)
# check data integrity from our previous post
self.assertEqual(resp.crop_id, cropId)
self.assertEqual(resp.class_id, classId)
self.assertEqual(resp.type, 'standard')
self.assertEqual(resp.orientation, 'NE')
self.assertEqual(resp.shape, 'circle')
self.assertEqual(resp.background_color, 'white')
self.assertEqual(resp.alphanumeric, 'T')
self.assertEqual(resp.alphanumeric_color, 'yellow')
self.assertEqual(resp.submitted, 'unsubmitted')
self.assertEqual(resp.description, '')
self.assertIsNotNone(resp.target)
def test(self):
resetDb()
rest = ImagingInterface()
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
_, cropId, _ = rest.getNextCroppedImage(
) # get the cropId as they would in the gui
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = resp.headers['X-Class-Id']
self.assertIsNotNone(classId)
self.assertNotEqual(int(classId), -1)
resp = rest.deleteClass(classId)
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code, 200)
# we should fail to get the classification
self.assertIsNone(rest.getClassById(classId))
def test(self):
resetDb()
rest = ImagingInterface()
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
_, cropId, _ = rest.getNextCroppedImage(
) # get the cropId as they would in the gui
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = resp.headers['X-Class-Id']
self.assertIsNotNone(classId)
self.assertNotEqual(int(classId), -1)
# should fail to update stuff that doesn't exist
stuffToUpdate = Classification(None, None, "SE", "square", None, "Y",
"purple")
self.assertIsNone(rest.updateClass(int(classId) + 20, stuffToUpdate))
resp = rest.updateClass(classId, stuffToUpdate)
# confirm update claims success
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code, 200)
# confirm update was acutlaly successful
updated = rest.getClassById(classId)
self.assertIsNotNone(updated)
self.assertEqual(updated.crop_id, cropId)
self.assertEqual(updated.type, 'standard')
self.assertEqual(updated.orientation, 'SE')
self.assertEqual(updated.shape, 'square')
self.assertEqual(updated.background_color, 'white')
self.assertEqual(updated.alphanumeric, "Y")
self.assertEqual(updated.alphanumeric_color, "purple")
def test(self):
resetDb()
rest = ImagingInterface()
# empty table
self.assertIsNone(rest.getSubmittedTargetById(100))
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId = int(resp.headers['X-Crop-Id'])
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = int(resp.headers['X-Class-Id'])
modelResult = rest.getClassById(classId)
self.assertIsNotNone(modelResult)
targetId = modelResult.target
# should still be none since the target is unsubmitted
self.assertIsNone(rest.getSubmittedTargetById(targetId))
# submit the target
resp = rest.postSubmitTargetById(targetId)
self.assertIsNotNone(resp)
# now lets see if the getter works:
resp = rest.getSubmittedTargetById(targetId)
self.assertIsNotNone(resp)
self.assertIsInstance(resp, Classification)
self.assertEqual(resp.target, targetId)
self.assertEqual(resp.crop_id, cropId)
self.assertEqual(resp.type, 'standard')
self.assertEqual(resp.shape, 'circle')
self.assertEqual(resp.orientation, 'NE')
self.assertEqual(resp.background_color, 'white')
self.assertEqual(resp.alphanumeric, 'T')
self.assertEqual(resp.alphanumeric_color, 'yellow')
self.assertEqual(resp.submitted, 'pending')
def test(self):
resetDb()
rest = ImagingInterface()
# should get none when we try and post on empty table
self.assertIsNone(rest.postSubmitTargetById(100))
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId = int(resp.headers['X-Crop-Id'])
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = int(resp.headers['X-Class-Id'])
modelResult = rest.getClassById(classId)
self.assertIsNotNone(modelResult)
targetId = modelResult.target
# trying to submit an id that doesn't exist should also fail
self.assertIsNone(rest.postSubmitTargetById(targetId + 20))
resp = rest.postSubmitTargetById(targetId)
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code, 200)
# confirm that the classification's status has changed to submitted
modelResult = rest.getClassById(classId)
self.assertIsNotNone(modelResult)
self.assertIsNotNone(modelResult.target)
self.assertEqual(modelResult.submitted, 'submitted')
# trying to submit the same target again should fail:
self.assertIsNone(rest.postSubmitTargetById(targetId))
def test(self):
resetDb()
rest = ImagingInterface()
# should get none if classification/pend list is empty:
self.assertIsNone(rest.getPendingSubmissions())
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId = int(resp.headers['X-Crop-Id'])
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = resp.headers['X-Class-Id']
resp = rest.getPendingSubmissions()
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 1)
self.assertEqual(len(resp[0]), 1)
self.assertEqual(resp[0][0].class_id, int(classId))
self.assertEqual(resp[0][0].crop_id, int(cropId))
# post a second crop and classification which goes to a different target:
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId2 = int(resp.headers['X-Crop-Id'])
# since it's shape is different, this should be a different target
classToPost = Classification(cropId2, 'standard', 'NE', 'square',
'orange', 'T', 'black')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId2 = int(resp.headers['X-Class-Id'])
resp = rest.getPendingSubmissions()
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 2)
self.assertEqual(len(resp[0]), 1)
self.assertEqual(len(resp[1]), 1)
# post a third crop and classification which goes to one of our already existing targets
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
cropId3 = int(resp.headers['X-Crop-Id'])
# this should be a match with target2
classToPost = Classification(cropId3, 'standard', 'SE', 'square',
'purple', 'T', 'black')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId3 = int(resp.headers['X-Class-Id'])
self.assertNotEqual(classId2, classId3)
resp = rest.getPendingSubmissions()
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 2)
if len(resp[0]) == 2:
self.assertEqual(resp[0][1].type, 'standard')
self.assertEqual(resp[0][1].shape, 'square')
self.assertEqual(resp[0][0].alphanumeric, 'T')
self.assertEqual(resp[1][0].class_id, int(classId))
self.assertEqual(resp[1][0].crop_id, int(cropId))
elif len(resp[1]) == 2:
self.assertEqual(resp[0][0].class_id, int(classId))
self.assertEqual(resp[0][0].crop_id, int(cropId))
self.assertEqual(resp[1][1].type, 'standard')
self.assertEqual(resp[1][1].shape, 'square')
self.assertEqual(resp[1][0].alphanumeric, 'T')
else:
self.fail(msg="one of the targets should have two classifications")
def test(self):
resetDb()
rest = ImagingInterface()
ret = rest.getNextRawImage()
self.assertIsNotNone(ret)
# get stuff into the cropped and classification table
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
_, cropId, _ = rest.getNextCroppedImage(
) # get the cropId as they would in the gui
classToPost = Classification(cropId, 'standard', 'NE', 'circle',
'white', 'T', 'yellow')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId = int(resp.headers['X-Class-Id'])
# post a second crop and classification:
resp = rest.postCroppedImage(ret[1], ret[0], [22, 22], [236, 236])
self.assertIsNotNone(resp)
self.assertEqual(resp.status_code,
200) # assert successful post to cropped
_, cropId2, _ = rest.getNextCroppedImage(
) # get the cropId as they would in the gui
classToPost = Classification(cropId2, 'off_axis', 'NE', 'square',
'orange', 'T', 'black')
resp = rest.postClass(classToPost)
self.assertIsNotNone(resp)
classId2 = int(resp.headers['X-Class-Id'])
# get all:
resp = rest.getAllClass()
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 2)
modelA = resp[0]
modelB = resp[1]
if modelA.class_id == classId:
#check model A
self.assertEqual(modelA.crop_id, cropId)
self.assertEqual(modelA.class_id, classId)
self.assertEqual(modelA.type, 'standard')
self.assertEqual(modelA.orientation, 'NE')
self.assertEqual(modelA.shape, 'circle')
self.assertEqual(modelA.background_color, 'white')
self.assertEqual(modelA.alphanumeric, 'T')
self.assertEqual(modelA.alphanumeric_color, 'yellow')
self.assertEqual(modelA.submitted, 'unsubmitted')
self.assertEqual(modelA.description, '')
self.assertIsNotNone(modelA.target)
# check model B
self.assertEqual(modelB.crop_id, cropId2)
self.assertEqual(modelB.class_id, classId2)
self.assertEqual(modelB.type, 'off_axis')
self.assertEqual(modelB.orientation, 'NE')
self.assertEqual(modelB.shape, 'square')
self.assertEqual(modelB.background_color, 'orange')
self.assertEqual(modelB.alphanumeric, 'T')
self.assertEqual(modelB.alphanumeric_color, 'black')
self.assertEqual(modelB.submitted, 'unsubmitted')
self.assertEqual(modelB.description, '')
self.assertIsNotNone(modelB.target)
elif modelA.class_id == classId2:
#check model B
self.assertEqual(modelB.crop_id, cropId)
self.assertEqual(modelB.class_id, classId)
self.assertEqual(modelB.type, 'standard')
self.assertEqual(modelB.orientation, 'NE')
self.assertEqual(modelB.shape, 'circle')
self.assertEqual(modelB.background_color, 'white')
self.assertEqual(modelB.alphanumeric, 'T')
self.assertEqual(modelB.alphanumeric_color, 'yellow')
self.assertEqual(modelB.submitted, 'unsubmitted')
self.assertEqual(modelB.description, '')
self.assertIsNotNone(modelB.target)
# check model A
self.assertEqual(modelA.crop_id, cropId2)
self.assertEqual(modelA.class_id, classId2)
self.assertEqual(modelA.type, 'off_axis')
self.assertEqual(modelA.orientation, 'NE')
self.assertEqual(modelA.shape, 'square')
self.assertEqual(modelA.background_color, 'orange')
self.assertEqual(modelA.alphanumeric, 'T')
self.assertEqual(modelA.alphanumeric_color, 'black')
self.assertEqual(modelA.submitted, 'unsubmitted')
self.assertEqual(modelA.description, '')
self.assertIsNotNone(modelA.target)
else:
self.fail()
def runClassification(self):
"""
If this autonomous manager is set todo so, run classification on an available
cropped image, if any.
"""
toClassify = self.client.getNextCroppedImage()
if toClassify is not None:
imgToClassify = np.array(toClassify[0])[:, :, ::-1]
cropId = toClassify[1]
cropInfo = self.client.getCroppedImageInfo(cropId)
if cropInfo is None:
print("Failed to get cropped image info!")
return # couldnt get info on the cropped image? weird..
rawInfo = self.client.getImageInfo(cropInfo.imgId)
stateMeas = None
if rawInfo is None:
print(
"Failed to get raw image info while attempting to classify!"
)
else:
# get the state measurement closest to the raw image timestamp
stateMeas = self.client.getStateByTs(rawInfo.time_stamp)
classified = None
if stateMeas is not None:
# if we were able to get a state measurement close to our raw img timestamp use it to try and decide orientation
classified = self.classifier.classify(imgToClassify,
show=False,
yaw=stateMeas.yaw)
else:
# attempt to classify without orientation data
classified = self.classifier.classify(imgToClassify,
show=False)
# print("Crop #: %i" % (cropId))
if self.show:
to_display = self.classifier.blur_crop.copy()
cv2.putText(to_display, str(cropId), (5, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 1,
cv2.LINE_AA)
cv2.imshow('Crop', to_display)
key = cv2.waitKey(1) & 0xFF
if classified is not None:
print("Successfully classified crop {}!".format(cropId))
print(
"\tshape={},letter={},shapeClr={}letterClr={},orientation={}"
.format(classified['shape'], classified['letter'],
classified['shapeColor'],
classified['letterColor'],
classified['orientation']))
# TODO: Always assuming standard target for now..
toPost = Classification(cropId,
"standard",
orientation=classified['orientation'],
shape=classified['shape'],
bgColor=classified['shapeColor'],
alpha=classified['letter'],
alphaColor=classified['letterColor'])
self.client.postClass(toPost)
else:
print("Crop # %i rejected as false positive" % (cropId))