def save_image(self):
"""Save a timestamped image with bounding boxes around plates."""
draw = ImageDraw.Draw(self._image)
decimal_places = 3
for vehicle in self._results:
box = (
round(vehicle['box']["ymin"] / self._image_height,
decimal_places),
round(vehicle['box']["xmin"] / self._image_width,
decimal_places),
round(vehicle['box']["ymax"] / self._image_height,
decimal_places),
round(vehicle['box']["xmax"] / self._image_width,
decimal_places),
)
text = vehicle['plate']
draw_box(
draw,
box,
self._image_width,
self._image_height,
text=text,
color=RED,
)
latest_save_path = self._save_file_folder / f"{self._name}_latest.png"
self._image.save(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = self._save_file_folder / f"{self._name}_{self._last_detection}.png"
self._image.save(timestamp_save_path)
_LOGGER.info("platerecognizer saved file %s", timestamp_save_path)
def save_image(self, pil_image: Image, directory: Path):
"""Draws the actual bounding box of the detected objects."""
image_width, image_height = pil_image.size
draw = ImageDraw.Draw(pil_image)
for face in self.faces:
if not self._show_boxes:
break
name = face["name"]
confidence = face["confidence"]
box = face["bounding_box"]
box_label = f"{name}: {confidence:.1f}%"
draw_box(
draw,
(box["y_min"], box["x_min"], box["y_max"], box["x_max"]),
image_width,
image_height,
text=box_label,
color=RED,
)
latest_save_path = (
directory / f"{get_valid_filename(self._name).lower()}_latest.jpg")
pil_image.save(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = directory / f"{self._name}_{self._last_detection}.jpg"
pil_image.save(timestamp_save_path)
_LOGGER.info("Deepstack saved file %s", timestamp_save_path)
def save_image(self, targets, directory) -> str:
"""Draws the actual bounding box of the detected objects.
Returns: saved_image_path, which is the path to the saved timestamped file if configured, else the default saved image.
"""
try:
img = self._image.convert("RGB")
except UnidentifiedImageError:
_LOGGER.warning("Rekognition unable to process image, bad data")
return
draw = ImageDraw.Draw(img)
roi_tuple = tuple(self._roi_dict.values())
if roi_tuple != DEFAULT_ROI and self._show_boxes:
draw_box(
draw,
roi_tuple,
img.width,
img.height,
text="ROI",
color=GREEN,
)
for obj in targets:
if not self._show_boxes:
break
name = obj["name"]
confidence = obj["confidence"]
box = obj["bounding_box"]
centroid = obj["centroid"]
box_label = f"{name}: {confidence:.1f}%"
draw_box(
draw,
(box["y_min"], box["x_min"], box["y_max"], box["x_max"]),
img.width,
img.height,
text=box_label,
color=RED,
)
# draw bullseye
draw.text(
(centroid["x"] * img.width, centroid["y"] * img.height),
text="X",
fill=RED,
)
latest_save_path = (
directory / f"{get_valid_filename(self._name).lower()}_latest.jpg")
img.save(latest_save_path)
_LOGGER.info("Rekognition saved file %s", latest_save_path)
saved_image_path = latest_save_path
if self._save_timestamped_file:
timestamp_save_path = directory / f"{self._name}_{self._last_detection}.jpg"
img.save(timestamp_save_path)
_LOGGER.info("Rekognition saved file %s", timestamp_save_path)
saved_image_path = timestamp_save_path
return str(saved_image_path)
def save_image(self, image, targets, confidence, directory):
"""Draws the actual bounding box of the detected objects."""
try:
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
except UnidentifiedImageError:
_LOGGER.warning("Deepstack unable to process image, bad data")
return
draw = ImageDraw.Draw(img)
roi_tuple = tuple(self._roi_dict.values())
if roi_tuple != DEFAULT_ROI:
draw_box(
draw,
roi_tuple,
img.width,
img.height,
text="ROI",
color=GREEN,
)
for obj in self._objects:
if not obj["name"] in self._targets:
continue
name = obj["name"]
confidence = obj["confidence"]
box = obj["bounding_box"]
centroid = obj["centroid"]
box_label = f"{name}: {confidence:.1f}%"
if object_in_roi(self._roi_dict, centroid):
box_colour = RED
else:
box_colour = YELLOW
draw_box(
draw,
(box["y_min"], box["x_min"], box["y_max"], box["x_max"]),
img.width,
img.height,
text=box_label,
color=box_colour,
)
# draw bullseye
draw.text(
(centroid["x"] * img.width, centroid["y"] * img.height),
text="X",
fill=box_colour,
)
latest_save_path = (
directory / f"{get_valid_filename(self._name).lower()}_latest.jpg")
img.save(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = directory / f"{self._name}_{self._last_detection}.jpg"
img.save(timestamp_save_path)
_LOGGER.info("Deepstack saved file %s", timestamp_save_path)
def save_image(self, image, people, faces, directory):
"""Save a timestamped image with bounding boxes around targets."""
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
draw = ImageDraw.Draw(img)
for person in people:
box = hound.bbox_to_tf_style(person["boundingBox"],
self._image_width, self._image_height)
draw_box(draw,
box,
self._image_width,
self._image_height,
color=RED)
for face in faces:
age = str(face["age"])
gender = face["gender"]
face_description = f"{gender}_{age}"
bbox = hound.bbox_to_tf_style(face["boundingBox"],
self._image_width,
self._image_height)
draw_box(
draw,
bbox,
self._image_width,
self._image_height,
text=face_description,
color=RED,
)
latest_save_path = directory + "{}_latest.jpg".format(self._name)
out_file = open(latest_save_path, "wb")
img.save(out_file, format="JPEG")
out_file.flush()
os.fsync(out_file)
out_file.close()
self.fire_saved_file_event(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = directory + "{} {}.jpg".format(
self._name, self._last_detection)
out_file = open(timestamp_save_path, "wb")
img.save(out_file, format="JPEG")
out_file.flush()
os.fsync(out_file)
out_file.close()
self.fire_saved_file_event(timestamp_save_path)
_LOGGER.info("Saved %s", timestamp_save_path)
def save_image(self, image, objects, target, directory):
"""Save a timestamped image with bounding boxes around targets."""
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
draw = ImageDraw.Draw(img)
for obj in objects:
obj_confidence = gv.format_confidence(obj.score)
if obj_confidence > self._confidence:
if obj.name.lower(
) == target and obj_confidence >= self._confidence:
box = gv.get_box(obj.bounding_poly.normalized_vertices)
draw_box(draw, box, img.width, img.height)
latest_save_path = directory + "google_vision_latest_{}.jpg".format(
target)
img.save(latest_save_path)
def save_image(self, image, predictions, target, directory):
"""Save a timestamped image with bounding boxes around targets."""
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
draw = ImageDraw.Draw(img)
for prediction in predictions:
prediction_confidence = ds.format_confidence(prediction["score"])
if (prediction["name"] in target
and prediction_confidence >= self._confidence):
draw_box(
draw,
prediction['box'],
self._image_width,
self._image_height,
text=str(prediction_confidence),
color=RED,
)
latest_save_path = directory + "{}_latest_{}.jpg".format(
self._name, target[0])
img.save(latest_save_path)
def save_image(self, image, people, directory):
"""Save a timestamped image with bounding boxes around targets."""
try:
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
except UnidentifiedImageError:
_LOGGER.warning("Sighthound unable to process image, bad data")
return
draw = ImageDraw.Draw(img)
for person in people:
box = hound.bbox_to_tf_style(person["boundingBox"],
self._image_width, self._image_height)
draw_box(draw, box, self._image_width, self._image_height)
latest_save_path = directory / f"{self._name}_latest.jpg"
img.save(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = directory / f"{self._name}_{self._last_detection}.jpg"
img.save(timestamp_save_path)
_LOGGER.info("Sighthound saved file %s", timestamp_save_path)
def save_image(self):
draw = ImageDraw.Draw(self._image)
roi_tuple = (self._y_min, self._x_min, self._y_max, self._x_max)
draw_box(
draw,
roi_tuple,
self._image_width,
self._image_height,
color=RED,
)
latest_save_path = (
self._save_file_folder /
f"{get_valid_filename(self._name).lower()}_latest.png")
self._image.save(latest_save_path)
_LOGGER.info("Rekognition_text saved file %s", latest_save_path)
if self._save_timestamped_file:
now_str = dt_util.now().strftime(DATETIME_FORMAT)
timestamp_save_path = self._save_file_folder / f"{self._name}_{now_str}.png"
self._image.save(timestamp_save_path)
_LOGGER.info("Rekognition_text saved file %s", timestamp_save_path)
def save_image(self, image, response, target, confidence, directory,
camera_entity):
"""Draws the actual bounding box of the detected objects."""
try:
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
except UnidentifiedImageError:
_LOGGER.warning("Sighthound unable to process image, bad data")
return
draw = ImageDraw.Draw(img)
for label in response["Labels"]:
if (label["Confidence"] < confidence) or (label["Name"] != target):
continue
for instance in label["Instances"]:
box = instance["BoundingBox"]
x, y, w, h = box["Left"], box["Top"], box["Width"], box[
"Height"]
x_max, y_max = x + w, y + h
box_label = f'{label["Name"]}: {label["Confidence"]:.1f}%'
draw_box(
draw,
(y, x, y_max, x_max),
img.width,
img.height,
text=box_label,
)
latest_save_path = (
directory / f"{get_valid_filename(self._name).lower()}_latest.jpg")
img.save(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = directory / f"{self._name}_{self._last_detection}.jpg"
img.save(timestamp_save_path)
_LOGGER.info("Deepstack saved file %s", timestamp_save_path)
def save_image(self, image, predictions, target, directory):
"""Save a timestamped image with bounding boxes around targets."""
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
draw = ImageDraw.Draw(img)
for prediction in predictions:
prediction_confidence = ds.format_confidence(
prediction["confidence"])
if (prediction["label"] == target
and prediction_confidence >= self._confidence):
box = get_box(prediction, self._image_width,
self._image_height)
draw_box(
draw,
box,
self._image_width,
self._image_height,
text=str(prediction_confidence),
color=RED,
)
latest_save_path = directory + "{}_latest_{}.jpg".format(
self._name, target)
img.save(latest_save_path)
if self._save_timestamped_file:
timestamp_save_path = directory + "{}_{}_{}.jpg".format(
self._name, target, self._last_detection)
out_file = open(timestamp_save_path, "wb")
img.save(out_file, format="JPEG")
out_file.flush()
os.fsync(out_file)
out_file.close()
self.fire_saved_file_event(timestamp_save_path)
_LOGGER.info("Saved bounding box image to %s", timestamp_save_path)
def save_image(image, response, target, confidence, directory, camera_entity):
"""Draws the actual bounding box of the detected objects."""
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
draw = ImageDraw.Draw(img)
boxes = []
for label in response["Labels"]:
if (label["Confidence"] < confidence) or (label["Name"] != target):
continue
for instance in label["Instances"]:
box = instance["BoundingBox"]
x, y, w, h = box["Left"], box["Top"], box["Width"], box["Height"]
x_max, y_max = x + w, y + h
box_label = f'{label["Name"]}: {label["Confidence"]:.1f}%'
draw_box(
draw, (y, x, y_max, x_max), img.width, img.height, color=(0, 212, 0)
)
# Use draw for the text so you can give it a color that is actually readable
left, top, line_width, font_height = (
img.width * box["Left"],
img.height * box["Top"],
3,
12,
)
draw.text(
(left + line_width, abs(top - line_width - font_height)), box_label
)
latest_save_path = os.path.join(
directory, get_valid_filename(camera_entity).lower() + "_latest.jpg"
)
img.save(latest_save_path)
def _save_image(self, image, matches, paths):
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
img_width, img_height = img.size
draw = ImageDraw.Draw(img)
# Draw custom global region/area
if self._area != [0, 0, 1, 1]:
draw_box(draw, self._area, img_width, img_height, "Detection Area",
(0, 255, 255))
for label, values in matches.items():
# Draw custom label regions/areas
if label in self._label_areas and self._label_areas[label] != [
0, 0, 1, 1
]:
box_label = f"{label.capitalize()} Detection Area"
draw_box(
draw,
self._label_areas[label],
img_width,
img_height,
box_label,
(0, 255, 0),
)
# Draw detected objects
for instance in values:
box_label = f'{label} {instance["score"]:.1f}%'
# Already scaled, use 1 for width and height
draw_box(
draw,
instance["box"],
img_width,
img_height,
box_label,
(255, 255, 0),
)
for path in paths:
_LOGGER.info("Saving results image to %s", path)
if not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path), exist_ok=True)
img.save(path)
def _save_image(self, image, matches, paths):
img = Image.open(io.BytesIO(bytearray(image))).convert("RGB")
img_width, img_height = img.size
draw = ImageDraw.Draw(img)
# Draw custom global region/area
if self._area != [0, 0, 1, 1]:
draw_box(
draw, self._area, img_width, img_height, "Detection Area", (0, 255, 255)
)
for category, values in matches.items():
# Draw custom category regions/areas
if category in self._category_areas and self._category_areas[category] != [
0,
0,
1,
1,
]:
label = f"{category.capitalize()} Detection Area"
draw_box(
draw,
self._category_areas[category],
img_width,
img_height,
label,
(0, 255, 0),
)
# Draw detected objects
for instance in values:
label = "{} {:.1f}%".format(category, instance["score"])
draw_box(
draw, instance["box"], img_width, img_height, label, (255, 255, 0)
)
for path in paths:
_LOGGER.info("Saving results image to %s", path)
if not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path), exist_ok=True)
img.save(path)
