Bitmask Labels

# Import dependencies
import numpy as np
from PIL import Image

from encord import EncordUserClient
from encord.objects import Object
from encord.objects.coordinates import BitmaskCoordinates

# User input
SSH_PATH = "/Users/chris-encord/ssh-private-key.txt"  # Replace with the file path to your SSH private key
PROJECT_ID = "00000000-0000-0000-0000-000000000000"  # Replace with the unique ID for the Project
DATA_TITLE = "cherries-001.jpg"  # Replace with the title of the image or video to label
ONTOLOGY_OBJECT_TITLE = "Cherry"  # Replace with the title of a Bitmask object in your Ontology
MASK_PATH = "cherries-001-mask.png"  # Replace with the path to your mask. Non-zero pixels are inside the mask.
FRAME = 0  # Replace with the frame number to label. Use 0 for a single image.

# Create user client using ssh key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=SSH_PATH,
    # For US platform users use "https://api.us.encord.com"
    domain="https://api.encord.com",
)

project = user_client.get_project(PROJECT_ID)

# Read the mask and convert it to a boolean array: True inside the mask, False outside
mask = np.array(Image.open(MASK_PATH).convert("L")) > 0

# Get the label row for the image or video
label_rows = project.list_label_rows_v2(data_title_eq=DATA_TITLE)
if not label_rows:
    raise ValueError(f"No label row found for {DATA_TITLE}")
label_row = label_rows[0]
label_row.initialise_labels()

# The mask must be exactly the same size as the image or video frame
if mask.shape != (label_row.height, label_row.width):
    raise ValueError(
        f"The mask is {mask.shape[1]}x{mask.shape[0]} pixels, "
        f"but {DATA_TITLE} is {label_row.width}x{label_row.height} pixels."
    )

# Create a Bitmask instance and add the mask to the frame
bitmask_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)
bitmask_object_instance = bitmask_ontology_object.create_instance()
bitmask_object_instance.set_for_frames(
    coordinates=BitmaskCoordinates(mask),
    frames=FRAME,
    manual_annotation=False,
)
label_row.add_object_instance(bitmask_object_instance)

# Save the label row
label_row.save()
print(f"Uploaded the Bitmask from {MASK_PATH} to {DATA_TITLE}")

# Import dependencies
import json
from pathlib import Path
import numpy as np
from encord.objects.coordinates import BitmaskCoordinates
from PIL import Image

# Read the JSON file.
# Replace labels.json with the path to the JSON file containing your Bitmask
labels = json.loads(Path("labels.json").read_text())
output_folder = Path("output")
output_folder.mkdir(parents=True, exist_ok=True)

# Finds the rleString and saves it to a .png image
for label_row in labels:
    for du in label_row["data_units"].values():
        frame_labels = du["labels"]
        # Videos, image sequences, and DICOM are keyed by frame or slice number.
        # A single image stores its objects directly, so treat it as frame 0.
        if "objects" in frame_labels:
            frame_labels = {"0": frame_labels}
        for slice_num, slice_labels in frame_labels.items():
            for obj in slice_labels["objects"]:
                # Skip objects that are not Bitmasks, such as bounding boxes or polygons
                if obj.get("shape") != "bitmask":
                    continue
                bmc = BitmaskCoordinates.from_dict(obj)
                nparr = np.array(bmc)
                img = Image.fromarray(nparr)
                # img.show()
                # Object hashes can contain "/", which is not allowed in file names
                safe_hash = obj["objectHash"].replace("/", "_")
                img.save(output_folder / f"mask_{int(slice_num):05d}_{safe_hash}.png")
print("Decoding complete.")

import json
from pathlib import Path
from encord.objects.coordinates import BitmaskCoordinates

# Read the JSON file. Replace labels.json with the path to the JSON file containing your Bitmask
labels = json.loads(Path("labels.json").read_text())

for label_row in labels:
    for du in label_row["data_units"].values():
        frame_labels = du["labels"]
        # A single image stores its objects directly, so treat it as frame 0
        if "objects" in frame_labels:
            frame_labels = {"0": frame_labels}
        for frame_data in frame_labels.values():
            for obj in frame_data["objects"]:
                if obj.get("shape") != "bitmask":
                    continue
                # Create a numpy array
                np_mask = BitmaskCoordinates.from_dict(obj).to_numpy_array()
                print(np_mask.astype(int))

from pycocotools.coco import COCO
import numpy as np
from pycocotools import mask as maskUtils
from PIL import Image
import json


# Read the COCO file. Replace 'labels.json' with the path to your COCO format annotations file
coco_annotations_path = 'labels.json'
coco = COCO(coco_annotations_path)

# Get all annotation IDs (you might want to filter or select specific ones)
annIds = coco.getAnnIds()
anns = coco.loadAnns(annIds)

# Decode each rleString and save as a .png image
for ann in anns:
    if 'segmentation' in ann and isinstance(ann['segmentation'], dict):

        rle = ann['segmentation']

        mask = maskUtils.decode(rle)

        img = Image.fromarray(mask * 255).convert('L')  # Convert to grayscale

        # Save one file per annotation, named after the annotation ID
        img.save(f"mask_{ann['id']}.png")

print("Decoding complete.")