New semantic masks

Signed-off-by: Jiri Podivin <[email protected]>

.gitattributes

@@ -64,3 +64,4 @@ metadata filter=lfs diff=lfs merge=lfs -text
 metadata_semantic_test.csv filter=lfs diff=lfs merge=lfs -text
 metadata_semantic_train.csv filter=lfs diff=lfs merge=lfs -text
 metadata_test.csv filter=lfs diff=lfs merge=lfs -text
+semantic_masks.tar.gz filter=lfs diff=lfs merge=lfs -text

masks.tar.00

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

masks.tar.01

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

metadata_semantic_test.csv

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

metadata_semantic_train.csv

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

semantic_masks.tar.01

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

semantic_masks.tar.00 → semantic_masks.tar.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:41d2d9638b7f12a5284ced53e1d9a4591b11c3227476feed328ca48947b744a5
-size 582758400
+oid sha256:67d089fdb940fae15dc5d9cae0af139a007888221d8821b6cd33ab4d49ee571a
+size 287311415

utils/convert_masks.py

@@ -0,0 +1,202 @@
+#!/bin/env python
+
+import numpy as np
+import json
+import os
+import numpy as np
+from PIL import Image
+from multiprocessing import Pool, cpu_count
+from urllib.parse import unquote
+from datetime import datetime
+import pandas as pd
+import os
+import tempfile
+import argparse
+import glob
+
+class InputStream:
+    def __init__(self, data):
+        self.data = data
+        self.i = 0
+
+    def read(self, size):
+        out = self.data[self.i : self.i + size]
+        self.i += size
+        return int(out, 2)
+
+
+def access_bit(data, num):
+    """from bytes array to bits by num position"""
+    base = int(num // 8)
+    shift = 7 - int(num % 8)
+    return (data[base] & (1 << shift)) >> shift
+
+
+def bytes2bit(data):
+    """get bit string from bytes data"""
+    return ''.join([str(access_bit(data, i)) for i in range(len(data) * 8)])
+
+
+def decode_rle(rle, print_params: bool = False):
+    """from LS RLE to numpy uint8 3d image [width, height, channel]
+
+    Args:
+        print_params (bool, optional): If true, a RLE parameters print statement is suppressed
+    """
+    input = InputStream(bytes2bit(rle))
+    num = input.read(32)
+    word_size = input.read(5) + 1
+    rle_sizes = [input.read(4) + 1 for _ in range(4)]
+
+    if print_params:
+        print(
+            'RLE params:', num, 'values', word_size, 'word_size', rle_sizes, 'rle_sizes'
+        )
+
+    i = 0
+    out = np.zeros(num, dtype=np.uint8)
+    while i < num:
+        x = input.read(1)
+        j = i + 1 + input.read(rle_sizes[input.read(2)])
+        if x:
+            val = input.read(word_size)
+            out[i:j] = val
+            i = j
+        else:
+            while i < j:
+                val = input.read(word_size)
+                out[i] = val
+                i += 1
+    return out
+
+def log(message):
+    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    print(f"[{timestamp}] {message}")
+
+def save_image(mask_image: Image.Image, save_path: str):
+    mask_image.save(save_path, format='PNG')
+    log(f'Saved mask: {save_path}')
+
+def process_files_in_parallel(files_to_process, masks_save_directory, source_files):
+    with Pool(processes=cpu_count()//2) as pool:
+        results = pool.starmap(process_file, [(file, masks_save_directory, source_files) for file in files_to_process])
+    
+    return [e for r in results for e in r]
+
+
+def process_file(file_path, masks_save_directory, source_files):
+    log(f"Opening file: {file_path}")
+    total_metadata = []
+    try:
+        with open(file_path, 'r') as file:
+            data = json.load(file)
+    except Exception as e:
+        log(f'Error reading file {file_path}: {e}')
+        return total_metadata
+    
+    image_name = data['task']['data']['image'].split('/')[-1]
+
+    if image_name not in source_files:
+        log(f"Requested file {image_name} does not exist in source data!")
+        return total_metadata
+
+    image_name_prefix = unquote(image_name.rsplit('.', 1)[0])
+    log(f"Processing image: {image_name_prefix}")
+    label_counts = {}
+
+    for result in data['result']:
+        if 'rle' not in result['value']:
+            log(f"No 'rle' key found in result: {result.get('id', 'Unknown ID')}")
+            continue
+        
+        rle_data = result['value']['rle']
+        rle_bytes = bytes.fromhex(''.join(format(x, '02x') for x in rle_data))
+        mask = decode_rle(rle_bytes)
+
+        original_height = result['original_height']
+        original_width = result['original_width']
+        mask = mask.reshape((original_height, original_width, 4))
+
+        alpha_channel = mask[:, :, 3]
+        mask_image = np.zeros((original_height, original_width, 3), dtype=np.uint8)
+        mask_image[alpha_channel == 255] = [255, 255, 255]
+
+        if 'brushlabels' in result['value']:
+            for label in result['value']['brushlabels']:
+
+                label_counts[label] = label_counts.get(label, 0) + 1
+                save_path = os.path.join(masks_save_directory, f"{image_name_prefix}-{label}-{label_counts[label]}.png")
+                save_image(Image.fromarray(mask_image).convert('L'), save_path)
+                metadata = {
+                    "original_height": result['original_height'],
+                    "original_width": result['original_width'],
+                    "image": os.path.join('sourcedata/labeled/', os.path.basename(data['task']['data']['image'])),
+                    "score": result['score'] if 'score' in result.keys() else 0,
+                    "mask": save_path,
+                    "class": label,
+                }
+                total_metadata.append(metadata)
+
+    return total_metadata
+
+def merge_file_masks(mask_info, target_mask_dir, label2id, img):
+    final_mask = np.zeros(
+        np.asarray(Image.open(mask_info['mask'].iloc[0])).shape, dtype=np.uint8)
+    for i, r in mask_info.iterrows():
+        mask = np.asarray(Image.open(r['mask']))
+        final_mask = np.where(mask == 0, final_mask, label2id[r['class']])
+    
+    mask_path = os.path.join(target_mask_dir, f"{os.path.basename(img).split('.')[0]}_mask.png")
+    Image.fromarray(final_mask).convert('L').save(mask_path, format='PNG')
+    return {
+        'mask': mask_path,
+        'image': img,
+        'original_height': r['original_height'],
+        'original_width': r['original_width']
+    }
+
+def merge_masks(mask_metadata, target_mask_dir, label2id):
+    new_metadata = []
+    imgs = [
+        (
+            mask_metadata[mask_metadata['image'] == img],
+            target_mask_dir,
+            label2id,
+            img
+        ) for img in mask_metadata['image'].unique()]
+
+    
+    with Pool(processes=cpu_count()//2) as pool:
+        new_metadata = pool.starmap(merge_file_masks, imgs)
+
+    return new_metadata
+
+
+def main():
+    parser = argparse.ArgumentParser('maskconvert')
+    parser.add_argument('dataset_root')
+
+    arguments = parser.parse_args()
+    annotations_folder_path = os.path.join(arguments.dataset_root, 'labels_raw')
+    tmp_mask_path = tempfile.mkdtemp('masks')
+ 
+    files_to_process = glob.glob(f"{annotations_folder_path}/*")
+
+    # For sanity check
+    source_files = [os.path.basename(name) for name in glob.glob(f"sourcedata/**/*.jpg")]
+
+    metadata = pd.DataFrame(process_files_in_parallel(files_to_process, tmp_mask_path, source_files))
+
+    id2label = {int(k): v for k, v in enumerate(['void', 'Fruit', 'Leaf', 'Flower', 'Stem'])}
+
+    label2id = {v: k for k, v in id2label.items()}
+
+    result = merge_masks(metadata, os.path.join(arguments.dataset_root, 'semantic_masks'), label2id)
+    result = pd.DataFrame(result).drop_duplicates()
+    result.to_csv(
+        os.path.join(arguments.dataset_root, 'semantic_metadata.csv'),
+        index=False)
+
+
+if __name__ == '__main__':
+    main()