def detect_weight_region(image):
# top_left_corner = (21,120)
# bottom_right_corner = (217, 210)
# cv2.imshow("image",image)
image_shape = image.shape
print(image_shape)
credentials = ApiKeyCredentials(in_headers = {"Prediction-Key":"bf595a2cb1854d988a1f9d26834cd4e2"})
predictor = CustomVisionPredictionClient("https://pankaj.cognitiveservices.azure.com/", credentials)
cv2.imwrite('detect_weight_region.png', image)
digit = ""
with open("detect_weight_region.png", mode ='rb') as captured_image:
# print("load digit image... and predict ")
results = predictor.detect_image("de960dda-1a51-444e-9fe9-84f8fbc4eff1", "Iteration2", captured_image)
maxm_percentage = 0.0
ans = []
for prediction in results.predictions:
if(prediction.probability > maxm_percentage):
maxm_percentage = prediction.probability
ans = [image_shape[0]*prediction.bounding_box.left, image_shape[1]*prediction.bounding_box.top, image_shape[0]*prediction.bounding_box.width, image_shape[1]*prediction.bounding_box.height]
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))
# for prediction in results.predictions:
# if(prediction.probability> maxm_percentage):
# digit = prediction.tag_name
# maxm_percentage = prediction.probability
return ans
def localAnalysis(self, location):
# Initialize Object Predictor
predictor = CustomVisionPredictionClient(self.prediction_key,
endpoint=self.ENDPOINT)
# Open the sample image and get back the prediction results.
with open(location, mode="rb") as test_data:
results = predictor.detect_image(self.project_id,
self.publish_iteration_name,
test_data)
# Display the results.
notes = []
for prediction in results.predictions:
if prediction.probability > self.min_confidence:
notes.append([
prediction.tag_name, prediction.bounding_box.left,
prediction.bounding_box.top, prediction.probability
])
# Sort the data.
self.__noteSort(notes)
# print("Note, Left, Top, Prob")
# for note in notes:
# print(note)
output = []
for note in notes:
output.append(note[0])
return output
def azure_detect_object(img_path):
"""
detect gloves and screwdriver in given image
:param img_path: Image path
:return:
"""
res = {}
template_prediction_key = "54c71598e9434d5fa7853360c4a9e4ce"
template_project_id = "54e7f828-d0c8-49d3-8802-9b402612b7c7"
template_iteration_name = "Iteration2"
template_prediction_endpoint = "https://southeastasia.api.cognitive.microsoft.com"
predictor = CustomVisionPredictionClient(
template_prediction_key, endpoint=template_prediction_endpoint)
with open(img_path, "rb") as image_contents:
results = predictor.detect_image(
template_project_id,
template_iteration_name,
image_contents.read(),
custom_headers={'Content-Type': 'application/octet-stream'})
res = []
for prediction in results.predictions:
res.append(
(prediction.tag_name, prediction.probability,
prediction.bounding_box.left, prediction.bounding_box.top,
prediction.bounding_box.width,
prediction.bounding_box.height))
return res
def success():
image = request.args.get('name', None)
ENDPOINT = "https://southcentralus.api.cognitive.microsoft.com/"
prediction_key = "4c99a663c6984df6b912025e2c7e1dee"
my_project_id = "c9f9158e-e82d-4541-926a-15699c59a4b4"
publish_iteration_name = "Iteration3"
test_data = urlopen(image).read()
prediction_credentials = ApiKeyCredentials(
in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)
results = predictor.detect_image(project_id=my_project_id,
published_name=publish_iteration_name,
image_data=test_data)
first_value = 0
maximum = 0
print(first_value)
for prediction in results.predictions:
next_value = int(prediction.probability * 100)
if maximum <= next_value:
maximum = next_value
tag = prediction.tag_name
print(int(prediction.probability * 100))
print(maximum)
print(tag)
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))
return tag
def get_pattern_predictions(image_path):
predictor = CustomVisionPredictionClient(prediction_key, endpoint=endpoint)
# Open the image and get back the prediction results.
with open(image_path, mode="rb") as test_data:
results = predictor.detect_image(project_id, iteration_name, test_data)
return {"predictions": results.predictions}
def process_image():
file = request.files['file']
file.save("predict")
# Read the image via file.stream
#img = Image.open(file.stream)
#test_img_file = os.path.join('data', 'object-detection', 'ofr.jpg')
test_img_file = 'predict'
test_img = Image.open(test_img_file)
imgbin = open(test_img_file,mode="rb")
test_img_h, test_img_w, test_img_ch = np.array(test_img).shape
print('Ready to predict using model {} in project {}'.format(model_name, project_id))
# Get a prediction client for the object detection model
credentials = ApiKeyCredentials(in_headers={"Prediction-key": cv_key})
predictor = CustomVisionPredictionClient(endpoint=cv_endpoint, credentials=credentials)
print('Detecting objects in {} using model {} in project {}...'.format(test_img_file, model_name, project_id))
# Detect objects in the test image
with open(test_img_file, mode="rb") as test_data:
results = predictor.detect_image(project_id, model_name, test_data)
# Create a figure to display the results
fig = plt.figure(figsize=(10, 12))
#fig = plt.figure(figsize=(test_img_h,test_img_w))
plt.axis('off')
# Display the image with boxes around each detected object
draw = ImageDraw.Draw(test_img)
lineWidth = int(np.array(test_img).shape[1]/100)
object_colors = {
"bebida": "lightgreen",
"calavera_completa": "yellow",
"calavera_de_dulce": "yellow",
"cempasuchil": "orange",
"comida": "blue",
"cruz": "gold",
"fruta": "magenta",
"pan_de_muerto": "darkcyan",
"papel_picado": "red",
"retrato": "cyan"
}
found = []
for prediction in results.predictions:
color = 'white' # default for 'other' object tags
if (prediction.probability*100) > 50:
if prediction.tag_name in object_colors:
color = object_colors[prediction.tag_name]
found.append(prediction.tag_name)
left = prediction.bounding_box.left * test_img_w
top = prediction.bounding_box.top * test_img_h
height = prediction.bounding_box.height * test_img_h
width = prediction.bounding_box.width * test_img_w
points = ((left,top), (left+width,top), (left+width,top+height), (left,top+height),(left,top))
draw.line(points, fill=color, width=lineWidth)
#plt.annotate(prediction.tag_name + ": {0:.2f}%".format(prediction.probability * 100),(left,top), backgroundcolor=color)
plt.annotate(prediction.tag_name,(left,top), backgroundcolor=color)
test_img.save("./static/Imagenes/out.jpg")
return jsonify(found)
def getPredictionBatch(ENDPOINT, publish_iteration_name, prediction_key,
prediction_resource_id, file, training_key,
project_name):
# Now there is a trained endpoint that can be used to make a prediction
prediction_credentials = ApiKeyCredentials(
in_headers={"Prediction-key": prediction_key})
training_credentials = ApiKeyCredentials(
in_headers={"Training-key": training_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)
trainer = CustomVisionTrainingClient(ENDPOINT, training_credentials)
projects = trainer.get_projects()
res_batch = {}
js_res = {}
#Retrieve the object dection project and its tags
#Current assumes one tag
for p in projects:
if p.name == project_name:
project = trainer.get_project(p.id)
tags = trainer.get_tags(project.id)
print('Project Found')
for url in file:
info = url.split()
name = info[0]
url = info[1]
try:
response = requests.get(url)
except:
print("error retrieving image: " + url)
exit(-1)
# Open the sample image and get back the prediction results.
results = predictor.detect_image(project.id, publish_iteration_name,
response.content)
# Display the results.
js_res["vehicle"] = []
for prediction in results.predictions:
x = {
"confidence": "{0:.2f}%".format(prediction.probability * 100),
"bbox_left": "{0:.2f}".format(prediction.bounding_box.left),
"bbox_right": "{0:.2f}".format(prediction.bounding_box.top),
"bbox_width": "{0:.2f}".format(prediction.bounding_box.width),
"bbox_height": "{0:.2f}".format(prediction.bounding_box.height)
}
x = json.dumps(x)
js_res[prediction.tag_name].append(x)
res_batch[name] = js_res
return res_batch
def main():
from dotenv import load_dotenv
try:
# Get Configuration Settings
load_dotenv()
prediction_endpoint = os.getenv('PredictionEndpoint')
prediction_key = os.getenv('PredictionKey')
project_id = os.getenv('ProjectID')
model_name = os.getenv('ModelName')
# Authenticate a client for the training API
credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
prediction_client = CustomVisionPredictionClient(endpoint=prediction_endpoint, credentials=credentials)
# Load image and get height, width and channels
image_file = 'produce.jpg'
print('Detecting objects in', image_file)
image = Image.open(image_file)
h, w, ch = np.array(image).shape
# Detect objects in the test image
with open(image_file, mode="rb") as image_data:
results = prediction_client.detect_image(project_id, model_name, image_data)
# Create a figure for the results
fig = plt.figure(figsize=(8, 8))
plt.axis('off')
# Display the image with boxes around each detected object
draw = ImageDraw.Draw(image)
lineWidth = int(w/100)
color = 'magenta'
for prediction in results.predictions:
# Only show objects with a > 50% probability
if (prediction.probability*100) > 50:
# Box coordinates and dimensions are proportional - convert to absolutes
left = prediction.bounding_box.left * w
top = prediction.bounding_box.top * h
height = prediction.bounding_box.height * h
width = prediction.bounding_box.width * w
# Draw the box
points = ((left,top), (left+width,top), (left+width,top+height), (left,top+height),(left,top))
draw.line(points, fill=color, width=lineWidth)
# Add the tag name and probability
plt.annotate(prediction.tag_name + ": {0:.2f}%".format(prediction.probability * 100),(left,top), backgroundcolor=color)
plt.imshow(image)
outputfile = 'output.jpg'
fig.savefig(outputfile)
print('Results saved in ', outputfile)
except Exception as ex:
print(ex)
def get_pattern_predictions(image_path):
predictor = CustomVisionPredictionClient(prediction_key, endpoint=endpoint)
print 'About to OD the image ' + image_path
# Open the image and get back the prediction results.
with open(image_path, mode="rb") as test_data:
print 'Opened file'
results = predictor.detect_image(project_id, iteration_name, test_data)
print results
# TODO: order the predictions in order to aid readability
return {"predictions": results.predictions}
def main():
"""
Object Detection with Azure Custom Vision
"""
args = parse_args()
config = json.load(open(args.config, "r"))
# Get the predictor
prediction_credentials = ApiKeyCredentials(
in_headers={"Prediction-key": config["prediction_key"]})
predictor = CustomVisionPredictionClient(config["ENDPOINT"],
prediction_credentials)
# ======================================================================================
# Open the sample image and get back the prediction results.
project_id = get_project_id(config)
with open(args.image, "rb") as test_data:
results = predictor.detect_image(
project_id,
config["publish_iteration_name"],
test_data,
)
# ======================================================================================
# Draw the bounding boxes on the image
img = Image.open(args.image)
draw = ImageDraw.Draw(img)
font = ImageFont.truetype("../static/TaipeiSansTCBeta-Regular.ttf",
size=int(5e-2 * img.size[1]))
for prediction in results.predictions:
if prediction.probability > 0.5:
bbox = prediction.bounding_box.as_dict()
left = bbox['left'] * img.size[0]
top = bbox['top'] * img.size[1]
right = left + bbox['width'] * img.size[0]
bot = top + bbox['height'] * img.size[1]
draw.rectangle([left, top, right, bot],
outline=(255, 0, 0),
width=3)
draw.text(
[left, abs(top - 5e-2 * img.size[1])],
"{0} {1:0.2f}".format(prediction.tag_name,
prediction.probability * 100),
fill=(255, 0, 0),
font=font,
)
img.save("output.png")
print("Done!")
print("Please check ouptut.png")
def predict_project(prediction_key, project, iteration):
predictor = CustomVisionPredictionClient(prediction_key, endpoint=ENDPOINT)
# Open the sample image and get back the prediction results.
with open(os.path.join(IMAGES_FOLDER, "Test", "test_od_image.jpg"),
mode="rb") as test_data:
results = predictor.detect_image(project.id, PUBLISH_ITERATION_NAME,
test_data)
# Display the results.
for prediction in results.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))
def get_result(image):
# Now there is a trained endpoint that can be used to make a prediction
ENDPOINT = "https://southcentralus.api.cognitive.microsoft.com"
predictor = CustomVisionPredictionClient(
"a9b7310ff55441829878684390c89aae", endpoint=ENDPOINT)
with open("test.png", "rb") as image_contents:
results = predictor.detect_image(
"ca2d87c7-9f53-4606-8db7-2cf0f410a075", "test",
image_contents.read())
return set([
item.tag_name for item in results.predictions
if item.probability > .5
])
def forecast(meter):
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from msrest.authentication import ApiKeyCredentials
# Now there is a trained endpoint that can be used to make a prediction
credentials = ApiKeyCredentials(
in_headers={"Prediction-key": "5cebf412b5504687bbbe08255e810e88"})
predictor = CustomVisionPredictionClient(
endpoint="https://uksouth.api.cognitive.microsoft.com/",
credentials=credentials)
with open(meter, mode="rb") as image_contents:
results = predictor.detect_image(
"b667b9c2-2604-4f86-be8e-818852441327", "Iteration8",
image_contents)
# Display the results.
#for prediction in results.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))
return results.predictions
def getPrediction(ENDPOINT, publish_iteration_name, prediction_key,
prediction_resource_id, img, training_key, project_name):
# Now there is a trained endpoint that can be used to make a prediction
prediction_credentials = ApiKeyCredentials(
in_headers={"Prediction-key": prediction_key})
training_credentials = ApiKeyCredentials(
in_headers={"Training-key": training_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)
trainer = CustomVisionTrainingClient(ENDPOINT, training_credentials)
projects = trainer.get_projects()
#Retrieve the object dection project and its tags
#Current assumes one tag
for p in projects:
if p.name == project_name:
project = trainer.get_project(p.id)
tags = trainer.get_tags(project.id)
print('Project Found')
# Open the sample image and get back the prediction results.
results = predictor.detect_image(project.id, publish_iteration_name, img)
drawBounds(img, results.predictions)
# Display the results.
js_res = defaultdict(list)
for prediction in results.predictions:
print(prediction)
x = {
"confidence": "{0:.2f}%".format(prediction.probability * 100),
"bbox_left": "{0:.2f}".format(prediction.bounding_box.left),
"bbox_right": "{0:.2f}".format(prediction.bounding_box.top),
"bbox_width": "{0:.2f}".format(prediction.bounding_box.width),
"bbox_height": "{0:.2f}".format(prediction.bounding_box.height)
}
js_res[prediction.tag_name].append(x)
return js_res
def get_head_predictions(image_path):
predictor = CustomVisionPredictionClient(prediction_key, endpoint=endpoint)
# Open the image and get back the prediction results.
with open(image_path, mode="rb") as test_data:
results = predictor.detect_image(project_id, iteration_name, test_data)
best_prediction = None
# Find the best prediction
for prediction in results.predictions:
if best_prediction == None:
best_prediction = prediction
if best_prediction.probability < prediction.probability:
best_prediction = prediction
return {
"predictions": results.predictions,
"best_prediction": best_prediction
}
#Importing the code that detects the arduino Input
#define frame as the frame of webcam feed
ret, frame = vidFeed.read()
#Changes the size of the image such that the aspect ratio is kept the same
frame = imutils.resize(frame, width=400)
#Writes the image as a folder to be used with customvision.ai
cv2.imwrite("Temp_image.jpg", frame)
iterationName = "HandPrediction-Py5"
#Gets the predictions based on the image
with open("Temp_image.jpg", mode="rb") as modelImage:
output = predict.detect_image(project.id, iterationName, modelImage)
modelPredictions = []
#Stores the predictions with a probability higher than 50% in the array modelPredictions
for prediction in output.predictions:
if prediction.probability > 0.3:
modelPredictions.append(prediction)
print(prediction.tag_name + " detected with prob of " +
str(prediction.probability))
#Used to determine the size of the image
frame.shape
#left click functionality
mouseDown = False
class Vision:
def __init__(self, prediction_key, endpoint, iteration_id, iteration_name):
"""Makes a call to custom vision api and use trained model to detect people
"""
credentials = ApiKeyCredentials(
in_headers={"Prediction-key": prediction_key})
self._predictor = CustomVisionPredictionClient(endpoint, credentials)
self._iteration_id = iteration_id
self._iteration_name = iteration_name
def detect_people(self, filepath, show=False):
"""Makes a call to custom vision api and use trained model to detect people
"""
if show: print("Making call to vision api...")
people = []
with open(filepath, mode="rb") as image:
results = self._predictor.detect_image(self._iteration_id,
self._iteration_name, image)
for prediction in results.predictions:
if (prediction.tag_name == "person"
and prediction.probability > .5):
people.append(prediction)
count = len(people)
if show: draw_objects(filepath, people, wait=True)
return people
def get_points_from_box(self, prediction, pixw, pixh):
"""
prediction.bounding_box.left = x
prediction.bounding_box.top = y
prediction.bounding_box.width = w
prediction.bounding_box.height = h
"""
center = (prediction.bounding_box.width * pixw / 2 +
prediction.bounding_box.left * pixw,
prediction.bounding_box.top * pixh +
prediction.bounding_box.height * pixh)
upoid = (prediction.bounding_box.width * pixw / 2 +
prediction.bounding_box.left * pixw,
prediction.bounding_box.top * pixh)
return center, upoid
def get_centroids_and_uppoints(self, predictions, pixw, pixh):
"""
For every bounding box, compute the centroid and the point located on the bottom center of the box
@ array_boxes_detected : list containing all our bounding boxes
"""
array_centroids, array_uppoints = [], [
] # Initialize empty centroid and ground point lists
for prediction in predictions:
# Draw the bounding box
# Get the both important points
centroid, up_point = self.get_points_from_box(
prediction, pixw, pixh)
array_centroids.append(centroid)
array_uppoints.append(centroid)
return array_centroids, array_uppoints
# array_groundpoints is pased in as param list_downoids in compute point transformation
# corner points = corner points of the portion of the image where you want to detect objects (one set of opposite sides must be ||)
# get the height and width of the image, read the image like cv2.imread(img_path)
def compute_perspective_transform(self, corner_points, img):
pt_A = corner_points[0]
pt_B = corner_points[1]
pt_C = corner_points[2]
pt_D = corner_points[3]
width_AD = np.sqrt(((pt_A[0] - pt_D[0])**2) + ((pt_A[1] - pt_D[1])**2))
width_BC = np.sqrt(((pt_B[0] - pt_C[0])**2) + ((pt_B[1] - pt_C[1])**2))
maxWidth = max(int(width_AD), int(width_BC))
height_AB = np.sqrt(((pt_A[0] - pt_B[0])**2) +
((pt_A[1] - pt_B[1])**2))
height_CD = np.sqrt(((pt_C[0] - pt_D[0])**2) +
((pt_C[1] - pt_D[1])**2))
maxHeight = max(int(height_AB), int(height_CD))
input_pts = np.float32([pt_A, pt_B, pt_C, pt_D])
output_pts = np.float32([[0, 0], [0, maxHeight - 1],
[maxWidth - 1, maxHeight - 1],
[maxWidth - 1, 0]])
# matrix
M = cv2.getPerspectiveTransform(input_pts, output_pts)
out = cv2.warpPerspective(img,
M, (maxWidth, maxHeight),
flags=cv2.INTER_LINEAR)
return M, out
# matrix is the transformed image, list of downoids are the list of points that represent objects detected in the image(bottom center of image)
def compute_point_perspective_transformation(self, matrix, list_upoids):
""" Apply the perspective transformation to every ground point which have been detected on the main frame.
@ matrix : the 3x3 matrix
@ list_downoids : list that contains the points to transform
return : list containing all the new points
"""
# Compute the new coordinates of our points
#list_points_to_detect = np.float32(list_upoids).reshape(-1, 1, 2)
list_points_to_detect = np.float32(list_upoids).reshape(-1, 1, 2)
transformed_points = cv2.perspectiveTransform(list_points_to_detect,
matrix)
# Loop over the points and add them to the list that will be returned
transformed_points_list = list()
try:
for i in range(0, transformed_points.shape[0]):
transformed_points_list.append(
[transformed_points[i][0][0], transformed_points[i][0][1]])
except Exception as e:
print("computer point perspective transformation error", e)
return transformed_points_list
# TODO: { people, violations, time, location }
def analyzeFrame(self, image_path, dist_threshold=100):
# val = [[]]
# for now if val does not exist just set a default val array and we will deal with it later
# for now if covid violation threshold does not exist just set a default val array and we will deal with it later
img = cv2.imread(image_path)
# method to get the num of poeple in a image frame and
predictions = self.detect_people(image_path)
p_count = len(predictions)
if p_count == 0:
return predictions, 0, 0
# val[x][y] ---> verticies of image
# corner_points = [[val[0][0], val[0][1]], [val[1][0], val[1][1]], [val[2][0], val[2][1]], [val[3][0], val[3][1]]]
corner_points = [[721, 260], [493, 367], [384, 273], [576, 205]]
# corner_points = [[ 1883 , 654 ], [ 743 , 972], [ 11 , 467 ], [ 961 , 225 ]]
# corner_points = [[ 635 , 293 ], [1879 , 228 ], [9 , 883], [1637 , 1072]]
M, new_img = self.compute_perspective_transform(corner_points, img)
h = img.shape[1]
w = img.shape[0]
array_centroids, array_uppoints = self.get_centroids_and_uppoints(
predictions, h, w)
transformed_points_list = self.compute_point_perspective_transformation(
M, array_uppoints)
# for point in transformed_points_list:
# new_img = cv2.circle(new_img, (point[0], point[1]), radius=5, color=(0, 0, 255), thickness=-1)
# cv2.imshow("analyze stuff", new_img)
violation_count = 0
for i, pair in enumerate(
itertools.combinations(transformed_points_list, r=2)):
# print(pair) --> testing method
# get distance from points - print this out see whats going on
if math.sqrt((pair[0][0] - pair[1][0])**2 +
(pair[0][1] - pair[1][1])**2) < int(dist_threshold):
violation_count = violation_count + 1
return predictions, p_count, violation_count
success,image = vidcap.read()
count = 0
credentials = ApiKeyCredentials(in_headers={"Prediction-key":cv_key})
predictor = CustomVisionPredictionClient(endpoint=cv_endpoint, credentials=credentials)
while success:
cv2.imwrite("frame%d.jpg" % count, image)
success,image = vidcap.read()
test_img_file = os.path.join('frame'+str(count)+'.jpg')
test_img = Image.open(test_img_file)
test_img_h, test_img_w, test_img_ch = np.array(test_img).shape
print('Read a new frame: ', success)
count += 1
with open(test_img_file, mode="rb") as test_data:
results = predictor.detect_image(project_id, model_name, test_data)
fig = plt.figure(figsize=(8, 8))
plt.axis('off')
draw = ImageDraw.Draw(test_img)
lineWidth = int(np.array(test_img).shape[1]/100)
object_colors = {
"mask": "lightgreen",
"no_mask": "yellow"
}
for prediction in results.predictions:
color = 'white'# default for 'other' object tags
if (prediction.probability*100) > 50:
if prediction.tag_name in object_colors:
color = object_colors[prediction.tag_name]
rval = False
while rval:
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,
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")
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
import cv2
camera = cv2.VideoCapture(0)
for i in range(10):
return_value, image = camera.read()
cv2.imwrite('opencv' + str(i) + '.png', image)
del (camera)
# Now there is a trained endpoint that can be used to make a prediction
ENDPOINT = "https://southcentralus.api.cognitive.microsoft.com"
predictor = CustomVisionPredictionClient("a9b7310ff55441829878684390c89aae",
endpoint=ENDPOINT)
with open("test.jpg", "rb") as image_contents:
results = predictor.detect_image("ca2d87c7-9f53-4606-8db7-2cf0f410a075",
"test", image_contents.read())
# Display the results.
for prediction in results.predictions:
print("\t" + prediction.tag_name +
": {0:.2f}%".format(prediction.probability * 100))
import cv2
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from msrest.authentication import ApiKeyCredentials
camera = cv2.VideoCapture(0)
camera.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
credentials = ApiKeyCredentials(
in_headers={"Prediction-key": "<PREDICTION_KEY>"})
predictor = CustomVisionPredictionClient("<ENDPOINT_URL>", credentials)
ret, image = camera.read()
cv2.imwrite('capture.png', image)
with open("capture.png", mode="rb") as captured_image:
results = predictor.detect_image("<PROJECT_ID>", "<ITERATION_NAME>",
captured_image)
for prediction in results.predictions:
if prediction.probability > 0.9:
bbox = prediction.bounding_box
result_image = cv2.rectangle(
image, (int(bbox.left * 640), int(bbox.top * 480)),
(int((bbox.left + bbox.width) * 640),
int((bbox.top + bbox.height) * 480)), (0, 255, 0), 3)
cv2.imwrite('result.png', result_image)
camera.release()
class PredictImages:
def __init__(self):
# Load credentials from environment
# Authenticate the training client
credentials = ApiKeyCredentials(
in_headers={"Training-key": TRAINING_KEY})
trainer = CustomVisionTrainingClient(TRAINING_ENDPOINT, credentials)
# Authenticate the prediction client
prediction_credentials = ApiKeyCredentials(
in_headers={"Prediction-key": PREDICTION_KEY})
self.predictor = CustomVisionPredictionClient(PREDICTION_ENDPOINT,
prediction_credentials)
project_name = "car_seal_train_and_validation"
self.publish_iteration_name = "Iteration3"
self.max_byte_size = 4000000
projects = trainer.get_projects()
project_id = next((p.id for p in projects if p.name == project_name),
None)
print("Connecting to existing project...")
self.project = trainer.get_project(project_id)
@staticmethod
def show_prediction(image_path, predictions):
GREEN = (0, 255, 0)
BBOX_LINE_SIZE = 5
image = cv2.imread(image_path)
img_height = image.shape[0]
img_width = image.shape[1]
for prediction in predictions:
if prediction.probability < PREDICTION_THRESHOLD:
continue
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,
),
)
left = prediction.bounding_box.left * img_width
top = prediction.bounding_box.top * img_height
width = prediction.bounding_box.width * img_width
height = prediction.bounding_box.height * img_height
x0 = int(left)
y0 = int(top)
x1 = int(left + width)
y1 = int(top + height)
cv2.rectangle(image, (x0, y0), (x1, y1), GREEN, BBOX_LINE_SIZE)
cv2.imshow("image", image)
while True:
key = cv2.waitKey(0)
if key:
break
def predict_image(self, image_path: str):
image_bytes: bytes = read_and_resize_image(
image_path=image_path,
max_byte_size=self.max_byte_size,
)
print(f"Predicting on image {image_path}")
# Send image and get back the prediction results
results = self.predictor.detect_image(self.project.id,
self.publish_iteration_name,
image_bytes)
return results.predictions
# Querying custom vision to extract only the barcodes
# Now there is a trained endpoint that can be used to make a prediction
prediction_key = "<YOUR PREDICTION KEY>"
ENDPOINT = 'https://westeurope.api.cognitive.microsoft.com/'
base_image_url = "./"
image_relative_path = "barcode-on-food-item-c0bf0m.jpg"
predictor = CustomVisionPredictionClient(prediction_key, endpoint=ENDPOINT)
# Open the sample image and get back the prediction results.
with open(base_image_url + "images/" + image_relative_path,
mode="rb") as test_data:
results = predictor.detect_image('<CUSTOM_VISION_AI_PROJECT_ID>',
'Iteration1', test_data)
#------------------------------------------------------------
# Selecting the best candidates and storing the temporal
# image
class DetectedObject(object):
def __init__(self):
self.probability = 0.0
self.bounding_box_left = 0.0
self.bounding_box_top = 0.0
self.bounding_box_width = 0.0
self.bounding_box_height = 0.0
def predict_image(img, role):
start_time = time.time()
result = []
img = Image.open(img)
img.save("frame.jpg")
with open("frame.jpg", mode="rb") as frame:
if role == "person":
# Connectiong to the Face API service
subscription_key = face_api_key
base_url = face_api_url
person_group_id = face_group_id
CF.BaseUrl.set(base_url)
CF.Key.set(subscription_key)
detected_people = CF.face.detect(frame, attributes=face_features)
if len(detected_people) > 0:
face_ids = [d['faceId'] for d in detected_people]
faces = CF.face.identify(face_ids, person_group_id)
biggest_width, index = get_width(detected_people)
if (recognize_face(faces)):
result.append("member")
else:
processor = FeatureProcessor(
"feature_temp.csv", "get",
detected_people[index]["faceAttributes"])
processor.start()
result.append("stranger")
result.append(biggest_width)
else:
result.append("nothing")
result.append(0)
end_time = time.time()
elasped_time = str(int((end_time - start_time) * 1000)) + " ms"
elif role == "package":
# Connectiong to the Custom Vision service
prediction_key = package_api_key
project_id = package_api_project_id
iteration_name = package_api_iteration_name
endpoint = package_api_endpoint
predictor = CustomVisionPredictionClient(prediction_key,
endpoint=endpoint)
results = predictor.detect_image(project_id, iteration_name, frame)
max_prob = 0.77
tag = ""
package_counter = 0
for prediction in results.predictions:
if prediction.probability > max_prob:
package_counter += 1
tag = prediction.tag_name
if tag != "" and tag.lower() == "package":
result.append("package")
result.append(package_counter)
else:
result.append("nothing")
result.append(0)
end_time = time.time()
elasped_time = str(int((end_time - start_time) * 1000)) + " ms"
return result
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from msrest.authentication import ApiKeyCredentials
camera = cv2.VideoCapture(0)
camera.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
credentials = ApiKeyCredentials(
in_headers={"Prediction-key": "<Prediction-key>"})
predictor = CustomVisionPredictionClient("<Endpoint-URL>", credentials)
ret, image = camera.read()
cv2.imwrite('capture_detect.png', image)
with open("capture_detect.png", mode="rb") as captured_image:
results = predictor.detect_image("<Project-id>", "<Name-of-Iteration>",
captured_image)
for prediction in results.predictions:
if prediction.probability > 0.5:
bbox = prediction.bounding_box
cv2.putText(image, prediction.tag_name,
(int(bbox.left * 640), int(bbox.top * 480) - 4),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
result_image = cv2.rectangle(
image, (int(bbox.left * 640), int(bbox.top * 480)),
(int((bbox.left + bbox.width) * 640),
int((bbox.top + bbox.height) * 480)), (0, 255, 0), 1)
cv2.imwrite('result_detect.png', result_image)
print(prediction.tag_name)
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)
wideo = cv2.VideoCapture(1)
if (wideo.isOpened()):
while (True):
udany_odczyt, ramka = wideo.read()
if udany_odczyt:
k = cv2.waitKey(25) & 0xFF
if k == 27:
break
img = cv2.imwrite("temp.jpg", ramka)
with open("temp.jpg", "rb") as image_contents:
results = predictor.detect_image(project_id,
publish_iteration_name,
image_contents.read())
valid_predictions = [
pred for pred in results.predictions
if (pred.tag_name == "with_mask"
and pred.probability > with_mask_threshold) or (
pred.tag_name == "no_mask"
and pred.probability > no_mask_threshold)
]
# Display the results.
for prediction in valid_predictions:
print("\t" + prediction.tag_name +
": {0:.2f}%".format(prediction.probability * 100))
lx = int(prediction.bounding_box.left * ramka.shape[1])
rx = int((prediction.bounding_box.left +
def fileDialog(self):
self.filename = filedialog.askopenfilename(initialdir = "/", title = "Select A File", filetype =
(("jpeg files","*.jpg"),("all files","*.*")) )
self.label = ttk.Label(self.labelFrame, text = "")
self.label.grid(column = 1, row = 2)
self.label.configure(text = self.filename)
#following details are available in Azure Portal
ENDPOINT = "<insert Resource EndPoint>"
PROJECT_ID = "<insert Project ID>"
items=["cinthol_soap",
"nima",
"comfort_liquid",
"himalaya_neem_soap",
"himalaya_baby_shampoo",
"genteel",
"honey_apis",
"crompton_15w_bulb"]
index={"cinthol_soap":0 ,
"nima":1 ,
"comfort_liquid":2,
"himalaya_neem_soap":3,
"himalaya_baby_shampoo":4,
"genteel":5,
"honey_apis":6,
"crompton_15w_bulb":7}
name={"cinthol_soap":"Cinthol Soap" ,
"nima":"Nima Soap" ,
"comfort_liquid":"Comfort Fabric Conditioner",
"himalaya_neem_soap":"Himalaya Neem Soap",
"himalaya_baby_shampoo":"Himalaya Baby Shampoo",
"genteel":"Genteel Liquid Detergent",
"honey_apis":"Apis Himalayan Honey",
"crompton_15w_bulb":"Crompton Light Bulb 15W"}
cost=[0 for i in range(8)]
price=[49.0,14.0,218.0,45.0,160.0,320.0,440.0,160.0]
#following details are available in custom vision project
prediction_key = "<enter Prediction Key >"
prediction_resource_id = "<enter Resource ID>"
publish_iteration_name = "<enter Iteration name>"
credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(endpoint=ENDPOINT, credentials=credentials)
location = self.filename
location=list(location)
destination=[]
for itr in range(len(location)):
if(location[itr]=="/"):
destination.append("\\")
else:
destination.append(location[itr])
pic = ''.join(destination)
with open(pic, mode="rb") as test_data:
results = predictor.detect_image(PROJECT_ID, published_name="Iteration1",image_data =test_data.read(),iteration_id= ' e32a6cd8-9a11-42a6-852c-0ec836455726')
for prediction in results.predictions:
if(prediction.tag_name in items):
print ("\t" + prediction.tag_name + ": {0:.2f}%".format(prediction.probability * 100))
cost[index[prediction.tag_name]]+=1
dash=['-' for i in range(60)]
tot=0
qty=0
#location of test file to store the result
sys.stdout=open("<enter the location of destination text file>","w")
print("".join(dash))
print("Photo Bill Mart")
print("".join(dash))
print('{:30s} {:3s} {:10s} {:3s}'.format("Item Name","Qty","Cost","MRP"))
print("".join(dash))
for i in range(8):
if(cost[i]>0):
qty+=cost[i]
print('{:30s} {:3d} {:7.2f} {:7.2f}'.format(name[items[i]], cost[i], price[i]*cost[i],price[i]))
tot+=(price[i]*cost[i])
print("".join(dash))
print('{:30s} {:3d} {:7.2f}'.format("Total",qty,tot))
print("".join(dash))
sys.stdout.close()
#print("break\n")
img = Image.open(self.filename)
img = img.resize((450, 350), Image.ANTIALIAS)
photo = ImageTk.PhotoImage(img)
self.label2 = Label(image=photo,text="Captured Image",compound='bottom')
self.label2.image = photo
self.label2.grid(column=1, row=4)
self.configfile = Text(self.labelFrame_res, wrap=WORD, width=60, height= 20)
with open("<enter the location of destination text file>", 'r') as f:
self.configfile.insert(INSERT, f.read())
self.configfile.grid(column=3,row=4)
exit(-1)
print("Training...")
iteration = trainer.train_project(project.id)
while iteration.status != "Completed":
iteration = trainer.get_iteration(project.id, iteration.id)
print("Training status: " + iteration.status)
time.sleep(1)
# The iteration is now trained. Publish it to the project endpoint
trainer.publish_iteration(project.id, iteration.id, publish_iteration_name,
prediction_resource_id)
print("Done!")
# Now there is a trained endpoint that can be used to make a prediction
# Open the sample image and get back the prediction results.
with open(base_image_location + "images/Test/test_od_image.jpg",
mode="rb") as test_data:
results = predictor.detect_image(project.id, publish_iteration_name,
test_data)
# Display the results.
for prediction in results.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))
class analyze:
def __init__(self, path_to_image_to_predict):
self.model = CustomVisionPredictionClient(prediction_key,
endpoint=ENDPOINT)
self.fires = []
self.smoke = []
self.image_path = path_to_image_to_predict
# updates using the self.image_path
def predictUpdate(self):
fires = []
smoke = []
with open(self.image_path, mode="rb") as test_data:
results = self.model.detect_image(project_id, publishedName,
test_data)
for pred in results.predictions:
if (pred.tag_name == fire_classifier
and pred.probability >= fireThreshold):
fires.append(pred)
for pred in results.predictions:
if (pred.tag_name == smoke_classifier
and pred.probability >= smokeThreshold):
smoke.append(pred)
self.fires = fires
self.smoke = smoke
def __areBothEmpty(self):
return (len(self.fires) == 0 and len(self.smoke) == 0)
# returns original list after prediction
def getFireSmoke(self):
if self.__areBothEmpty():
self.predictUpdate()
return self.fires, self.smoke
# returns two lists of distances from the center of frame
def returnDistances(self):
if self.__areBothEmpty():
self.predictUpdate()
fireDist = []
smokeDist = []
for inst in self.fires:
x, y = inst.bounding_box.left, inst.bounding_box.top
delta_x, delta_y = 0.5 - x, 0.5 - y
dist = math.sqrt(delta_x**2 + delta_y**2)
fireDist.append(dist)
for inst in self.smoke:
x, y = inst.bounding_box.left, inst.bounding_box.top
delta_x, delta_y = 0.5 - x, 0.5 - y
dist = math.sqrt(delta_x**2 + delta_y**2)
fireDist.append(dist)
return fireDist, smokeDist
# boxes the object and labels with tag name and probability for matplotlib. for direct_run
def __boxObject(self, obj_list, droneInstance, ax, im_width, im_height):
scoring_array = [0] * 250000
for inst in obj_list:
x, y = inst.bounding_box.left * im_width, inst.bounding_box.top * im_height
label = inst.tag_name
probability = inst.probability
# scale to frame dimensions
pic_coord = (x, y)
# dimensions of recognized region
obj_width = inst.bounding_box.width * im_width
obj_height = inst.bounding_box.height * im_height
# display
rect = patches.Rectangle(pic_coord,
obj_width,
obj_height,
edgecolor='r',
fill=False)
plt.text(pic_coord[0], pic_coord[1],
f'{label}: {round(probability, 3)}')
ax.add_patch(rect)
# scoring
scoring_array = self.__score(scoring_array, x, y, obj_width,
obj_height)
# export to FireDrone
droneInstance.score(scoring_array)
# changes scoring array for one instance of fire. for direct_run
def __score(self, scoring_array, top_left_x, top_left_y, width, height):
width = int(round(width))
height = int(round(height))
top_left_x = int(round(top_left_x))
top_left_y = int(round(top_left_y))
arr_index = top_left_x + top_left_y * 500
for _ in range(height):
for i in range(arr_index, arr_index + width):
scoring_array[i] = 1
arr_index += 500
return scoring_array
# display on matplotlib. Use only with direct run. for direct_run
def dispPredict(self, droneInstance, ax):
if self.__areBothEmpty():
self.predictUpdate()
if self.__areBothEmpty():
return
im_width, im_height = Image.open(self.image_path).size
img = np.array(Image.open(self.image_path), dtype=np.uint8)
self.__boxObject(self.fires, droneInstance, ax, im_width, im_height)
ax.imshow(img)
plt.pause(1)
# returns nearest drone coordinates using image coordinates
def __img_to_drone_coords(self, im_x, im_y, im_width, im_height):
im_x, im_y = int(round(im_x)), int(round(im_y))
drone_x = int(round((im_x - 250) / 100))
drone_y = int(round((im_height - im_y - 250) / 100))
max_drone_x = int(round((im_width - 500) / 100))
max_drone_y = int(round((im_height - 500) / 100))
# bounding
if drone_x < 0:
drone_x = 0
elif drone_x > max_drone_x:
drone_x = max_drone_x
if drone_y < 0:
drone_y = 0
elif drone_y > max_drone_y:
drone_y = max_drone_y
return drone_x, drone_y
# boxes objects and returns a Draw PIL image and list of object center coordinates. For reverse_run
def __imgBox(self, obj_list, image, im_width, im_height):
im = image.convert('RGBA')
drawn = Draw(im)
fontsize = im_height * 0.01
font = ImageFont.truetype('arial.ttf', int(round(fontsize)))
coords = []
for inst in obj_list:
label = inst.tag_name
probability = inst.probability
x0, y0 = inst.bounding_box.left * im_width, inst.bounding_box.top * im_height
x1, y1 = x0 + inst.bounding_box.width * im_width, y0 + inst.bounding_box.height * im_height
xC, yC = abs(x0 + x1) / 2, abs(y0 + y1) / 2
xC, yC = self.__img_to_drone_coords(xC, yC, im_width, im_height)
coords.append((xC, yC))
drawn.rectangle([(x0, y0), (x1, y1)], outline=(255, 0, 0, 255))
drawn.text((x0, y0),
f'{label}: {round(probability, 3)}; ({xC}, {yC})',
fill=(0, 0, 0, 255),
font=font)
return im, coords
# for reverse_run
def imgPredict(self):
if self.__areBothEmpty():
self.predictUpdate()
if self.__areBothEmpty():
return
img = Image.open(self.image_path)
im_width, im_height = img.size
draw, coordList = self.__imgBox(self.fires, img, im_width, im_height)
return draw, coordList
