Import to Consensus Branches

# Import dependencies
import os
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import LabelRowV2, Object, OntologyStructure, ObjectInstance
from encord.objects.coordinates import BoundingBoxCoordinates, RotatableBoundingBoxCoordinates, PolygonCoordinates, PolylineCoordinates, PointCoordinate, BitmaskCoordinates

# Configuration
SSH_PATH = "<file-path-to-ssh-private-key>"
PROJECT_ID = "<unique-id-of-your-project>"
CONSENSUS_BRANCH_NAME = "<name-of-your-label-branch>"
ONTOLOGY_OBJECT_TITLE = "<name-of-ontology-object>" # Name of object label in your Ontology
DATA_UNIT_TITLES = ["<data-unit-title-1>", "<data-unit-title-2>"]  # List of specific data units

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
all_consensus_branch_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit titles
consensus_branch_rows = [
    row for row in all_consensus_branch_rows 
    if row.data_title in DATA_UNIT_TITLES
]

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Retrieve the specified ontology object by title
ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

# Initialize labels for each selected label row in the label branch
with project.create_bundle() as bundle:
    for row in consensus_branch_rows:
        row.initialise_labels(bundle=bundle)

# Add bounding box labels to each filtered label row
for row in consensus_branch_rows:
    # Instantiate an object instance for bounding box labels
    inst = ontology_object.create_instance()
    inst.set_for_frames(
        coordinates=BoundingBoxCoordinates(
            height=0.1,
            width=0.1,
            top_left_x=0.5,
            top_left_y=0.5,
        ),
        frames=0,  # Apply to the specified frame
        manual_annotation=False,  # Set to False as this is a label
        confidence=1, # Confidence of your label
    )

    # Add the label instance to the label row
    row.add_object_instance(inst)

with project.create_bundle() as bundle:
    # Save the row with labels within the bundle
    for row in consensus_branch_rows:
        row.save(bundle=bundle)

# Import dependencies
import os
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import LabelRowV2, Object, OntologyStructure, ObjectInstance
from encord.objects.coordinates import BoundingBoxCoordinates, RotatableBoundingBoxCoordinates, PolygonCoordinates, PolylineCoordinates, PointCoordinate, BitmaskCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "80ae53e3-594c-4120-a108-ee4af105bff3"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"
ONTOLOGY_OBJECT_TITLE = "Cherry" # Name of object label in your Ontology
DATA_UNIT_TITLES = ["cherry_001.png"]  # List of specific data units

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
all_consensus_branch_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit titles
consensus_branch_rows = [
    row for row in all_consensus_branch_rows 
    if row.data_title in DATA_UNIT_TITLES
]

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Retrieve the specified ontology object by title
ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

# Initialize labels for each selected label row in the label branch
with project.create_bundle() as bundle:
    for row in consensus_branch_rows:
        row.initialise_labels(bundle=bundle)

# Add bounding box labels to each filtered label row
for row in consensus_branch_rows:
    # Instantiate an object instance for bounding box labels
    inst = ontology_object.create_instance()
    inst.set_for_frames(
        coordinates=BoundingBoxCoordinates(
            height=0.1,
            width=0.1,
            top_left_x=0.5,
            top_left_y=0.5,
        ),
        frames=0,  # Apply to the specified frame
        manual_annotation=False,  # Set to False as this is a label
        confidence=1, # Confidence of your label
    )

    # Add the label instance to the label row
    row.add_object_instance(inst)

with project.create_bundle() as bundle:
    for row in consensus_branch_rows:
        # Save the row with labels within the bundle
        row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import BoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"
ONTOLOGY_OBJECT_TITLE = "Cherry"
DATA_UNIT_TITLES = ["Cherries_video.mp4"]  # List of specific video data units

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
all_consensus_branch_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit titles
consensus_branch_rows = [
    row for row in all_consensus_branch_rows 
    if row.data_title in DATA_UNIT_TITLES
]

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Retrieve the specified ontology object by title
box_ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

with project.create_bundle() as bundle:
    # Initialize labels for each selected label row in the label branch
    for label_row in consensus_branch_rows:
        label_row.initialise_labels(bundle=bundle)

# Define frame coordinates for video tracking
coordinates_per_frame = {
    103: BoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.2,
        top_left_y=0.2,
    ),
    104: BoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.3,
        top_left_y=0.3,
    ),
    105: BoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.4,
        top_left_y=0.4,
    ),
}

# Add bounding box labels to each filtered label row across specified frames
for label_row in consensus_branch_rows:
    # Instantiate an object instance for bounding box labels
    box_object_instance = box_ontology_object.create_instance()
    
    # Apply bounding box coordinates for each specified frame
    for frame_number, coordinates in coordinates_per_frame.items():
        box_object_instance.set_for_frames(
            coordinates=coordinates, 
            frames=frame_number,  # Specify the frame number
            manual_annotation=False  # Mark as a label
        )
    
    # Add the object instance to the label row
    label_row.add_object_instance(box_object_instance)
    
with project.create_bundle() as bundle:
    for label_row in consensus_branch_rows:
        # Save the label row with the updated labels within the bundle
        label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import BoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-II"
ONTOLOGY_OBJECT_TITLE = "Cherry"
DATA_UNIT_TITLES = ["cherry_001.png"]  # List of specific image data units

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
all_consensus_branch_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit titles
consensus_branch_rows = [
    row for row in all_consensus_branch_rows 
    if row.data_title in DATA_UNIT_TITLES
]

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Retrieve the specified ontology object by title
box_ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

with project.create_bundle() as bundle:
    # Initialize labels for each selected label row in the label branch
    for label_row in consensus_branch_rows:
        label_row.initialise_labels(bundle=bundle)

# Add bounding box labels to each filtered label row
for label_row in consensus_branch_rows:
    # Define bounding box coordinates for each label
    bounding_boxes = [
        BoundingBoxCoordinates(height=0.1, width=0.1, top_left_x=0.2, top_left_y=0.2),
        BoundingBoxCoordinates(height=0.1, width=0.1, top_left_x=0.3, top_left_y=0.3),
        BoundingBoxCoordinates(height=0.1, width=0.1, top_left_x=0.4, top_left_y=0.4),
    ]

    # Instantiate and set labels for each bounding box
    for coordinates in bounding_boxes:
        box_object_instance = box_ontology_object.create_instance()
        box_object_instance.set_for_frames(
            coordinates=coordinates,
            frames=0,  # Image frame
            manual_annotation=False,  # Mark as label
            confidence=1.0,
        )

        # Add each object instance to the label row
        label_row.add_object_instance(box_object_instance)
    
with project.create_bundle() as bundle:
    for label_row in consensus_branch_rows:
        # Save the label row with the updated labels within the bundle
        label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import BoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-II"
ONTOLOGY_OBJECT_TITLE = "Cherry"
DATA_UNIT_TITLES = ["Cherries_video.mp4"]  # List of specific video data units

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
all_consensus_branch_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit titles
consensus_branch_rows = [
    row for row in all_consensus_branch_rows 
    if row.data_title in DATA_UNIT_TITLES
]

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Retrieve the specified ontology object by title
box_ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

with project.create_bundle() as bundle:
    # Initialize labels for each selected label row in the label branch
    for label_row in consensus_branch_rows:
        label_row.initialise_labels(bundle=bundle)

# Define frame coordinates for tracking across multiple frames for each object
tracking_coordinates = [
    {  # First object tracked across frames 103, 104, 105
        103: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.2, top_left_y=0.2),
        104: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.3, top_left_y=0.3),
        105: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.4, top_left_y=0.4)
    },
    {  # Second object tracked across frames 206, 207, 208
        206: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.2, top_left_y=0.2),
        207: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.3, top_left_y=0.3),
        208: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.4, top_left_y=0.4)
    },
    {  # Third object tracked across frames 313, 315, 317
        313: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.2, top_left_y=0.2),
        315: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.3, top_left_y=0.3),
        317: BoundingBoxCoordinates(height=0.5, width=0.5, top_left_x=0.4, top_left_y=0.4)
    },
]

# Add bounding box labels to each filtered label row across specified frames
for label_row in consensus_branch_rows:
    for frame_coordinates in tracking_coordinates:
        box_object_instance = box_ontology_object.create_instance()
        
        for frame_number, coordinates in frame_coordinates.items():
            box_object_instance.set_for_frames(
                coordinates=coordinates, 
                frames=frame_number,
                manual_annotation=False,  # Mark as a label
                confidence=1.0
            )
        
        # Add each object instance to the label row
        label_row.add_object_instance(box_object_instance)
    
with project.create_bundle() as bundle:
    for label_row in consensus_branch_rows:
        # Save the label row with the updated labels within the bundle
        label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import RotatableBoundingBoxCoordinates

# Configuration
SSH_PATH = "<file-path-to-ssh-private-key>"
PROJECT_ID = "<unique-id-for-project>"
CONSENSUS_BRANCH_NAME = "<name-of-your-label-branch>"
ONTOLOGY_OBJECT_TITLE = "<rotatable-bounding-box-class-title>"
DATA_UNIT_TITLES = ["<data-unit-title-1>", "<data-unit-title-2>"]  # Specify the data unit titles here

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
all_consensus_branch_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit titles
consensus_branch_rows = [
    row for row in all_consensus_branch_rows 
    if row.data_title in DATA_UNIT_TITLES
]

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Retrieve the specified ontology object by title
rbb_ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

with project.create_bundle() as bundle:
    # Initialize labels for each selected label row in the label branch
    for label_row in consensus_branch_rows:
        label_row.initialise_labels(bundle=bundle)

# Define rotatable bounding box coordinates and frame for each object
rotatable_bounding_box_labels = [
    {
        "frame_number": 0,
        "coordinates": RotatableBoundingBoxCoordinates(
            height=0.3,
            width=0.2,
            top_left_x=0.1,
            top_left_y=0.1,
            theta=15  # Angle of rotation in degrees
        ),
    },
    {
        "frame_number": 5,
        "coordinates": RotatableBoundingBoxCoordinates(
            height=0.25,
            width=0.25,
            top_left_x=0.15,
            top_left_y=0.15,
            theta=30
        ),
    },
    {
        "frame_number": 10,
        "coordinates": RotatableBoundingBoxCoordinates(
            height=0.2,
            width=0.3,
            top_left_x=0.2,
            top_left_y=0.2,
            theta=45
        ),
    },
]

# Add rotatable bounding box labels to each filtered label row
for label_row in consensus_branch_rows:
    for label in rotatable_bounding_box_labels:
        rbb_object_instance = rbb_ontology_object.create_instance()
        
        rbb_object_instance.set_for_frames(
            coordinates=label["coordinates"],
            frames=label["frame_number"],
            manual_annotation=False,  # Mark as a label
            confidence=1.0
        )
        
        # Link the object instance to the label row
        label_row.add_object_instance(rbb_object_instance)
    
with project.create_bundle() as bundle:
    for label_row in consensus_branch_rows:
        # Save the label row with the updated labels within the bundle
        label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import RotatableBoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"
DATA_UNIT_TITLE = "apple_001.jpg"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Other type of fruit"  # Ontology class title for rotatable bounding box

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path=Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project = user_client.get_project(PROJECT_ID)
consensus_branch_rows = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,
    data_title_eq=DATA_UNIT_TITLE
)

if not consensus_branch_rows:
    print("No matching data unit found in the specified branch.")
else:
    print("Data unit found:", consensus_branch_rows[0].data_title)

# Retrieve the specified ontology object by title
rbb_ontology_object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE,
    type_=Object
)

# Prepare for label imports by creating a bundle
with project.create_bundle() as bundle:
    # Initialize labels for the label row in the label branch
    label_row = consensus_branch_rows[0]
    label_row.initialise_labels(bundle=bundle)

# Define the rotatable bounding box coordinates for label
rbb_coordinates = RotatableBoundingBoxCoordinates(
    height=0.23,
    width=0.13,
    top_left_x=0.3,
    top_left_y=0.5,
    theta=95  # Angle of rotation in degrees
)

# Add rotatable bounding box label to the label row
rbb_object_instance = rbb_ontology_object.create_instance()
rbb_object_instance.set_for_frames(
    coordinates=rbb_coordinates,
    frames=0,  # Frame for the image
    manual_annotation=False,  # Mark as a label
    confidence=1.0
)

# Link the object instance to the label row
label_row.add_object_instance(rbb_object_instance)

with project.create_bundle() as bundle:
    # Save the label row with the updated labels within the bundle
    # (useful if you're calling `initialise_labels` on many label rows
    label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import RotatableBoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify the label branch
DATA_UNIT_TITLE = "Cherries_video.mp4"  # The title of the video data unit
ONTOLOGY_OBJECT_TITLE = "Other type of fruit"  # The ontology object title for the bounding box

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Creating multiple instances of a rotatable bounding box - START
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Use the label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]


with project.create_bundle() as bundle:
    # Initialize labels for the selected label row in the label branch
    label_row.initialise_labels(bundle=bundle)

# Find a rotatable bounding box annotation object in the project ontology
rbb_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Define the coordinates for the rotatable bounding boxes across frames
coordinates_per_frame = {
    120: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.2,
        top_left_y=0.2,
        theta=23
    ),
    121: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.3,
        top_left_y=0.3,
        theta=27
    ),
    122: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.4,
        top_left_y=0.4,
        theta=57
    ),
}

# Iterate through the frames and create instances for each bounding box
for frame_number, coordinates in coordinates_per_frame.items():
    # Instantiate an object instance from the ontology node for each frame
    rbb_object_instance: ObjectInstance = rbb_ontology_object.create_instance()

    # Set the coordinates for the rotatable bounding box for this frame
    rbb_object_instance.set_for_frames(
        coordinates=coordinates,
        frames=frame_number,
        manual_annotation=False,  # Mark as a label
        confidence=1.0  # Optional confidence score
    )

    # Link the object instance to the label row
    label_row.add_object_instance(rbb_object_instance)

with project.create_bundle() as bundle:
    # Save the label row with the updated labels within the bundle
    label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import RotatableBoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-II"  # Specify the label branch
DATA_UNIT_TITLE = "apple_001.jpg"  # The title of the image data unit
ONTOLOGY_OBJECT_TITLE = "Other type of fruit"  # The ontology object title for the bounding box

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project: Project = user_client.get_project(PROJECT_ID)
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Use the label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

with project.create_bundle() as bundle:
    # Initialize labels for the selected label row in the label branch
    label_row.initialise_labels(bundle=bundle)

# Find the rotatable bounding box annotation object in the project ontology
rbb_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Define rotatable bounding box instances with different coordinates
rotatable_bounding_boxes = [
    RotatableBoundingBoxCoordinates(
        height=0.23,
        width=0.13,
        top_left_x=0.1,
        top_left_y=0.2,
        theta=37
    ),
    RotatableBoundingBoxCoordinates(
        height=0.23,
        width=0.13,
        top_left_x=0.3,
        top_left_y=0.5,
        theta=95
    ),
    RotatableBoundingBoxCoordinates(
        height=0.23,
        width=0.13,
        top_left_x=0.4,
        top_left_y=0.6,
        theta=70
    ),
]

# Iterate over each bounding box and apply them as labels to the label row
for rbb_coordinates in rotatable_bounding_boxes:
    rbb_object_instance: ObjectInstance = rbb_ontology_object.create_instance()

    rbb_object_instance.set_for_frames(
        coordinates=rbb_coordinates,
        frames=0,  # Image frame
        manual_annotation=False,  # Mark as a label
        confidence=1.0
    )

    # Link the object instance to the label row
    label_row.add_object_instance(rbb_object_instance)

with project.create_bundle() as bundle:
    # Save the label row with the updated labels within the bundle
    label_row.save(bundle=bundle)

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import RotatableBoundingBoxCoordinates

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "<name-of-your-label-branch>"  # Specify the label branch
DATA_UNIT_TITLE = "Cherries_video.mp4"  # The title of the video data unit
ONTOLOGY_OBJECT_TITLE = "Other type of fruit"  # The ontology object title for the bounding box

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project: Project = user_client.get_project(PROJECT_ID)
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Use the label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

with project.create_bundle() as bundle:
    # Initialize labels for the selected label row in the label branch
    label_row.initialise_labels(bundle=bundle)

# Find the rotatable bounding box annotation object in the project ontology
rbb_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Define frame coordinates for the first rotatable bounding box
coordinates_per_frame_01 = {
    120: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.2,
        top_left_y=0.2,
        theta=23
    ),
    121: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.3,
        top_left_y=0.3,
        theta=27
    ),
    122: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.4,
        top_left_y=0.4,
        theta=57
    ),
}

# Create and link the first rotatable bounding box to the label row
rbb_object_instance_01: ObjectInstance = rbb_ontology_object.create_instance()
for frame_number, coordinates in coordinates_per_frame_01.items():
    rbb_object_instance_01.set_for_frames(
        coordinates=coordinates,
        frames=frame_number,
        manual_annotation=False,  # Mark as a label
        confidence=1.0  # Optional confidence score
    )
label_row.add_object_instance(rbb_object_instance_01)

# Define frame coordinates for the second rotatable bounding box
coordinates_per_frame_02 = {
    222: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.2,
        top_left_y=0.2,
        theta=23
    ),
    224: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.3,
        top_left_y=0.3,
        theta=27
    ),
    226: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.4,
        top_left_y=0.4,
        theta=57
    ),
}

# Create and link the second rotatable bounding box to the label row
rbb_object_instance_02: ObjectInstance = rbb_ontology_object.create_instance()
for frame_number, coordinates in coordinates_per_frame_02.items():
    rbb_object_instance_02.set_for_frames(
        coordinates=coordinates,
        frames=frame_number,
        manual_annotation=False,  # Mark as a label
        confidence=1.0  # Optional confidence score
    )
label_row.add_object_instance(rbb_object_instance_02)

# Define frame coordinates for the third rotatable bounding box
coordinates_per_frame_03 = {
    321: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.2,
        top_left_y=0.2,
        theta=23
    ),
    323: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.3,
        top_left_y=0.3,
        theta=27
    ),
    325: RotatableBoundingBoxCoordinates(
        height=0.5,
        width=0.5,
        top_left_x=0.4,
        top_left_y=0.4,
        theta=57
    ),
}

# Create and link the third rotatable bounding box to the label row
rbb_object_instance_03: ObjectInstance = rbb_ontology_object.create_instance()
for frame_number, coordinates in coordinates_per_frame_03.items():
    rbb_object_instance_03.set_for_frames(
        coordinates=coordinates,
        frames=frame_number,
        manual_annotation=False,  # Mark as a label
        confidence=1.0  # Optional confidence score
    )
label_row.add_object_instance(rbb_object_instance_03)

with project.create_bundle() as bundle:
    # Save the label row with the updated labels within the bundle
    label_row.save(bundle=bundle)

PolygonCoordinates(polygons=[[[PointCoordinate(x1, y1), PointCoordinate(x2, y2),...]]]

PolygonCoordinates(polygons=
[
    [
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Outer ring
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Inner ring
    ]
]

PolygonCoordinates(polygons=
[
    [
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Polygon 1
    ],
    [
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Polygon 2
    ],
    [
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Polygon 3
    ],

]

PolygonCoordinates(polygons=
[
    [
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Outer ring
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Inner ring
    ],
    [
        [PointCoordinate(x1, y1), PointCoordinate(x2, y2),...], # Polygon inside
    ],

]

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Define coordinates for each image
image_annotations = {
    "cherry-002-dup-001.jpg": [
        [  # Simple Polygon
            [PointCoordinate(1.000, 0.500), PointCoordinate(0.750, 0.933), 
             PointCoordinate(0.250, 0.933), PointCoordinate(0.000, 0.500), 
             PointCoordinate(0.250, 0.067), PointCoordinate(0.750, 0.067)]
        ]
    ],
    
    "cherry-002-dup-002.jpg": [
        [  # Simple Polygon
            [PointCoordinate(0.900, 0.400), PointCoordinate(0.700, 0.850), 
             PointCoordinate(0.300, 0.850), PointCoordinate(0.100, 0.400), 
             PointCoordinate(0.300, 0.100), PointCoordinate(0.700, 0.100)]
        ]
    ],
}

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project and list label rows for the specified branch
project = user_client.get_project(PROJECT_ID)
all_label_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on images in `image_annotations`
label_rows = [row for row in all_label_rows if row.data_title in image_annotations]

if not label_rows:
    print("No matching label rows found for specified images in branch '{CONSENSUS_BRANCH_NAME}'.")
    exit()

print("Processing label rows for:", [row.data_title for row in label_rows])

with project.create_bundle() as bundle:
    # Prepare for labeling
    for label_row in label_rows:
        label_row.initialise_labels(bundle=bundle)

for label_row in label_rows:
    image_title = label_row.data_title  # Get the image title
    polygon_data = image_annotations.get(image_title, [])  # Get associated polygons

    if not polygon_data:
        print(f"No polygon data found for {image_title}, skipping.")
        continue

    # Retrieve the specified ontology object by title
    polygon_ontology_object = project.ontology_structure.get_child_by_title(
        title=ONTOLOGY_OBJECT_TITLE,
        type_=Object
    )

    # Iterate through each polygon in the image's annotation data
    for polygon in polygon_data:
        # Instantiate an object instance from the polygon ontology node
        polygon_object_instance = polygon_ontology_object.create_instance()

        # Set the coordinates for the polygon
        polygon_object_instance.set_for_frames(
            coordinates=PolygonCoordinates(polygon),
            frames=0,  # Apply to the specified frame
            manual_annotation=True,  # Set to True for manual annotation
            confidence=1.0,  # Confidence of your label
        )

        # Link the object instance to the label row
        label_row.add_object_instance(polygon_object_instance)

with project.create_bundle() as bundle:
    for label_row in label_rows:
        # Save the label row with the polygon object instance within the bundle
        label_row.save(bundle=bundle)

print("Label rows updated with polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Define coordinates for each image (supporting both outer and inner rings)
image_annotations = {
    "cherry-002-dup-004.jpg": [
        # Outer ring
        [
            [PointCoordinate(1.000, 0.500), PointCoordinate(0.750, 0.933), 
             PointCoordinate(0.250, 0.933), PointCoordinate(0.000, 0.500), 
             PointCoordinate(0.250, 0.067), PointCoordinate(0.750, 0.067)],
        ],
        # Inner ring (hole)
        [
            [PointCoordinate(0.750, 0.500), PointCoordinate(0.625, 0.717), 
             PointCoordinate(0.375, 0.717), PointCoordinate(0.250, 0.500), 
             PointCoordinate(0.375, 0.284), PointCoordinate(0.625, 0.284)]
        ]
    ],
    
    "cherry-002-dup-003.jpg": [
        # Outer ring
        [
            [PointCoordinate(0.900, 0.400), PointCoordinate(0.700, 0.850), 
             PointCoordinate(0.300, 0.850), PointCoordinate(0.100, 0.400), 
             PointCoordinate(0.300, 0.100), PointCoordinate(0.700, 0.100)],
        ],
        # Inner ring (hole)
        [
            [PointCoordinate(0.700, 0.400), PointCoordinate(0.600, 0.650), 
             PointCoordinate(0.400, 0.650), PointCoordinate(0.300, 0.400), 
             PointCoordinate(0.400, 0.200), PointCoordinate(0.600, 0.200)]
        ]
    ],
}

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project and list label rows for the specified branch
project = user_client.get_project(PROJECT_ID)
all_label_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on images in `image_annotations`
label_rows = [row for row in all_label_rows if row.data_title in image_annotations]

if not label_rows:
    print("No matching label rows found for specified images in branch '{CONSENSUS_BRANCH_NAME}'.")
    exit()

print("Processing label rows for:", [row.data_title for row in label_rows])

with project.create_bundle() as bundle:
    # Prepare for labeling
    for label_row in label_rows:
        label_row.initialise_labels(bundle=bundle)

for label_row in label_rows:
    image_title = label_row.data_title  # Get the image title
    polygon_data = image_annotations.get(image_title, [])  # Get associated polygons

    if not polygon_data:
        print(f"No polygon data found for {image_title}, skipping.")
        continue

    # Retrieve the specified ontology object by title
    polygon_ontology_object = project.ontology_structure.get_child_by_title(
        title=ONTOLOGY_OBJECT_TITLE,
        type_=Object
    )

    # Iterate through each set of polygons in the image's annotation data
    for polygon_group in polygon_data:
        # Instantiate an object instance from the polygon ontology node
        polygon_object_instance = polygon_ontology_object.create_instance()

        # Set the coordinates for the polygon(s) (outer + inner if applicable)
        polygon_object_instance.set_for_frames(
            coordinates=PolygonCoordinates(polygon_group),
            frames=0,  # Apply to the specified frame
            manual_annotation=True,  # Set to True for manual annotation
            confidence=1.0,  # Confidence of your label
        )

        # Link the object instance to the label row
        label_row.add_object_instance(polygon_object_instance)

with project.create_bundle() as bundle:
    for label_row in label_rows:
        # Save the label row with the polygon object instance within the bundle
        label_row.save(bundle=bundle)

print("Label rows updated with polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Define coordinates for each image (multiple independent polygons)
image_annotations = {
    "cherry-002-dup-003.jpg": [
        # Polygon 1
        [
            [PointCoordinate(0.1, 0.1), PointCoordinate(0.3, 0.1), 
             PointCoordinate(0.3, 0.3), PointCoordinate(0.1, 0.3)]
        ],
        # Polygon 2
        [
            [PointCoordinate(0.6, 0.6), PointCoordinate(0.9, 0.6), 
             PointCoordinate(0.9, 0.9), PointCoordinate(0.6, 0.9)]
        ]
    ],
    
    "cherry-002-dup-006.jpg": [
        # Polygon 1
        [
            [PointCoordinate(0.2, 0.2), PointCoordinate(0.4, 0.2), 
             PointCoordinate(0.4, 0.4), PointCoordinate(0.2, 0.4)]
        ],
        # Polygon 2
        [
            [PointCoordinate(0.5, 0.5), PointCoordinate(0.7, 0.5), 
             PointCoordinate(0.7, 0.7), PointCoordinate(0.5, 0.7)]
        ]
    ],
}

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project and list label rows for the specified branch
project = user_client.get_project(PROJECT_ID)
all_label_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on images in `image_annotations`
label_rows = [row for row in all_label_rows if row.data_title in image_annotations]

if not label_rows:
    print(f"No matching label rows found for specified images in branch '{CONSENSUS_BRANCH_NAME}'.")
    exit()

print("Processing label rows for:", [row.data_title for row in label_rows])

with project.create_bundle() as bundle:
    # Prepare for labeling
    for label_row in label_rows:
        label_row.initialise_labels(bundle=bundle)

for label_row in label_rows:
    image_title = label_row.data_title  # Get the image title
    polygon_data = image_annotations.get(image_title, [])  # Get associated polygons

    if not polygon_data:
        print(f"No polygon data found for {image_title}, skipping.")
        continue

    # Retrieve the specified ontology object by title
    polygon_ontology_object = project.ontology_structure.get_child_by_title(
        title=ONTOLOGY_OBJECT_TITLE,
        type_=Object
    )

    # Iterate through each independent polygon in the image's annotation data
    for polygon in polygon_data:
        # Instantiate an object instance from the polygon ontology node
        polygon_object_instance = polygon_ontology_object.create_instance()

        # Set the coordinates for each polygon separately
        polygon_object_instance.set_for_frames(
            coordinates=PolygonCoordinates(polygon),
            frames=0,  # Apply to the specified frame
            manual_annotation=True,  # Set to True for manual annotation
            confidence=1.0,  # Confidence of your label
        )

        # Link the object instance to the label row
        label_row.add_object_instance(polygon_object_instance)

with project.create_bundle() as bundle:
    for label_row in label_rows:
        # Save the label row with the polygon object instances within the bundle
        label_row.save(bundle=bundle)

print("Label rows updated with multiple independent polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Define coordinates for each image (handling donut shapes and nested polygons)
image_annotations = {
    "cherries-001.jpg": [
        # Donut shape: Outer ring + Inner ring
        [
            [
                PointCoordinate(1.000, 0.500), PointCoordinate(0.750, 0.933), 
                PointCoordinate(0.250, 0.933), PointCoordinate(0.000, 0.500), 
                PointCoordinate(0.250, 0.067), PointCoordinate(0.750, 0.067)  # Outer ring
            ],
            [
                PointCoordinate(0.750, 0.500), PointCoordinate(0.625, 0.717), 
                PointCoordinate(0.375, 0.717), PointCoordinate(0.250, 0.500), 
                PointCoordinate(0.375, 0.284), PointCoordinate(0.625, 0.284)  # Inner ring (hole)
            ]
        ],
        # Second polygon inside the hole
        [
            [
                PointCoordinate(0.550, 0.500), PointCoordinate(0.525, 0.575), 
                PointCoordinate(0.475, 0.575), PointCoordinate(0.450, 0.500), 
                PointCoordinate(0.475, 0.425), PointCoordinate(0.525, 0.425)
            ]
        ]
    ],
    
    "cherries-010.jpg": [
        # Donut shape: Outer ring + Inner ring
        [
            [
                PointCoordinate(0.900, 0.400), PointCoordinate(0.700, 0.850), 
                PointCoordinate(0.300, 0.850), PointCoordinate(0.100, 0.400), 
                PointCoordinate(0.300, 0.100), PointCoordinate(0.700, 0.100)
            ],
            [
                PointCoordinate(0.700, 0.400), PointCoordinate(0.600, 0.650), 
                PointCoordinate(0.400, 0.650), PointCoordinate(0.300, 0.400), 
                PointCoordinate(0.400, 0.200), PointCoordinate(0.600, 0.200)
            ]
        ],
        # Second polygon inside the hole
        [
            [
                PointCoordinate(0.500, 0.500), PointCoordinate(0.550, 0.600), 
                PointCoordinate(0.450, 0.600), PointCoordinate(0.400, 0.500), 
                PointCoordinate(0.450, 0.400), PointCoordinate(0.550, 0.400)
            ]
        ]
    ]
}

# Ensure SSH path and project ID are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project ID cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project and list label rows for the specified branch
project = user_client.get_project(PROJECT_ID)
all_label_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on images in `image_annotations`
label_rows = [row for row in all_label_rows if row.data_title in image_annotations]

if not label_rows:
    print(f"No matching label rows found for specified images in branch '{CONSENSUS_BRANCH_NAME}'.")
    exit()

print("Processing label rows for:", [row.data_title for row in label_rows])

with project.create_bundle() as bundle:
    # Prepare for labeling
    for label_row in label_rows:
        label_row.initialise_labels(bundle=bundle)

for label_row in label_rows:
    image_title = label_row.data_title  # Get the image title
    polygon_data = image_annotations.get(image_title, [])  # Get associated polygons

    if not polygon_data:
        print(f"No polygon data found for {image_title}, skipping.")
        continue

    # Retrieve the specified ontology object by title
    polygon_ontology_object = project.ontology_structure.get_child_by_title(
        title=ONTOLOGY_OBJECT_TITLE,
        type_=Object
    )

    # Iterate through each group of polygons in the image's annotation data
    for polygon_group in polygon_data:
        # Instantiate an object instance from the polygon ontology node
        polygon_object_instance = polygon_ontology_object.create_instance()

        # Check if the polygon group contains multiple polygons (outer + inner ring)
        if len(polygon_group) > 1:
            # Handle donut shape (outer ring + inner ring)
            polygon_object_instance.set_for_frames(
                coordinates=PolygonCoordinates(polygon_group),  # Multiple polygons
                frames=0,  # Apply to the specified frame
                manual_annotation=True,  # Set to True for manual annotation
                confidence=1.0,  # Confidence of your label
            )
        else:
            # Handle single independent polygons inside the hole
            polygon_object_instance.set_for_frames(
                coordinates=PolygonCoordinates(polygon_group[0]),  # Single polygon
                frames=0,  # Apply to the specified frame
                manual_annotation=True,  # Set to True for manual annotation
                confidence=1.0,  # Confidence of your label
            )

        # Link the object instance to the label row
        label_row.add_object_instance(polygon_object_instance)

with project.create_bundle() as bundle:
    for label_row in label_rows:
        # Save the label row with the polygon object instances within the bundle
        label_row.save(bundle=bundle)

print("Label rows updated with donut-shaped polygons and nested polygons.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "<file-path-to-ssh-private-key>"
PROJECT_ID = "<project-unique-id>"
CONSENSUS_BRANCH_NAME = "<name-of-your-label-branch>"  # Specify the label branch
DATA_UNIT_TITLE = "<name-of-data-unit>"  # The title of the data unit (image or video)
ONTOLOGY_OBJECT_TITLE = "<object-name>"  # The ontology object title for the polygon

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get the project and list label rows for the label branch
project: Project = user_client.get_project(PROJECT_ID)
consensus_branch_rows = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Use the label branch
    data_title_eq=DATA_UNIT_TITLE
)

if not consensus_branch_rows:
    print("No matching data units found in the specified branch.")
else:
    print("Data units found:", [row.data_title for row in consensus_branch_rows])

# Initialize labels for each selected label row in the label branch
label_row = consensus_branch_rows[0]
label_row.initialise_labels()

# Find a polygon annotation object in the project ontology
polygon_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Instantiate an object instance from the polygon ontology node
polygon_object_instance: ObjectInstance = polygon_ontology_object.create_instance()

# Define the polygon coordinates
polygon_coordinates = PolygonCoordinates([
    PointCoordinate(0.1, 0.2),
    PointCoordinate(0.3, 0.4),
    PointCoordinate(0.5, 0.6),
    PointCoordinate(0.7, 0.8)
])

# Set the polygon label for the specified frame
polygon_object_instance.set_for_frames(
    coordinates=polygon_coordinates,
    frames=0,  # Specify the frame number
    manual_annotation=False,  # Mark as a label
    confidence=1.0  # Optional confidence score
)

# Link the object instance to the label row
label_row.add_object_instance(polygon_object_instance)

# Save the label row 
label_row.save()

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology
DATA_UNIT_TITLE = "persimmon_001.jpg"  # Specific data unit title

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Authenticate with Encord using access key
user_client = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project and list label rows for the specified branch and data unit
project = user_client.get_project(PROJECT_ID)
all_label_rows = project.list_label_rows_v2(branch_name=CONSENSUS_BRANCH_NAME)

# Filter label rows based on the specified data unit title
label_rows = [
    row for row in all_label_rows 
    if row.data_title == DATA_UNIT_TITLE
]

if not label_rows:
    print(f"No matching label rows found for {DATA_UNIT_TITLE} in branch '{CONSENSUS_BRANCH_NAME}'.")
    exit()  # Nothing to do so exit early

print("Label rows found:", [row.data_title for row in label_rows])

with project.create_bundle() as bundle:
    # Prepare for labeling
    for label_row in label_rows:
        label_row.initialise_labels(bundle=bundle)

for label_row in label_rows:
    # Retrieve the specified ontology object by title
    polygon_ontology_object = project.ontology_structure.get_child_by_title(
        title=ONTOLOGY_OBJECT_TITLE,
        type_=Object
    )

    # Instantiate an object instance from the polygon ontology node
    polygon_object_instance = polygon_ontology_object.create_instance()

    # The x,y coordinates of each polygon vertex
    polygon_object_instance.set_for_frames(
        coordinates=PolygonCoordinates(
            [PointCoordinate(.1, .1), PointCoordinate(.2, .2), PointCoordinate(.3, .3), PointCoordinate(.4, .4)]
        ),
        frames=0,  # Apply to the specified frame
        manual_annotation=True,  # Set to True for manual annotation
        confidence=1.0,  # Confidence of your label
    )

    # Link the object instance to the label row
    label_row.add_object_instance(polygon_object_instance)


with project.create_bundle() as bundle:
    for label_row in label_rows:
        # Save the label row with the polygon object instance within the bundle
        label_row.save(bundle=bundle)

print("Label rows updated with polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "Cherries_video.mp4"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Ensure SSH path and project id are set
assert SSH_PATH, "SSH path cannot be None"
assert PROJECT_ID, "Project id cannot be None"

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Retrieve the label row for the specified data unit
label_row = project.list_label_rows_v2(
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find the polygon annotation object in the project ontology
polygon_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Coordinates for each frame
coordinates_per_frame = {
    143: PolygonCoordinates(
        [PointCoordinate(.1, .1),
         PointCoordinate(.2, .1),
         PointCoordinate(.3, .2),
         PointCoordinate(.1, .3)]
    ),
    144: PolygonCoordinates(
        [PointCoordinate(.1, .1),
         PointCoordinate(.2, .1),
         PointCoordinate(.3, .2),
         PointCoordinate(.1, .3)]
    ),
    145: PolygonCoordinates(
        [PointCoordinate(.1, .1),
         PointCoordinate(.2, .1),
         PointCoordinate(.3, .2),
         PointCoordinate(.1, .3)]
    ),
}

# Create and link polygon object instances for each frame
for frame_number, coordinates in coordinates_per_frame.items():
    polygon_object_instance: ObjectInstance = polygon_ontology_object.create_instance()
    polygon_object_instance.set_for_frames(
        coordinates=coordinates,
        frames=frame_number,
        manual_annotation=True,  # Set to True for manual annotation
        confidence=1.0,  # Set confidence level as needed
    )
    
    # Link the object instance to the label row
    label_row.add_object_instance(polygon_object_instance)

# Save the label row 
label_row.save()
print("Label row updated with polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "persimmon_001.jpg"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

label_row.initialise_labels()

# Find a polygon annotation object in the project ontology
polygon_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Function to create a polygon object instance
def create_polygon_instance(ontology_object, coordinates, frame, manual_annotation=True, confidence=1.0):
    polygon_instance = ontology_object.create_instance()
    polygon_instance.set_for_frames(
        coordinates=coordinates,
        frames=frame,
        manual_annotation=manual_annotation,
        confidence=confidence,
    )
    return polygon_instance

# Define coordinates for polygons
polygon_coordinates = [
    PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .2), PointCoordinate(.3, .3), PointCoordinate(.4, .4)]),
    PolygonCoordinates([PointCoordinate(.15, .15), PointCoordinate(.25, .25), PointCoordinate(.35, .35), PointCoordinate(.15, .45)]),
    PolygonCoordinates([PointCoordinate(.2, .2), PointCoordinate(.3, .3), PointCoordinate(.4, .4), PointCoordinate(.2, .5)]),
]

# Create and link polygon instances for each set of coordinates
for coords in polygon_coordinates:
    polygon_instance = create_polygon_instance(polygon_ontology_object, coords, frame=0)
    label_row.add_object_instance(polygon_instance)

# Save the label row with polygon instances
label_row.save()
print("Label row updated with polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolygonCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "Cherries_video.mp4"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Persimmon"  # Name of object label in your Ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row 
label_row.initialise_labels()

# Find a polygon annotation object in the project ontology
polygon_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Function to create and add a polygon instance
def add_polygon_instance(label_row, ontology_object, coordinates_per_frame):
    polygon_instance = ontology_object.create_instance()

    for frame_number, coordinates in coordinates_per_frame.items():
        polygon_instance.set_for_frames(
            coordinates=coordinates,
            frames=frame_number,
            manual_annotation=True,  # Set to True for manual annotation
            confidence=1.0,  # Set confidence level as needed
        )
    
    # Link the object instance to the label row
    label_row.add_object_instance(polygon_instance)

# Coordinates for each polygon
coordinates_list = [
    {
        153: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
        154: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
        155: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
    },
    {
        242: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
        244: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
        246: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
    },
    {
        343: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
        345: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
        347: PolygonCoordinates([PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]),
    },
]

# Add polygon instances
for coordinates in coordinates_list:
    add_polygon_instance(label_row, polygon_ontology_object, coordinates)

# Save the label row with polygon instances
label_row.save()
print("Label row updated with polygon instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolylineCoordinates, PointCoordinate

# Configuration
SSH_PATH = "<file-path-to-ssh-private-key>"  # Path to your SSH private key
PROJECT_ID = "<project-unique-id>"  # Unique project id
CONSENSUS_BRANCH_NAME = "<your-label-branch-name>"  # Specify your label branch
DATA_UNIT_TITLE = "<name-of-data-unit>"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "<object-name>"  # Name of the polyline object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row 
label_row.initialise_labels()

# Find a polyline annotation object in the project ontology
polyline_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Instantiate an object instance from the polyline ontology node
polyline_object_instance: ObjectInstance = polyline_ontology_object.create_instance()

# The x,y coordinates of each polyline vertex are specified as follows
polyline_object_instance.set_for_frames(
    coordinates=PolylineCoordinates(
        [PointCoordinate(.x1, .y1), PointCoordinate(.x2, .y2), PointCoordinate(.x3, .y3), PointCoordinate(.13, .456)]
    ),
    # Add the polyline to the specified frame number
    frames=<frame-number>,  # Replace with the actual frame number
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
    confidence=1.0,
)

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance)

# Save the label row with the polyline instance
label_row.save()
print("Label row updated with polyline instance.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolylineCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "apple_001.png"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Branch"  # Name of the polyline object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find a polyline annotation object in the project ontology
polyline_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Instantiate an object instance from the polyline ontology node
polyline_object_instance: ObjectInstance = polyline_ontology_object.create_instance()

# The x,y coordinates of each polyline vertex are specified as follows
polyline_object_instance.set_for_frames(
    coordinates=PolylineCoordinates(
        [PointCoordinate(.1, .1), PointCoordinate(.2, .2), PointCoordinate(.3, .3), PointCoordinate(.4, .4)]
    ),
    # Add the polyline to the image
    frames=0,  # Specify the frame number
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
    confidence=1.0,
)

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance)

# Save the label row with the polyline instance 
label_row.save()
print("Label row updated with polyline instance.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolylineCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "Cherries_video.mp4"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Branch"  # Name of the polyline object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find a polyline annotation object in the project ontology
polyline_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Instantiate an object instance from the polyline ontology node
polyline_object_instance: ObjectInstance = polyline_ontology_object.create_instance()

# Coordinates for each frame
coordinates_per_frame = {
    146: PolylineCoordinates(
        [PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]
    ),
    147: PolylineCoordinates(
        [PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]
    ),
    148: PolylineCoordinates(
        [PointCoordinate(.1, .1), PointCoordinate(.2, .1), PointCoordinate(.3, .2), PointCoordinate(.1, .3)]
    ),
}

# Set coordinates for each frame in the polyline object instance
for frame_number, coordinates in coordinates_per_frame.items():
    polyline_object_instance.set_for_frames(
        coordinates=coordinates, frames=frame_number, manual_annotation=True
    )

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance)

# Save the label row with the polyline instance
label_row.save()
print("Label row updated with polyline instance.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolylineCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "apple_001.png"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Branch"  # Name of the polyline object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find a polyline annotation object in the project ontology
polyline_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Polyline 1 - START
# Instantiate an object instance from the polyline ontology node
polyline_object_instance01: ObjectInstance = polyline_ontology_object.create_instance()

# The x,y coordinates of each polyline vertex are specified as follows
polyline_object_instance01.set_for_frames(
    coordinates=PolylineCoordinates(
        [PointCoordinate(.1, .1), PointCoordinate(.2, .2), PointCoordinate(.3, .3), PointCoordinate(.4, .4)]
    ),
    # Add the polyline to the image
    frames=0,
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
    confidence=1.0,
)

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance01)
# Polyline 1 - END

# Polyline 2 - START
# Instantiate an object instance from the polyline ontology node
polyline_object_instance02: ObjectInstance = polyline_ontology_object.create_instance()

# The x,y coordinates of each polyline vertex are specified as follows
polyline_object_instance02.set_for_frames(
    coordinates=PolylineCoordinates(
        [PointCoordinate(.15, .15), PointCoordinate(.25, .25), PointCoordinate(.35, .35), PointCoordinate(.45, .45)]
    ),
    # Add the polyline to the image
    frames=0,
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
)

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance02)
# Polyline 2 - END

# Polyline 3 - START
# Instantiate an object instance from the polyline ontology node
polyline_object_instance03: ObjectInstance = polyline_ontology_object.create_instance()

# The x,y coordinates of each polyline vertex are specified as follows
polyline_object_instance03.set_for_frames(
    coordinates=PolylineCoordinates(
        [PointCoordinate(.17, .17), PointCoordinate(.27, .27), PointCoordinate(.37, .37), PointCoordinate(.47, .47)]
    ),
    # Add the polyline to the image
    frames=0,
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
)

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance03)
# Polyline 3 - END

# Save the label row with the polyline instances
label_row.save()
print("Label row updated with polyline instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PolylineCoordinates, PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "Cherries_video.mp4"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Branch"  # Name of the polyline object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find a polyline annotation object in the project ontology
polyline_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Polyline 1 - START
# Instantiate an object instance from the polyline ontology node
polyline_object_instance01: ObjectInstance = polyline_ontology_object.create_instance()

coordinates_per_frame = {
    246: PolylineCoordinates(
        [PointCoordinate(.1, .1),
         PointCoordinate(.2, .1),
         PointCoordinate(.3, .2),
         PointCoordinate(.1, .3)]
    ),
    247: PolylineCoordinates(
        [PointCoordinate(.1, .1),
         PointCoordinate(.2, .1),
         PointCoordinate(.3, .2),
         PointCoordinate(.1, .3)]
    ),
    248: PolylineCoordinates(
        [PointCoordinate(.1, .1),
         PointCoordinate(.2, .1),
         PointCoordinate(.3, .2),
         PointCoordinate(.1, .3)]
    ),
}
for frame_number, coordinates in coordinates_per_frame.items():
    polyline_object_instance01.set_for_frames(
        coordinates=coordinates, frames=frame_number, manual_annotation=True
    )

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance01)
# Polyline 1 - END

# Polyline 2 - START
# Instantiate an object instance from the polyline ontology node
polyline_object_instance02: ObjectInstance = polyline_ontology_object.create_instance()

coordinates_per_frame = {
    346: PolylineCoordinates(
        [PointCoordinate(.11, .11),
         PointCoordinate(.21, .11),
         PointCoordinate(.31, .21),
         PointCoordinate(.11, .31)]
    ),
    347: PolylineCoordinates(
        [PointCoordinate(.11, .11),
         PointCoordinate(.21, .11),
         PointCoordinate(.31, .21),
         PointCoordinate(.11, .31)]
    ),
    348: PolylineCoordinates(
        [PointCoordinate(.11, .11),
         PointCoordinate(.21, .11),
         PointCoordinate(.31, .21),
         PointCoordinate(.11, .31)]
    ),
}
for frame_number, coordinates in coordinates_per_frame.items():
    polyline_object_instance02.set_for_frames(
        coordinates=coordinates, frames=frame_number, manual_annotation=True
    )

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance02)
# Polyline 2 - END

# Polyline 3 - START
# Instantiate an object instance from the polyline ontology node
polyline_object_instance03: ObjectInstance = polyline_ontology_object.create_instance()

coordinates_per_frame = {
    446: PolylineCoordinates(
        [PointCoordinate(.21, .21),
         PointCoordinate(.22, .21),
         PointCoordinate(.23, .22),
         PointCoordinate(.21, .23)]
    ),
    447: PolylineCoordinates(
        [PointCoordinate(.21, .21),
         PointCoordinate(.22, .21),
         PointCoordinate(.23, .22),
         PointCoordinate(.21, .23)]
    ),
    448: PolylineCoordinates(
        [PointCoordinate(.21, .21),
         PointCoordinate(.22, .21),
         PointCoordinate(.23, .22),
         PointCoordinate(.21, .23)]
    ),
}
for frame_number, coordinates in coordinates_per_frame.items():
    polyline_object_instance03.set_for_frames(
        coordinates=coordinates, frames=frame_number, manual_annotation=True
    )

# Link the object instance to the label row
label_row.add_object_instance(polyline_object_instance03)
# Polyline 3 - END

# Save the label row with the polyline instances
label_row.save()
print("Label row updated with polyline instances.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PointCoordinate

# Configuration
SSH_PATH = "<file-path-to-ssh-private-key>"  # Path to your SSH private key
PROJECT_ID = "<project-unique-id>"  # Unique project id
CONSENSUS_BRANCH_NAME = "<your-label-branch-name>"  # Specify your label branch
DATA_UNIT_TITLE = "<name-of-data-unit>"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "<object-name>"  # Name of the keypoint object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find a keypoint annotation object in the project ontology
keypoint_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Instantiate an object instance from the keypoint ontology node
keypoint_object_instance: ObjectInstance = keypoint_ontology_object.create_instance()

# The x,y coordinates of the keypoint are specified as follows
keypoint_object_instance.set_for_frames(
    coordinates=PointCoordinate(
        x=<value-for-x-axis>,  # Replace with the actual value for the x-axis
        y=<value-for-y-axis>   # Replace with the actual value for the y-axis
    ),
    # Add the keypoint to the specified frame number
    frames=<frame-number>,  # Replace with the actual frame number
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
    confidence=1.0,
)

# Link the object instance to the label row
label_row.add_object_instance(keypoint_object_instance)

# Save the label row with the keypoint instance
label_row.save()
print("Label row updated with keypoint instance.")

# Import dependencies
from pathlib import Path
from encord import EncordUserClient, Project
from encord.objects import Object, ObjectInstance
from encord.objects.coordinates import PointCoordinate

# Configuration
SSH_PATH = "/Users/chris-encord/sdk-ssh-private-key.txt"
PROJECT_ID = "7d4ead9c-4087-4832-a301-eb2545e7d43b"
CONSENSUS_BRANCH_NAME = "my-label-branch-I"  # Specify your label branch
DATA_UNIT_TITLE = "blueberry_003.png"  # Specific data unit title
ONTOLOGY_OBJECT_TITLE = "Pedicel"  # Name of the keypoint object in your ontology

# Create user client using access key
user_client: EncordUserClient = EncordUserClient.create_with_ssh_private_key(
    Path(SSH_PATH).read_text()
)

# Get project for which labels are to be added
project: Project = user_client.get_project(PROJECT_ID)

# Specify the data unit to label in the given branch
label_row = project.list_label_rows_v2(
    branch_name=CONSENSUS_BRANCH_NAME,  # Filter by label branch
    data_title_eq=DATA_UNIT_TITLE
)[0]

# Initialize labels for the label row
label_row.initialise_labels()

# Find a keypoint annotation object in the project ontology
keypoint_ontology_object: Object = project.ontology_structure.get_child_by_title(
    title=ONTOLOGY_OBJECT_TITLE, type_=Object
)

# Instantiate an object instance from the keypoint ontology node
keypoint_object_instance: ObjectInstance = keypoint_ontology_object.create_instance()

# The x,y coordinates of the keypoint are specified as follows
keypoint_object_instance.set_for_frames(
    coordinates=PointCoordinate(
        x=.1,
        y=.1
    ),
    # Add the keypoint to the specified frame number
    frames=<frame-number>,  # Replace with the actual frame number
    # There are multiple additional fields that can be set optionally:
    manual_annotation=True,
    confidence=1.0,
)

# Link the object instance to the label row
label_row.add_object_instance(keypoint_object_instance)

# Save the label row with the keypoint instance
label_row.save()
print("Label row updated with keypoint instance.")