Add dataset files

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+*.jsonl filter=lfs diff=lfs merge=lfs -text

BaboonLand/README.md

@@ -0,0 +1,109 @@
+BaboonLand: Tracking Primates in the Wild and Automating Ethograms From Drone Videos
+
+The dataset structure looks as follows:
+
+BaboonLand
+    /charades -> The dataset converted to Charades format to train and evaluate behavior
+                 recognition models. You can download the generated dataset from our webpage
+                 or you can generate it yourself. See instructions below.
+        ...
+    /cvat_templates -> You can use these templates to backup projects in CVAT.
+                       It will allow you to explore and adjust the annotations in CVAT.
+        /behavior.zip
+        /tracking.zip
+    /dataset -> The dataset is located here.
+        /video_1
+            /actions -> The behavior annotations are located here.
+                /0.xml
+                /1.xml -> Annotations of the behavior for an individual with ID=1.
+                ...
+                /n.xml
+            /mini-scenes -> Generated mini-scenes from video.xml and tracks.xml. The name of the video matches
+                            ID of the track in tracks.xml. The name of the video also matches the behavior
+                            annotations file in the actions folder. For example, a track with ID=1 will be extracted
+                            into mini-scenes/1.mp4 and there will be behavior annotations for this track located
+                            in actions/1.xml.
+                /0.mp4
+                /1.mp4
+                ...
+                /n.mp4
+            /timeline.jpg -> A timeline of the original video and corresponding mini-scenes. This file is generated
+                             for convenience only. You can use it to look for a mini-scene with a specific length or
+                             relative location in the video.
+            /tracks.xml -> This file contains tracks and bounding boxes of baboons in
+                           CVAT for video 1.1 format. Each track has a unique ID. This
+                           number matches the name of the file in the actions folder.
+                           For example, if you want to get the track and corresponding
+                           bounding boxes of a baboon with ID=1, you can get this
+                           information from the tracks.xml file. If you want to explore
+                           the behavior of the baboon with ID=1, you can get this
+                           information with the help of the actions/1.xml file.
+            /video.mp4 -> The original video from a drone.
+        /video_2
+            /actions
+                /0.xml
+                /1.xml
+                ...
+                /n.xml
+            /mini-scenes
+                /0.mp4
+                /1.mp4
+                ...
+                /n.mp4
+            /timeline.jpg
+            /tracks.xml
+            /video.mp4
+        ...
+        /video_n
+            /actions
+                /0.xml
+                /1.xml
+                ...
+                /n.xml
+            /mini-scenes
+                /0.mp4
+                /1.mp4
+                ...
+                /n.mp4
+            /tracks.xml
+            /video.mp4
+    /scripts
+        /requirements.txt -> Install all the requirements to be able to run scripts.
+        /tracks2mini-scenes.py -> Use this script to generate the mini-scenes from
+                                  video.xml and tracks.xml files.
+        /dataset2charades.py -> Use this script to generate a dataset for Baboon behavior
+                                recognition in Charades format. The generated dataset can
+                                be used to train a model with the SlowFast framework. 
+        /charades2video.py -> Use this script if you want to combine images from the dataset
+                              in Charades format back to videos. These videos can be used to
+                              create demos of the model performance.
+        /charades2visual.py -> Use this script if you want to combine images from the dataset
+                               in Charades format back to videos and visualize corresponding
+                               behavior annotations.
+        /dataset2tracking.py -> Use this script to generate a data split for training and
+                                evaluating tracking algorithms.
+        /tracking2ultralytics.py -> Use this script to generate a Baboon detection dataset in
+                                    Ultralytics (YOLO) format. The dataset can be used to train
+                                    detection models with the Ultralytics (YOLOv8) framework.
+        /ultralytics2pyramid.py -> Use this script to split the original 5.3K images in the
+                                   Ultralytics dataset into tiles. You will create a dataset with
+                                   2x2, 3x3, and 4x4 tiles. It will help to train a model that
+                                   will be more robust for both small and large baboons.
+    /tracking -> The dataset split into train and test for tracking and train converted to
+                 Ultralytics format to train and evaluate detection models. You can download the
+                 generated dataset from our webpage or you can generate it yourself. See
+                 instructions below.
+        ...
+    /README.md -> You are reading this file.
+
+How to generate behavior dataset?
+    tracks2mini-scenes.py (skip, mini-scenes already generated) -> dataset2charades.py ->
+    -> charades2video.py (optional) -> charades2visual.py (optional)
+Or you can download generated charades.zip from our webpage.
+
+How to generate detection and tracking dataset?
+    tracks2mini-scenes.py (skip, mini-scenes already generated) -> dataset2tracking.py ->
+    -> tracking2ultralytics.py -> ultralytics2pyramid.py
+Or you can download generated tracking.zip from our webpage.
+
+All ".xml" files are compatible with CVAT and are simplified versions of CVAT for video 1.1 format.

BaboonLand/cvat_templates/behavior.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e389c6c1c49d3bfcf1832461c5ae524b4dbd4842f1f20eb45979cbd680b0946
+size 613

BaboonLand/cvat_templates/tracking.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbe3b1a4109d40cf805916bd46a57e85119ef53fb88a83b1c60f842ae514fd28
+size 293

BaboonLand/scripts/charades2video.py

@@ -0,0 +1,73 @@
+import os
+import sys
+import json
+import cv2
+from natsort import natsorted
+import pandas as pd
+from tqdm import tqdm
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    path_to_image = "charades/dataset/image"
+    path_to_video = "charades/dataset/video"
+    annotation_train = "charades/annotation/train.csv"
+    annotation_val = "charades/annotation/val.csv"
+    classes_json = "charades/annotation/classes.json"
+    visual = False
+
+    if not os.path.exists(path_to_video):
+        os.makedirs(path_to_video)
+
+    with open(classes_json, "r") as file:
+        label2number = json.load(file)
+
+    number2label = {value: key for key, value in label2number.items()}
+
+    df_train = pd.read_csv(annotation_train, sep=" ")
+    df_val = pd.read_csv(annotation_val, sep=" ")
+    df = pd.concat([df_train, df_val], axis=0)
+    folders = natsorted(os.listdir(path_to_image))
+
+    hierarchy = {}
+
+    for folder in folders:
+        main = folder.split(".")[0]
+
+        if hierarchy.get(main) is None:
+            hierarchy[main] = [folder]
+        else:
+            hierarchy[main].append(folder)
+
+    for i, folder in tqdm(enumerate(hierarchy.keys()), total=len(hierarchy.keys())):
+        vw = cv2.VideoWriter(f"{path_to_video}/{folder}.mp4", cv2.VideoWriter_fourcc("m", "p", "4", "v"), 29.97,
+                             (400, 300))
+
+        for segment in hierarchy[folder]:
+            mapping = {}
+
+            for index, row in df[df.original_vido_id == segment].iterrows():
+                mapping[row["frame_id"]] = number2label[row["labels"]]
+
+            for j, file in enumerate(natsorted(os.listdir(path_to_image + os.sep + segment))):
+                image = cv2.imread(f"{path_to_image}/{segment}/{file}")
+
+                if visual:
+                    color = (0, 0, 0)
+                    label = mapping[j + 1]
+                    thickness_in = 1
+                    size = 0.7
+                    label_length = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, size, thickness_in)
+                    copied = image.copy()
+                    cv2.rectangle(image, (10, 10), (20 + label_length[0][0], 40), (255, 255, 255), -1)
+                    cv2.putText(image, label, (16, 31),
+                                cv2.FONT_HERSHEY_SIMPLEX, size, tuple([i - 50 for i in color]), thickness_in,
+                                cv2.LINE_AA)
+                    image = cv2.addWeighted(image, 0.4, copied, 0.6, 0.0)
+
+                vw.write(image)
+
+        vw.release()

BaboonLand/scripts/charades2visual.py

@@ -0,0 +1,72 @@
+import os
+import sys
+import json
+import cv2
+from natsort import natsorted
+import pandas as pd
+from tqdm import tqdm
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    path_to_image = "charades/dataset/image"
+    path_to_video = "charades/dataset/visual"
+    annotation_train = "charades/annotation/train.csv"
+    annotation_val = "charades/annotation/val.csv"
+    classes_json = "charades/annotation/classes.json"
+    visual = True
+
+    if not os.path.exists(path_to_video):
+        os.makedirs(path_to_video)
+
+    with open(classes_json, "r") as file:
+        label2number = json.load(file)
+
+    number2label = {value: key for key, value in label2number.items()}
+
+    df_train = pd.read_csv(annotation_train, sep=" ")
+    df_val = pd.read_csv(annotation_val, sep=" ")
+    df = pd.concat([df_train, df_val], axis=0)
+    folders = natsorted(os.listdir(path_to_image))
+
+    hierarchy = {}
+
+    for folder in folders:
+        main = folder.split(".")[0]
+
+        if hierarchy.get(main) is None:
+            hierarchy[main] = [folder]
+        else:
+            hierarchy[main].append(folder)
+
+    for i, folder in tqdm(enumerate(hierarchy.keys()), total=len(hierarchy.keys())):
+        vw = cv2.VideoWriter(f"{path_to_video}/{folder}.mp4", cv2.VideoWriter_fourcc("m", "p", "4", "v"), 29.97,
+                             (400, 300))
+
+        for segment in hierarchy[folder]:
+            mapping = {}
+
+            for index, row in df[df.original_vido_id == segment].iterrows():
+                mapping[row["frame_id"]] = number2label[row["labels"]]
+
+            for j, file in enumerate(natsorted(os.listdir(path_to_image + os.sep + segment))):
+                image = cv2.imread(f"{path_to_image}/{segment}/{file}")
+
+                if visual:
+                    color = (0, 0, 0)
+                    label = mapping[j + 1]
+                    thickness_in = 1
+                    size = 0.7
+                    label_length = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, size, thickness_in)
+                    copied = image.copy()
+                    cv2.rectangle(image, (10, 10), (20 + label_length[0][0], 40), (255, 255, 255), -1)
+                    cv2.putText(image, label, (16, 31),
+                                cv2.FONT_HERSHEY_SIMPLEX, size, tuple([i - 50 for i in color]), thickness_in, cv2.LINE_AA)
+                    image = cv2.addWeighted(image, 0.4, copied, 0.6, 0.0)
+
+                vw.write(image)
+
+        vw.release()

BaboonLand/scripts/dataset2charades.py

@@ -0,0 +1,311 @@
+import os
+import sys
+import json
+from lxml import etree
+from collections import OrderedDict
+import pandas as pd
+from natsort import natsorted
+import cv2
+from tqdm import tqdm
+from sklearn.utils import shuffle
+import shutil
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    optimize = True
+    dataset_path = "dataset"
+    charades_path = "charades_"
+
+    label2number = {"Walking/Running": 0,
+                    "Sitting/Standing": 1,
+                    "Fighting/Playing": 2,
+                    "Self-Grooming": 3,
+                    "Being Groomed": 4,
+                    "Grooming Somebody": 5,
+                    "Mutual Grooming": 6,
+                    "Infant-Carrying": 7,
+                    "Foraging": 8,
+                    "Drinking": 9,
+                    "Mounting": 10,
+                    "Sleeping": 11,
+                    "Occluded": 12}
+
+    if not os.path.exists(charades_path):
+        os.makedirs(charades_path)
+
+    if not os.path.exists(f"{charades_path}/annotation"):
+        os.makedirs(f"{charades_path}/annotation")
+
+    if not os.path.exists(f"{charades_path}/dataset/image"):
+        os.makedirs(f"{charades_path}/dataset/image")
+
+    with open(f"{charades_path}/annotation/classes.json", "w") as file:
+        json.dump(label2number, file)
+
+    headers = {"original_vido_id": [], "video_id": pd.Series(dtype="int"), "frame_id": pd.Series(dtype="int"),
+               "path": [], "labels": []}
+    charades_df = pd.DataFrame(data=headers)
+    video_id = 1
+    folder_name = 1
+    flag = True
+
+    for i, folder in enumerate(natsorted(os.listdir(dataset_path))):
+        if os.path.exists(f"{dataset_path}/{folder}/actions"):
+            for j, file in enumerate(natsorted(os.listdir(f"{dataset_path}/{folder}/actions"))):
+                if os.path.splitext(file)[1] == ".xml":
+                    annotation_file = f"{dataset_path}/{folder}/actions/{file}"
+                    video_file = f"{dataset_path}/{folder}/mini-scenes/{os.path.splitext(file)[0]}.mp4"
+
+                    if not os.path.exists(video_file):
+                        print(f"{video_file} does not exist.")
+                        continue
+
+                    root = etree.parse(annotation_file).getroot()
+
+                    try:
+                        label = next(root.iterfind("track")).attrib["label"]
+                    except StopIteration:
+                        print(f"SKIPPED: {dataset_path}/{folder}/actions/{file}, EMPTY ANNOTATION")
+                        continue
+
+                    annotated = OrderedDict()
+
+                    for track in root.iterfind("track"):
+                        for entry in track.iter("points"):
+                            frame_id = entry.attrib["frame"]
+                            outside = entry.attrib["outside"]
+
+                            if outside == "1":
+                                continue
+
+                            behavior = "".join(entry.find("attribute").itertext())
+
+                            if annotated.get(frame_id) is None:
+                                annotated[frame_id] = OrderedDict()
+
+                            annotated[frame_id] = behavior
+
+                    counter = 0
+
+                    for value in annotated.values():
+                        if value in label2number.keys():
+                            counter += 1
+
+                    if counter < 90:
+                        print(f"SKIPPED: {dataset_path}/{folder}/actions/{file}, length={counter}<90")
+                        continue
+
+                    folder_code = f"{label[0].capitalize()}{folder_name:04d}"
+                    folder_name += 1
+                    output_folder = f"{charades_path}/dataset/image/{folder_code}"
+                    progress = f"{i + 1}/{len(os.listdir(dataset_path))}," \
+                               f"{j + 1}/{len(os.listdir(f'{dataset_path}/{folder}/actions'))}:" \
+                               f"{dataset_path}/{folder}/actions/{file} -> {output_folder}"
+                    print(progress)
+                    sys.stdout.flush()
+
+                    index = 0
+                    adjusted_index = 1
+                    vc = cv2.VideoCapture(video_file)
+                    size = int(vc.get(cv2.CAP_PROP_FRAME_COUNT))
+
+                    for k in range(1, size):
+                        if annotated.get(str(k)) is None:
+                            annotated[str(k)] = annotated[str(k - 1)]
+
+                    while vc.isOpened():
+                        if flag is False:
+                            if index < size:
+                                returned = True
+                                frame = None
+                            else:
+                                returned = False
+                                frame = None
+                        else:
+                            returned, frame = vc.read()
+
+                        if returned:
+                            if not os.path.exists(output_folder):
+                                os.makedirs(output_folder)
+
+                            behavior = annotated.get(str(index))
+
+                            if behavior in label2number.keys():
+                                if flag:
+                                    cv2.imwrite(f"{output_folder}/{adjusted_index}.jpg", frame)
+
+                                charades_df.loc[len(charades_df.index)] = [f"{folder_code}",
+                                                                           video_id,
+                                                                           adjusted_index,
+                                                                           f"{folder_code}/{adjusted_index}.jpg",
+                                                                           str(label2number[behavior])]
+
+                                adjusted_index += 1
+
+                            index += 1
+                        else:
+                            break
+
+                    vc.release()
+                    video_id += 1
+
+                    if video_id % 10 == 0:
+                        charades_df.to_csv(f"{charades_path}/annotation/data.csv", sep=" ", index=False)
+
+    charades_df.to_csv(f"{charades_path}/annotation/data.csv", sep=" ", index=False)
+    videos = shuffle(charades_df["original_vido_id"].unique(), random_state=42)
+    test = videos[:int(len(videos) / 100 * 25)]
+
+    train_original_vido_id = []
+    train_video_id = []
+    train_frame_id = []
+    train_path = []
+    train_labels = []
+    test_original_vido_id = []
+    test_video_id = []
+    test_frame_id = []
+    test_path = []
+    test_labels = []
+
+    for index, row in tqdm(charades_df.iterrows(), total=charades_df.shape[0]):
+        if row["original_vido_id"] in test:
+            test_original_vido_id.append(row["original_vido_id"])
+            test_video_id.append(row["video_id"])
+            test_frame_id.append(row["frame_id"])
+            test_path.append(row["path"])
+            test_labels.append(str(row["labels"]))
+        else:
+            train_original_vido_id.append(row["original_vido_id"])
+            train_video_id.append(row["video_id"])
+            train_frame_id.append(row["frame_id"])
+            train_path.append(row["path"])
+            train_labels.append(str(row["labels"]))
+
+    train_df = pd.DataFrame(data={"original_vido_id": train_original_vido_id,
+                                  "video_id": pd.Series(train_video_id, dtype="int"),
+                                  "frame_id": pd.Series(train_frame_id, dtype="int"),
+                                  "path": train_path, "labels": train_labels})
+    test_df = pd.DataFrame(data={"original_vido_id": test_original_vido_id,
+                                 "video_id": pd.Series(test_video_id, dtype="int"),
+                                 "frame_id": pd.Series(test_frame_id, dtype="int"),
+                                 "path": test_path, "labels": test_labels})
+
+    train_df.to_csv(f"{charades_path}/annotation/train.csv", sep=" ", index=False)
+    test_df.to_csv(f"{charades_path}/annotation/val.csv", sep=" ", index=False)
+
+    optimized_path = "charades"
+
+    if optimize:
+        shutil.copy(f"{charades_path}/annotation/classes.json", f"{optimized_path}/annotation/classes.json")
+
+        if not os.path.exists(optimized_path):
+            os.makedirs(optimized_path)
+
+        if not os.path.exists(f"{optimized_path}/annotation"):
+            os.makedirs(f"{optimized_path}/annotation")
+
+        if not os.path.exists(f"{optimized_path}/dataset/image"):
+            os.makedirs(f"{optimized_path}/dataset/image")
+
+        train_df = pd.read_csv(f"{charades_path}/annotation/train.csv", sep=" ")
+        val_df = pd.read_csv(f"{charades_path}/annotation/val.csv", sep=" ")
+        segment_size = 90
+
+        new_df = []
+        video_id = 1
+
+        for folder in tqdm(train_df["original_vido_id"].unique()):
+            subset = train_df[train_df["original_vido_id"] == folder].reset_index(drop=True)
+            number_of_subfolders = len(subset) // segment_size
+
+            for i in range(number_of_subfolders):
+                for j in range(segment_size):
+                    original_vido_id = subset.loc[i * segment_size + j]["original_vido_id"]
+                    new_original_vido_id = f"{original_vido_id}.{i + 1}"
+                    new_video_id = video_id
+                    new_frame_id = j + 1
+                    old_path = subset.loc[i * segment_size + j]["path"]
+                    new_path = f"{new_original_vido_id}/{new_frame_id}.jpg"
+                    new_labels = subset.loc[i * segment_size + j]["labels"]
+                    new_df.append([new_original_vido_id, new_video_id, new_frame_id, new_path, new_labels])
+
+                    if not os.path.exists(f"{optimized_path}/dataset/image/{new_original_vido_id}"):
+                        os.makedirs(f"{optimized_path}/dataset/image/{new_original_vido_id}")
+
+                    shutil.copy(f"{charades_path}/dataset/image/{old_path}",
+                                f"{optimized_path}/dataset/image/{new_path}")
+
+                video_id += 1
+
+            for i in range(len(subset) % segment_size):
+                original_vido_id = subset.loc[number_of_subfolders * segment_size + i]["original_vido_id"]
+                new_original_vido_id = f"{original_vido_id}.{number_of_subfolders + 1}"
+                new_video_id = video_id
+                new_frame_id = i + 1
+                old_path = subset.loc[number_of_subfolders * segment_size + i]["path"]
+                new_path = f"{new_original_vido_id}/{new_frame_id}.jpg"
+                new_labels = subset.loc[number_of_subfolders * segment_size + i]["labels"]
+                new_df.append([new_original_vido_id, new_video_id, new_frame_id, new_path, new_labels])
+
+                if not os.path.exists(f"{optimized_path}/dataset/image/{new_original_vido_id}"):
+                    os.makedirs(f"{optimized_path}/dataset/image/{new_original_vido_id}")
+
+                shutil.copy(f"{charades_path}/dataset/image/{old_path}", f"{optimized_path}/dataset/image/{new_path}")
+
+            video_id += 1
+
+        train_df = pd.DataFrame(new_df, columns=["original_vido_id", "video_id", "frame_id", "path", "labels"])
+        train_df.to_csv(f"{optimized_path}/annotation/train.csv", sep=" ", index=False)
+
+        new_df = []
+
+        for folder in tqdm(val_df["original_vido_id"].unique()):
+            subset = val_df[val_df["original_vido_id"] == folder].reset_index(drop=True)
+            number_of_subfolders = len(subset) // segment_size
+
+            for i in range(number_of_subfolders):
+                for j in range(segment_size):
+                    original_vido_id = subset.loc[i * segment_size + j]["original_vido_id"]
+                    new_original_vido_id = f"{original_vido_id}.{i + 1}"
+                    new_video_id = video_id
+                    new_frame_id = j + 1
+                    old_path = subset.loc[i * segment_size + j]["path"]
+                    new_path = f"{new_original_vido_id}/{new_frame_id}.jpg"
+                    new_labels = subset.loc[i * segment_size + j]["labels"]
+                    new_df.append([new_original_vido_id, new_video_id, new_frame_id, new_path, new_labels])
+
+                    if not os.path.exists(f"{optimized_path}/dataset/image/{new_original_vido_id}"):
+                        os.makedirs(f"{optimized_path}/dataset/image/{new_original_vido_id}")
+
+                    shutil.copy(f"{charades_path}/dataset/image/{old_path}",
+                                f"{optimized_path}/dataset/image/{new_path}")
+
+                video_id += 1
+
+            for i in range(len(subset) % segment_size):
+                original_vido_id = subset.loc[number_of_subfolders * segment_size + i]["original_vido_id"]
+                new_original_vido_id = f"{original_vido_id}.{number_of_subfolders + 1}"
+                new_video_id = video_id
+                new_frame_id = i + 1
+                old_path = subset.loc[number_of_subfolders * segment_size + i]["path"]
+                new_path = f"{new_original_vido_id}/{new_frame_id}.jpg"
+                new_labels = subset.loc[number_of_subfolders * segment_size + i]["labels"]
+                new_df.append([new_original_vido_id, new_video_id, new_frame_id, new_path, new_labels])
+
+                if not os.path.exists(f"{optimized_path}/dataset/image/{new_original_vido_id}"):
+                    os.makedirs(f"{optimized_path}/dataset/image/{new_original_vido_id}")
+
+                shutil.copy(f"{charades_path}/dataset/image/{old_path}", f"{optimized_path}/dataset/image/{new_path}")
+
+            video_id += 1
+
+        val_df = pd.DataFrame(new_df, columns=["original_vido_id", "video_id", "frame_id", "path", "labels"])
+        val_df.to_csv(f"{optimized_path}/annotation/val.csv", sep=" ", index=False)
+
+        shutil.rmtree(charades_path)
+    else:
+        shutil.move(charades_path, optimized_path)

BaboonLand/scripts/dataset2tracking.py

@@ -0,0 +1,197 @@
+import os
+import sys
+
+import cv2
+import json
+from lxml import etree
+from natsort import natsorted
+from collections import OrderedDict
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    path = "dataset"
+    tracking_path = "tracking"
+    test_size = 0.25
+
+    if not os.path.exists(tracking_path):
+        os.makedirs(tracking_path)
+
+    if not os.path.exists(f"{tracking_path}/train"):
+        os.makedirs(f"{tracking_path}/train")
+
+    if not os.path.exists(f"{tracking_path}/test"):
+        os.makedirs(f"{tracking_path}/test")
+
+    train_split = {}
+    test_split = {}
+
+    for folder in natsorted(os.listdir(path)):
+        vc = cv2.VideoCapture(f"{path}/{folder}/video.mp4")
+        train_start = 0
+        test_end = int(vc.get(cv2.CAP_PROP_FRAME_COUNT)) - 1
+        train_end = test_end - int(int(vc.get(cv2.CAP_PROP_FRAME_COUNT)) * test_size)
+        test_start = train_end + 1
+        vc.release()
+
+        train_split[folder] = {"start": train_start, "end": train_end}
+        test_split[folder] = {"start": test_start, "end": test_end}
+
+    with open(f"{tracking_path}/train.json", "w") as file:
+        json.dump(train_split, file, indent=4)
+
+    with open(f"{tracking_path}/test.json", "w") as file:
+        json.dump(test_split, file, indent=4)
+
+    for folder in natsorted(os.listdir(path)):
+        print(f"{path}/{folder} -> {tracking_path}/train/{folder} | {tracking_path}/test/{folder}")
+
+        if not os.path.exists(f"{tracking_path}/train/{folder}"):
+            os.makedirs(f"{tracking_path}/train/{folder}")
+
+        if not os.path.exists(f"{tracking_path}/test/{folder}"):
+            os.makedirs(f"{tracking_path}/test/{folder}")
+
+        video_path = f"{path}/{folder}/video.mp4"
+        annotation_path = f"{path}/{folder}/tracks.xml"
+
+        root = etree.parse(annotation_path).getroot()
+
+        annotated_train = dict()
+        annotated_test = dict()
+
+        for track in root.iterfind("track"):
+            track_id = int(track.attrib["id"])
+
+            for box in track.iter("box"):
+                frame_id = int(box.attrib["frame"])
+                keyframe = int(box.attrib["keyframe"])
+
+                if train_split[folder]["start"] <= frame_id <= train_split[folder]["end"]:
+                    if annotated_train.get(track_id) is None:
+                        annotated_train[track_id] = OrderedDict()
+
+                    if frame_id - train_split[folder]["start"] == 0:
+                        keyframe_train = 1
+                    else:
+                        keyframe_train = keyframe
+
+                    annotated_train[track_id][frame_id - train_split[folder]["start"]] = [int(float(box.attrib["xtl"])),
+                                                                                          int(float(box.attrib["ytl"])),
+                                                                                          int(float(box.attrib["xbr"])),
+                                                                                          int(float(box.attrib["ybr"])),
+                                                                                          keyframe_train]
+
+                if test_split[folder]["start"] <= frame_id <= test_split[folder]["end"]:
+                    if annotated_test.get(track_id) is None:
+                        annotated_test[track_id] = OrderedDict()
+
+                    if frame_id - test_split[folder]["start"] == 0:
+                        keyframe_test = 1
+                    else:
+                        keyframe_test = keyframe
+
+                    annotated_test[track_id][frame_id - test_split[folder]["start"]] = [int(float(box.attrib["xtl"])),
+                                                                                        int(float(box.attrib["ytl"])),
+                                                                                        int(float(box.attrib["xbr"])),
+                                                                                        int(float(box.attrib["ybr"])),
+                                                                                        keyframe_test]
+
+        xml_page = etree.Element("annotations")
+        etree.SubElement(xml_page, "version").text = "1.1"
+
+        for track_id in annotated_train.keys():
+            xml_track = etree.Element("track", id=str(track_id), label="Baboon", source="manual")
+
+            for frame_id in annotated_train[track_id].keys():
+                if frame_id == sorted(annotated_train[track_id].keys())[-1]:
+                    outside = "1"
+                else:
+                    outside = "0"
+
+                xml_box = etree.Element("box", frame=str(frame_id), outside=outside, occluded="0",
+                                        keyframe=str(annotated_train[track_id][frame_id][4]),
+                                        xtl=f"{annotated_train[track_id][frame_id][0]:.2f}",
+                                        ytl=f"{annotated_train[track_id][frame_id][1]:.2f}",
+                                        xbr=f"{annotated_train[track_id][frame_id][2]:.2f}",
+                                        ybr=f"{annotated_train[track_id][frame_id][3]:.2f}", z_order="0")
+
+                xml_track.append(xml_box)
+
+            if len(annotated_train[track_id].keys()) > 0:
+                xml_page.append(xml_track)
+
+        xml_document = etree.ElementTree(xml_page)
+        xml_document.write(f"{tracking_path}/train/{folder}/tracks.xml", xml_declaration=True, pretty_print=True,
+                           encoding="utf-8")
+
+        xml_page = etree.Element("annotations")
+        etree.SubElement(xml_page, "version").text = "1.1"
+
+        for track_id in annotated_test.keys():
+            xml_track = etree.Element("track", id=str(track_id), label="Baboon", source="manual")
+
+            for frame_id in annotated_test[track_id].keys():
+                if frame_id == sorted(annotated_test[track_id].keys())[-1]:
+                    outside = "1"
+                else:
+                    outside = "0"
+
+                xml_box = etree.Element("box", frame=str(frame_id), outside=outside, occluded="0",
+                                        keyframe=str(annotated_test[track_id][frame_id][4]),
+                                        xtl=f"{annotated_test[track_id][frame_id][0]:.2f}",
+                                        ytl=f"{annotated_test[track_id][frame_id][1]:.2f}",
+                                        xbr=f"{annotated_test[track_id][frame_id][2]:.2f}",
+                                        ybr=f"{annotated_test[track_id][frame_id][3]:.2f}", z_order="0")
+
+                xml_track.append(xml_box)
+
+            if len(annotated_test[track_id].keys()) > 0:
+                xml_page.append(xml_track)
+
+        xml_document = etree.ElementTree(xml_page)
+        xml_document.write(f"{tracking_path}/test/{folder}/tracks.xml", xml_declaration=True, pretty_print=True,
+                           encoding="utf-8")
+
+        vc = cv2.VideoCapture(video_path)
+        width, height = int(vc.get(cv2.CAP_PROP_FRAME_WIDTH)), int(vc.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        vw = cv2.VideoWriter(f"{tracking_path}/train/{folder}/video.mp4",
+                             cv2.VideoWriter_fourcc("m", "p", "4", "v"), 29.97, (width, height))
+        index = 0
+
+        while vc.isOpened():
+            returned, frame = vc.read()
+
+            if returned:
+                if train_split[folder]["start"] <= index <= train_split[folder]["end"]:
+                    vw.write(frame)
+
+                index += 1
+            else:
+                break
+
+        vc.release()
+        vw.release()
+
+        vc = cv2.VideoCapture(video_path)
+        width, height = int(vc.get(cv2.CAP_PROP_FRAME_WIDTH)), int(vc.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        vw = cv2.VideoWriter(f"{tracking_path}/test/{folder}/video.mp4",
+                             cv2.VideoWriter_fourcc("m", "p", "4", "v"), 29.97, (width, height))
+        index = 0
+
+        while vc.isOpened():
+            returned, frame = vc.read()
+
+            if returned:
+                if test_split[folder]["start"] <= index <= test_split[folder]["end"]:
+                    vw.write(frame)
+
+                index += 1
+            else:
+                break
+
+        vc.release()
+        vw.release()

BaboonLand/scripts/requirements.txt

@@ -0,0 +1,13 @@
+numpy>=1.23.4
+opencv-python>=4.7.0.68
+scipy>=1.10.0
+lxml>=4.9.2
+tqdm>=4.64.1
+torch>=1.10.0+cu111
+natsort>=8.2.0
+ruamel.yaml>=0.17.21
+ultralytics~=8.0.36
+pandas>=1.3.5
+matplotlib~=3.7.1
+seaborn~=0.12.2
+scikit-learn~=1.2.2

BaboonLand/scripts/tracking2ultralytics.py

@@ -0,0 +1,144 @@
+import os
+import sys
+import cv2
+import ruamel.yaml as yaml
+from lxml import etree
+from collections import OrderedDict
+from tqdm import tqdm
+import shutil
+from natsort import natsorted
+from sklearn.utils import shuffle
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    train_path = "tracking/train"
+    dataset = "tracking/ultralytics"
+    skip = 32
+
+    if os.path.exists(f"{dataset}"):
+        shutil.rmtree(f"{dataset}")
+
+    if not os.path.exists(f"{dataset}/images/train"):
+        os.makedirs(f"{dataset}/images/train")
+    if not os.path.exists(f"{dataset}/images/val"):
+        os.makedirs(f"{dataset}/images/val")
+    if not os.path.exists(f"{dataset}/images/test"):
+        os.makedirs(f"{dataset}/images/test")
+    if not os.path.exists(f"{dataset}/labels/train"):
+        os.makedirs(f"{dataset}/labels/train")
+    if not os.path.exists(f"{dataset}/labels/val"):
+        os.makedirs(f"{dataset}/labels/val")
+    if not os.path.exists(f"{dataset}/labels/test"):
+        os.makedirs(f"{dataset}/labels/test")
+
+    dataset_file = f"""
+    path: .
+    train: images/train
+    val: images/val
+    test: images/test
+
+    nc: 1
+    names: ['Baboon']
+    """
+
+    with open(f"{dataset}/ultralytics.yaml", "w") as file:
+        yaml.dump(yaml.load(dataset_file, Loader=yaml.RoundTripLoader, preserve_quotes=True),
+                  file, Dumper=yaml.RoundTripDumper)
+
+    label2index = {
+        "Baboon": 0,
+    }
+
+    videos = []
+    annotations = []
+
+    for folder in os.listdir(train_path):
+        videos.append(f"{train_path}/{folder}/video.mp4")
+        annotations.append(f"{train_path}/{folder}/tracks.xml")
+
+    for i, (video, annotation) in enumerate(zip(videos, annotations)):
+        print(f"{i + 1}/{len(annotations)}:")
+
+        if not os.path.exists(video):
+            print(f"Path {video} does not exist.")
+            continue
+
+        vc = cv2.VideoCapture(video)
+        width = vc.get(cv2.CAP_PROP_FRAME_WIDTH)
+        height = vc.get(cv2.CAP_PROP_FRAME_HEIGHT)
+        annotated_size = int(vc.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        root = etree.parse(annotation).getroot()
+        name = os.path.splitext(video.split("/")[-2])[0]
+
+        annotated = dict()
+
+        for track in root.iterfind("track"):
+            track_id = int(track.attrib["id"])
+            label = label2index[track.attrib["label"].lower().capitalize()]
+
+            for box in track.iter("box"):
+                frame_id = int(box.attrib["frame"])
+
+                if annotated.get(frame_id) is None:
+                    annotated[frame_id] = OrderedDict()
+
+                x_start = float(box.attrib["xtl"])
+                y_start = float(box.attrib["ytl"])
+                x_end = float(box.attrib["xbr"])
+                y_end = float(box.attrib["ybr"])
+                x_center = (x_start + (x_end - x_start) / 2) / width
+                y_center = (y_start + (y_end - y_start) / 2) / height
+                w = (x_end - x_start) / width
+                h = (y_end - y_start) / height
+                annotated[frame_id][track_id] = [label, x_center, y_center, w, h]
+
+        index = 0
+        pbar = tqdm(total=annotated_size)
+
+        while vc.isOpened():
+            returned, frame = vc.read()
+            saved = False
+
+            if returned:
+                if annotated.get(index) is not None:
+                    if index % skip == 0:
+                        for box in annotated[index].values():
+                            if not saved:
+                                cv2.imwrite(f"{dataset}/images/train/{name}_{index}.jpg", frame)
+                                saved = True
+
+                            with open(f"{dataset}/labels/train/{name}_{index}.txt", "a") as file:
+                                file.write(f"{box[0]} {box[1]:.6f} {box[2]:.6f} {box[3]:.6f} {box[4]:.6f}\n")
+
+                index += 1
+                pbar.update(1)
+            else:
+                break
+
+        pbar.close()
+        vc.release()
+
+    print("Distribute train, val, and test...")
+    images = natsorted([file for file in os.listdir(f"{dataset}/images/train") if
+                        os.path.isfile(os.path.join(f"{dataset}/images/train", file))])
+    labels = natsorted([file for file in os.listdir(f"{dataset}/labels/train") if
+                        os.path.isfile(os.path.join(f"{dataset}/labels/train", file))])
+
+    images, labels = shuffle(images, labels, random_state=42)
+
+    for file in tqdm(images[int(len(images) * 0.8):int(len(images) * 0.87)]):
+        shutil.move(f"{dataset}/images/train/{file}", f"{dataset}/images/val/{file}")
+
+    for file in tqdm(labels[int(len(labels) * 0.8):int(len(labels) * 0.87)]):
+        shutil.move(f"{dataset}/labels/train/{file}", f"{dataset}/labels/val/{file}")
+
+    for file in tqdm(images[int(len(images) * 0.87):]):
+        shutil.move(f"{dataset}/images/train/{file}", f"{dataset}/images/test/{file}")
+
+    for file in tqdm(labels[int(len(labels) * 0.87):]):
+        shutil.move(f"{dataset}/labels/train/{file}", f"{dataset}/labels/test/{file}")

BaboonLand/scripts/tracks2mini-scenes.py

@@ -0,0 +1,183 @@
+import numpy as np
+import os
+import sys
+from lxml import etree
+import cv2
+from src.utils import get_scene
+from collections import OrderedDict
+from tqdm import tqdm
+
+
+class Object:
+    def __init__(self, object_id, centroid, color, attribute=None):
+        self.object_id = object_id
+        self.centroid = centroid
+        self.color = color
+        self.attribute = attribute
+
+    def __getattr__(self, name):
+        if self.attribute is None:
+            return None
+
+        if self.attribute.get(name) is None:
+            return None
+        else:
+            return self.attribute[name]
+
+    @staticmethod
+    def object_factory(objects, centroids, colors, attributes):
+        entities = []
+
+        for object_id, centroid in objects.items():
+            assigned = False
+
+            for i, c in enumerate(centroids):
+                if np.array_equal(centroid, c):
+                    entities.append(Object(object_id, centroid, colors[object_id], attributes[i]))
+                    assigned = True
+
+            if not assigned:
+                # Object disappeared for some frames.
+                entities.append(Object(object_id, centroid, colors[object_id], None))
+
+        return entities
+
+
+def generate_timeline_image(folder, timeline, annotated_size):
+    timeline_image = np.zeros(shape=(len(timeline["tracks"].keys()) * 100, annotated_size, 3), dtype=np.uint8)
+
+    for i, (key, value) in enumerate(timeline["tracks"].items()):
+        if timeline["colors"].get(key) is None:
+            color = (127, 127, 127)
+        else:
+            color = timeline["colors"][key]
+
+        binary = np.array(value, dtype=np.int32)
+        binary[binary >= 0] = 1
+        binary[binary < 0] = 0
+        timeline_image[(i * 100):(i + 1) * 100, 0:annotated_size] = color
+        mask = np.repeat(np.array(binary, dtype=np.uint8).reshape(1, -1), repeats=100, axis=0)
+        image = timeline_image[(i * 100):(i + 1) * 100, 0:annotated_size]
+        timeline_image[(i * 100):(i + 1) * 100, 0:annotated_size] = \
+            cv2.bitwise_and(image, image, mask=mask)
+
+    timeline_resized = cv2.resize(timeline_image, (1000, timeline_image.shape[0]))
+
+    for i, (key, value) in enumerate(timeline["tracks"].items()):
+        if timeline["colors"].get(key) is None:
+            color = (127, 127, 127)
+        else:
+            color = timeline["colors"][key]
+
+        cv2.putText(timeline_resized, str(key), (30, i * 100 + 50),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, tuple([j - 30 for j in color]), 2, cv2.LINE_AA)
+
+    cv2.imwrite(f"{folder}/timeline.jpg", timeline_resized)
+
+
+def extract(path):
+    video_path = f"{path}/video.mp4"
+    annotation_path = f"{path}/tracks.xml"
+
+    root = etree.parse(annotation_path).getroot()
+
+    annotated = dict()
+
+    for track in root.iterfind("track"):
+        track_id = int(track.attrib["id"])
+
+        for box in track.iter("box"):
+            frame_id = int(box.attrib["frame"])
+
+            if annotated.get(frame_id) is None:
+                annotated[frame_id] = OrderedDict()
+
+            annotated[frame_id][track_id] = [int(float(box.attrib["xtl"])),
+                                             int(float(box.attrib["ytl"])),
+                                             int(float(box.attrib["xbr"])),
+                                             int(float(box.attrib["ybr"]))]
+
+    annotated_size = max(annotated.keys()) + 1
+    scene_width, scene_height = 400, 300
+    vc = cv2.VideoCapture(video_path)
+    print(f"{video_path} | {annotation_path} -> {path}/mini-scenes")
+
+    if not os.path.exists(f"{path}/mini-scenes"):
+        os.makedirs(f"{path}/mini-scenes")
+
+    index = 0
+    tracked_indices = OrderedDict()
+    timeline = OrderedDict()
+    timeline["tracks"] = OrderedDict()
+    timeline["tracks"]["main"] = [-1] * annotated_size
+    timeline["colors"] = {}
+    vc.set(cv2.CAP_PROP_POS_FRAMES, index)
+    tracks_vw = dict()
+    pbar = tqdm(total=annotated_size)
+
+    while vc.isOpened():
+        returned, frame = vc.read()
+
+        if returned:
+            if annotated.get(index) is not None:
+                centroids = []
+                attributes = []
+                objects = OrderedDict()
+                colors = OrderedDict()
+
+                for object_id, box in annotated[index].items():
+                    attribute = {}
+
+                    centroid = (int(box[0] + (box[2] - box[0]) / 2), int(box[1] + (box[3] - box[1]) / 2))
+                    centroids.append(centroid)
+                    attribute["box"] = box
+                    attributes.append(attribute)
+
+                    objects[object_id] = centroid
+                    colors_values = [(170, 105, 63), (58, 61, 189), (149, 91, 107), (69, 65, 127), (65, 174, 213),
+                                     (87, 111, 118), (46, 122, 228), (201, 158, 190), (127, 234, 241), (109, 110, 0),
+                                     (169, 140, 87), (85, 209, 246), (141, 75, 0), (44, 85, 242), (227, 222, 149),
+                                     (194, 205, 237), (117, 49, 206), (71, 114, 90), (149, 176, 207)]
+                    colors[object_id] = colors_values[object_id % len(colors_values)]
+                    timeline["colors"][object_id] = colors[object_id]
+
+                objects = Object.object_factory(objects, centroids, colors, attributes=attributes)
+
+                for object in objects:
+                    if tracks_vw.get(object.object_id) is None:
+                        tracks_vw[object.object_id] = cv2.VideoWriter(f"{path}/mini-scenes/{object.object_id}.mp4",
+                                                                      cv2.VideoWriter_fourcc("m", "p", "4", "v"),
+                                                                      29.97, (scene_width, scene_height))
+                        tracked_indices[object.object_id] = 0
+                        timeline["tracks"][object.object_id] = [-1] * annotated_size
+
+                for object in objects:
+                    scene_frame = frame.copy()
+                    scene_frame = get_scene(scene_frame, object, scene_width, scene_height)
+                    tracks_vw[object.object_id].write(scene_frame)
+                    timeline["tracks"][object.object_id][index] = tracked_indices[object.object_id]
+                    tracked_indices[object.object_id] += 1
+
+            timeline["tracks"]["main"][index] = index
+            index += 1
+            pbar.update(1)
+        else:
+            break
+
+    for track_key in tracks_vw.keys():
+        tracks_vw[track_key].release()
+
+    generate_timeline_image(path, timeline, annotated_size)
+    pbar.close()
+    vc.release()
+
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    for item in os.listdir("dataset"):
+        if os.path.isdir(f"dataset/{item}"):
+            extract(f"dataset/{item}")

BaboonLand/scripts/ultralytics2pyramid.py

@@ -0,0 +1,172 @@
+import os
+import sys
+import cv2
+import ruamel.yaml as yaml
+from tqdm import tqdm
+
+if __name__ == "__main__":
+    if "scripts" in os.listdir(".."):
+        os.chdir("..")
+
+    sys.dont_write_bytecode = True
+
+    slices_pyramid = [2, 3, 4]
+    ultralytics_path = "tracking/ultralytics"
+    pyramid_path = "tracking/pyramid"
+    draw_boxes = False
+
+    if not os.path.exists(f"{pyramid_path}/images/train"):
+        os.makedirs(f"{pyramid_path}/images/train")
+    if not os.path.exists(f"{pyramid_path}/images/val"):
+        os.makedirs(f"{pyramid_path}/images/val")
+    if not os.path.exists(f"{pyramid_path}/images/test"):
+        os.makedirs(f"{pyramid_path}/images/test")
+    if not os.path.exists(f"{pyramid_path}/labels/train"):
+        os.makedirs(f"{pyramid_path}/labels/train")
+    if not os.path.exists(f"{pyramid_path}/labels/val"):
+        os.makedirs(f"{pyramid_path}/labels/val")
+    if not os.path.exists(f"{pyramid_path}/labels/test"):
+        os.makedirs(f"{pyramid_path}/labels/test")
+
+    dataset_file = f"""
+    path: .
+    train: images/train
+    val: images/val
+    test: images/test
+
+    nc: 1
+    names: ['Baboon']
+    """
+
+    with open(f"{pyramid_path}/pyramid.yaml", "w") as file:
+        yaml.dump(yaml.load(dataset_file, Loader=yaml.RoundTripLoader, preserve_quotes=True),
+                  file, Dumper=yaml.RoundTripDumper)
+
+    images = []
+    annotations = []
+
+    for file in os.listdir(f"{ultralytics_path}/images/train"):
+        images.append(f"{ultralytics_path}/images/train/{file}")
+        annotations.append(f"{ultralytics_path}/labels/train/{os.path.splitext(file)[0]}.txt")
+
+    for file in os.listdir(f"{ultralytics_path}/images/val"):
+        images.append(f"{ultralytics_path}/images/val/{file}")
+        annotations.append(f"{ultralytics_path}/labels/val/{os.path.splitext(file)[0]}.txt")
+
+    for file in os.listdir(f"{ultralytics_path}/images/test"):
+        images.append(f"{ultralytics_path}/images/test/{file}")
+        annotations.append(f"{ultralytics_path}/labels/test/{os.path.splitext(file)[0]}.txt")
+
+    for slices in slices_pyramid:
+        for image_path, annotation_path in tqdm(zip(images, annotations), total=len(images)):
+            name = os.path.splitext(image_path.split("/")[-1])[0]
+            image = cv2.imread(image_path)
+            image_height, image_width = image.shape[:2]
+
+            with open(annotation_path, "r") as file:
+                bounding_boxes_ultralytics = file.readlines()
+                bounding_boxes = []
+
+                for bounding_box_ultralytics in bounding_boxes_ultralytics:
+                    label, x, y, width, height = bounding_box_ultralytics.strip().split(" ")
+                    label, x, y, width, height = int(label), float(x), float(y), float(width), float(height)
+                    x *= image_width
+                    y *= image_height
+                    width *= image_width
+                    height *= image_height
+                    bounding_boxes.append([label,
+                                           int(x - width // 2),
+                                           int(y - height // 2),
+                                           int(x - width // 2 + width),
+                                           int(y - height // 2 + height)])
+
+            slice_height = image_height // slices
+            slice_width = image_width // slices
+
+            for i in range(slices):
+                for j in range(slices):
+                    index = (i * slices) + j + 1
+                    distribution_folder = image_path.split("/")[-2]
+                    y_start = i * slice_height
+                    y_end = (i + 1) * slice_height
+                    x_start = j * slice_width
+                    x_end = (j + 1) * slice_width
+                    sliced = image[y_start:y_end, x_start:x_end]
+                    tile = [x_start, y_start, x_end, y_end]
+                    tile_boxes = []
+
+                    for bounding_box in bounding_boxes:
+                        points = [False, False, False, False]
+
+                        if tile[0] <= bounding_box[1] and tile[2] >= bounding_box[1]:
+                            if tile[1] <= bounding_box[2] and tile[3] >= bounding_box[2]:
+                                points[0] = True
+                            if tile[1] <= bounding_box[4] and tile[3] >= bounding_box[4]:
+                                points[2] = True
+
+                        if tile[0] <= bounding_box[3] and tile[2] >= bounding_box[3]:
+                            if tile[1] <= bounding_box[2] and tile[3] >= bounding_box[2]:
+                                points[1] = True
+                            if tile[1] <= bounding_box[4] and tile[3] >= bounding_box[4]:
+                                points[3] = True
+
+                        if sum(points) == 0:
+                            continue
+                        elif sum(points) == 4:
+                            tile_boxes.append([bounding_box[0], bounding_box[1] - tile[0], bounding_box[2] - tile[1],
+                                               bounding_box[3] - tile[0], bounding_box[4] - tile[1]])
+                        elif points[0]:
+                            if points[1]:
+                                tile_boxes.append(
+                                    [bounding_box[0], bounding_box[1] - tile[0], bounding_box[2] - tile[1],
+                                     bounding_box[3] - tile[0], slice_height - 1])
+                            elif points[2]:
+                                tile_boxes.append(
+                                    [bounding_box[0], bounding_box[1] - tile[0], bounding_box[2] - tile[1],
+                                     slice_width - 1, bounding_box[4] - tile[1]])
+                            else:
+                                tile_boxes.append(
+                                    [bounding_box[0], bounding_box[1] - tile[0], bounding_box[2] - tile[1],
+                                     slice_width - 1, slice_height - 1])
+                        elif points[1]:
+                            if points[3]:
+                                tile_boxes.append([bounding_box[0], 0, bounding_box[2] - tile[1],
+                                                   bounding_box[3] - tile[0], bounding_box[4] - tile[1]])
+                            else:
+                                tile_boxes.append([bounding_box[0], 0, bounding_box[2] - tile[1],
+                                                   bounding_box[3] - tile[0], slice_height - 1])
+                        elif points[2]:
+                            if points[3]:
+                                tile_boxes.append([bounding_box[0], bounding_box[1] - tile[0], 0,
+                                                   bounding_box[3] - tile[0], bounding_box[4] - tile[1]])
+                            else:
+                                tile_boxes.append([bounding_box[0], bounding_box[1] - tile[0], 0,
+                                                   slice_width - 1, bounding_box[4] - tile[1]])
+                        else:
+                            tile_boxes.append(
+                                [bounding_box[0], 0, 0, bounding_box[3] - tile[0], bounding_box[4] - tile[1]])
+
+                    if draw_boxes:
+                        for tile_box in tile_boxes:
+                            cv2.rectangle(sliced, (tile_box[1], tile_box[2]), (tile_box[3], tile_box[4]),
+                                          (255, 255, 255))
+
+                    cv2.imwrite(f"{pyramid_path}/images/{distribution_folder}/{name}.slice-{slices}.index-{index}.png",
+                                sliced)
+
+                    if len(tile_boxes) > 0:
+                        for tile_box in tile_boxes:
+                            x_center = (tile_box[1] + (tile_box[3] - tile_box[1]) / 2) / slice_width
+                            y_center = (tile_box[2] + (tile_box[4] - tile_box[2]) / 2) / slice_height
+                            w = (tile_box[3] - tile_box[1]) / slice_width
+                            h = (tile_box[4] - tile_box[2]) / slice_height
+
+                            with open(
+                                    f"{pyramid_path}/labels/{distribution_folder}/{name}.slice-{slices}.index-{index}.txt",
+                                    "a") as file:
+                                file.write(f"{tile_box[0]} {x_center:.6f} {y_center:.6f} {w:.6f} {h:.6f}\n")
+                    else:
+                        with open(
+                                f"{pyramid_path}/labels/{distribution_folder}/{name}.slice-{slices}.index-{index}.txt",
+                                "w") as file:
+                            pass