def customVisionDetectObjectsLocalDisplay(imageFileName):
"""
Description: This function detects selected workstation objects, using a custom vision algorithm, in an image retrieved from an Azure Blob Storage, via its URL. It then prints out the results to the console.
Source: The Azure Custom Vision SDK Sample was used as guidance and for finding an elegant way to print the results to the console (https://github.com/Azure-Samples/cognitive-services-python-sdk-samples/blob/master/samples/vision/custom_vision_prediction_samples.py)
Input: (containerName -> string), (blobName -> string)
Output: No direct output, but it writes the results of the object detection to the console.
"""
print("\n\n===== Custom Vision Object Detection=====\n")
#Retriving the probability threshold to recognise an object
result_probThreshold = dbc.retrieve_probThreshold("customVisionObjects")
probThreshold = float(result_probThreshold[0])
# Client Authentication
predictor = CustomVisionPredictionClient(CCV_endpoint, CCV_credentials)
# Get URL image with different objects
#remote_image_url_objects = hbl.getBlobURI(containerName, blobName)
with open(dm.createTargetDirectory("Images") + imageFileName, "rb") as image_contents:
# Call API with URL
custom_vision_prediction = predictor.detect_image_with_no_store(project_id, published_name, image_contents.read())
print("Objects Detected with Custom Vision and a Probability Threshold >= 0.2:")
if len(custom_vision_prediction.predictions) == 0:
print("No objects detected.")
else:
for prediction in custom_vision_prediction.predictions:
if (prediction.probability >= probThreshold):
print("->\t" + prediction.tag_name +
": {0:.2f}%".format(prediction.probability * 100))
cv2.imshow("preview", frame)
rval, frame = vc.read()
im = Image.fromarray(frame)
# im.save('test.png') # quick test
# exit()
imgByteArr = io.BytesIO()
im.save(imgByteArr, format='PNG')
imgByteArr = imgByteArr.getvalue()
if settings['store_images']:
results = predictor.detect_image(settings['project_id'],
settings['published_name'],
imgByteArr)
else:
results = predictor.detect_image_with_no_store(
settings['project_id'], settings['published_name'], imgByteArr)
predictions = [
p for p in results.predictions
if p.probability > settings['prediction_threshold']
and p.tag_name == settings['object_of_interest']
]
for prediction in predictions:
print(
"\t" + prediction.tag_name +
": {0:.2f}% bbox.left = {1:.2f}, bbox.top = {2:.2f}, bbox.width = {3:.2f}, bbox.height = {4:.2f}"
.format(prediction.probability * 100, prediction.bounding_box.left,
prediction.bounding_box.top, prediction.bounding_box.width,
prediction.bounding_box.height))
key = cv2.waitKey(20)
class customVisionApi:
'''Methods to call Custom Vision Prediction & Training API.'''
def __init__(
self,
endpoint,
training_key,
prediction_key,
prediction_ressource_id,
project_id,
iteration_id,
iteration_name,
training_images,
):
self.endpoint = endpoint
self.training_key = training_key
self.prediction_key = prediction_key
self.prediction_ressource_id = prediction_ressource_id
self.project_id = project_id
self.iteration_id = iteration_id
self.iteration_name = iteration_name
self.training_images = training_images
#Initializing Prediction Client
self.predictor = CustomVisionPredictionClient(self.prediction_key,
self.endpoint)
#Initializing Training Client
self.trainer = CustomVisionTrainingClient(self.training_key,
self.endpoint)
def listImagesInFile(self):
'''Browse all images in a directory and split them in a dictionnary according if model name is present in file name'''
model_name = "PL"
images = {'Model_A': [], 'Model_B': []}
#List all images in directory & display count
directory = os.listdir(self.training_images)
print("Found:", len(directory), "images")
#Split images in dictionnary according to their name
for image in directory:
if model_name in image:
images['Model_A'].append(image)
else:
images['Model_B'].append(image)
print("Found:", len(images['Model_A']), "Model_A")
print("Found:", len(images['Model_B']), "Model_B")
return images
def storeInSqlDb(self, AllDefaultDictionnary):
# Connect to the database
print(AllDefaultDictionnary)
def predictModelNoStore(self, imageToBeDetected):
'''Apply Cusom Vision API on image and list defaults'''
listAllDefaultsInImage = []
with open(self.training_images + '/' + imageToBeDetected,
"rb") as image_contents:
results = self.predictor.detect_image_with_no_store(
self.project_id, self.iteration_name, image_contents.read())
allDefault = {}
fileName = imageToBeDetected
#List all defaults in image with probability
getDefaultList = self.getDefaults(results.predictions)
#Create default categories with sum of probability
countDefault = self.defaultCounter(getDefaultList)
#Return Tag Name with probability > 10%
getSelectedTag = self.returnDefaultTag(countDefault)
#Create a list of dict with all defaults found in the file images
allDefault[fileName] = getSelectedTag
sql = self.storeInSqlDb(allDefault)
return allDefault
def writeResult(self, listToBeWritten):
'''Create a .txt file with the iteration name & write list content.'''
fileName = 'result_' + self.iteration_name + '.txt'
with open(fileName, 'a') as f:
f.write(str(listToBeWritten))
f.close()
return print("Results saved in " + fileName)
def getDefaults(self, predictionResults):
'''List all default found in image with its probability.'''
#Initialise empty list to store defaults
default_list = []
for prediction in predictionResults:
#Initialize a dictionnary with key:Default & value:probability
default_proba = {}
default_proba[prediction.tag_name] = prediction.probability * 100
#Add default to list
default_list.append(dict(default_proba))
#Return list with all defaults and their probabilities
return default_list
def defaultCounter(self, ListDefaultsWithProb):
'''Group default in categories and sum probabilities.'''
#Initialise counter() from Collections to sum probabilities per default
counter = collections.Counter()
for probabilityDefault in ListDefaultsWithProb:
counter.update(probabilityDefault)
#Return dictionnary with default and sum probability
defaultWithProbaSum = dict(counter)
return defaultWithProbaSum
def returnDefaultTag(self, defaultsDictionnary):
"Return only default with a certain probability."
#Return Dictionnary with only default tag where probability > 10%
accepted_probability = 10
OnlySelectedDefaultTag = {
k: v
for (k, v) in defaultsDictionnary.items()
if v > accepted_probability
}
print(OnlySelectedDefaultTag)
return OnlySelectedDefaultTag
def predictQuick(self):
'''Upload image and display predictions in terminal'''
#List all images in directory
directory = os.listdir(self.training_images)
print("Found:", len(directory), "images")
#Upload image without storing, get prediction
for file in directory:
with open(self.training_images + '/' + file,
"rb") as image_contents:
self.results = self.predictor.detect_image(
self.projectId, self.publish_iteration_name,
image_contents.read())
print("Image : " + file)
# Display the results.
for prediction in self.results.predictions:
print("\t" + prediction.tag_name +
": {0:.2f}%".format(prediction.probability * 100))
def getIdsinPredictions(self):
"""List Ids of images present in prediction"""
#Retrieve Prediction Token
query = PredictionQueryToken(order_by='Newest',
iteration_id=self.Iteration_id)
#Get all predictions results
response = self.trainer.query_predictions(self.projectId, query)
#Create a list with all ids & return it
list_ids = []
for elt in response.results:
list_ids.append(elt.id)
print("Found:", len(list_ids), "images in prediction")
return (list_ids)
def deletePredictions(self):
'''Delete images in prediction'''
#List all predictions Id
allIds = self.getIdsinPredictions()
#Create batches of 64 images (maximum for delete) & delete images
batch = [allIds[i:i + 64] for i in range(0, len(allIds), 64)]
for i in batch:
delete = self.trainer.delete_prediction(self.projectId, ids=i)
return print("All images deleted")
