Upload WCv1LMDBReader.py with huggingface_hub

WCv1LMDBReader.py

@@ -0,0 +1,258 @@
+import os
+import sys
+import lmdb
+import gzip
+import torch
+import logging
+import numpy as np
+from enum import Enum
+import safetensors.torch
+from torch.utils.data import Dataset
+from flumapping.utils.Utils import one_hot_encode, count_classes
+
+"""
+tensors = {
+        "center": torch.tensor(center),
+        "wcmap": map_data,
+        "B4": rgbnir_data[0, :, :],
+        "B3": rgbnir_data[1, :, :],
+        "B2": rgbnir_data[2, :, :],
+        "B8": rgbnir_data[3, :, :],
+        "B11": swir_data[0, :, :],
+        "B12": swir_data[1, :, :],
+        "S1VV": s1_data[0, :, :],
+        "S1VH": s1_data[1, :, :],
+        "classprops": torch.tensor(count_classes(map_data)),
+    }
+"""
+
+
+class Bands(Enum):
+    B2 = "B2"  # blue
+    B3 = "B3"  # green
+    B4 = "B4"  # red
+    B8 = "B8"  # VNIR
+    B11 = "B11"  # SWIR
+    B12 = "B12"  # SWIR
+    S1VV = "S1VV"
+    S1VH = "S1VH"
+    RGBNIR = "RGBNIR"
+    SWIR = "SWIR"
+    S1 = "S1"
+    ALL = "ALL"
+
+
+class WCv1LMDBReader(Dataset):
+    def __init__(self,
+                 map_lmdb_file: os.PathLike,
+                 split: str,
+                 return_key=False,
+                 readonly=True,
+                 lmdb_size_limit=8*1024**3,
+                 key_type=str,
+                 max_len=-1,
+                 return_type=tuple,
+                 output_bands: list = [Bands.RGBNIR],
+                 transforms=None
+                 ):
+        super().__init__()
+        self.map_lmdb_file = map_lmdb_file
+        self.env: lmdb.Environment | None = None
+        self.db = None
+        self.return_key = return_key
+        self.logger = logging.getLogger(__name__)
+        self.readonly = readonly
+        self._keys = None
+        self.lmdb_size_limit = lmdb_size_limit
+        self.key_type = key_type
+        self.max_len = max_len
+        self.return_type = return_type
+        # self.configure_output(output_bands)
+        self. transforms = transforms
+        self.split = split
+        
+        if split is not None:
+            assert split in ['train', 'val', 'test'], f"unrecignized split type. Expected one of ['train', 'val', 'test'] but got {split}"
+        
+        # self.keys()
+        self.configure_output(output_bands)
+
+        
+    def configure_output(self, output_bands):
+        output = []
+        for band in output_bands:
+            if band == Bands.RGBNIR:
+                output += [Bands.B2, Bands.B3, Bands.B4, Bands.B8]
+            elif band == Bands.SWIR:
+                output += [Bands.B11, Bands.B12]
+            elif band == Bands.S1:
+                output += [Bands.S1VV, Bands.S1VH]
+            elif band == Bands.ALL:
+                output = [Bands.B2, Bands.B3, Bands.B4, Bands.B8,
+                          Bands.B11, Bands.B12, Bands.S1VV, Bands.S1VH]
+            else:
+                if band not in output:
+                    output.append(band)
+        self.output_bands = output
+
+    def set_transforms(self, transfomrs):
+        self.transforms = transfomrs
+
+    def set_max_len(self, max_len):
+        self.max_len = max_len
+        self.keys()
+
+    def open_env(self):
+        try:
+            if self.env is None:
+                self.logger.info(
+                    f"Opening LMDB environment at {self.map_lmdb_file} ...")
+                self.env = lmdb.open(
+                    self.map_lmdb_file,
+                    readonly=self.readonly,
+                    lock=not self.readonly,
+                    meminit=False,
+                    readahead=True,
+                    map_size=self.lmdb_size_limit,
+                    max_spare_txns=18,
+                    max_dbs=3
+                )
+                if self.split is not None:
+                    self.db = self.env.open_db(self.split.encode())
+                else:
+                    self.db = None
+        except Exception as err:
+            raise err
+
+    def keys(self, update: bool = False):
+        self.open_env()
+
+        if self._keys is None or update:
+            logging.info("(Re-)Reading keys")
+            with self.env.begin(db=self.db) as txn:
+                self._keys = list(txn.cursor().iternext(values=False))
+            if self.key_type == str:
+                self._keys = [x.decode() for x in self._keys]
+            elif self.key_type == int:
+                self._keys = [int.from_bytes(x, 'big') for x in self._keys]
+        if self.max_len > 0:
+            idxs = np.random.choice(np.arange(len(self._keys)), self.max_len)
+            self._keys = np.asarray(self._keys)[idxs]
+        return self._keys
+
+    def _encode_key(self, key):
+        if self.key_type == str:
+            return key.encode()
+        if self.key_type == int:
+            return key.to_bytes(sys.getsizeof(key), 'big')
+        return None
+
+    def close_env(self):
+        if self.env is not None:
+            self.env.close()
+            self.env = None
+
+    def update_key(self, key: str, updateData: dict, compress=False) -> bool:
+        try:
+            if self.env is None:
+                self.logger.info("LMDB not yet opened")
+                self.logger.info("Open LMDB")
+                self.open_env()
+            with self.env.begin(write=True, db=self.db) as txn:
+                byte_data = safetensors.torch.save(updateData)
+                if compress:
+                    byte_data = gzip.compress(byte_data)
+                status = txn.put(self._encode_key(key), byte_data)
+            return status
+        except Exception as ex:
+            print(ex)
+            self.logger.error(ex)
+            raise ex
+        
+    def delete_key(self, index:str|int):
+        if type(index) == int and self.key_type != int:
+            key = self._keys[index]
+        else:
+            key = index
+        with self.env.begin(write=True, buffers=True, db=self.db) as txn:
+            status = txn.delete(self._encode_key(key))
+            self.keys()
+            return status
+
+    def __len__(self):
+        if self._keys is None:
+            self.logger.info("keys are not loaded yet")
+            self.logger.info("Loading keys")
+            self.keys()
+        if self.max_len > 0:
+            return self.max_len
+        else:
+            return len(self._keys)
+
+    def __getitem__(self, index: int | str):
+        assert type(index) == int or type(
+            index) == str, f"index can only be of type int or str. Got {type(index)}"
+
+        if self.env is None:
+            self.logger.info("LMDB not yet opened")
+            self.logger.info("Open LMDB")
+            try:
+                self.open_env()
+            except Exception as err:
+                raise err
+            
+        key = None
+        with self.env.begin(write=False, buffers=True) as txn:
+            if type(index) == int and self.key_type != int:
+                byte_data = txn.get(self._encode_key(self._keys[index]), db=self.db)
+                key = self._keys[index]
+            else:
+                byte_data = txn.get(self._encode_key(index), db=self.db)
+                key = index
+            magic_number = b'\x1f\x8b'
+
+            try:
+                # check if byte_data is gzip-compressed
+                if (bytes([byte_data[0], byte_data[1]]) == magic_number):
+                    tensor_dict = safetensors.torch.load(
+                        gzip.decompress(byte_data))
+                else:
+                    tensor_dict = safetensors.torch.load(bytes(byte_data))
+            except KeyError as e:
+                print(e)
+
+            # print(tensor_dict.keys())
+            # print(self.output_bands)
+
+            if "wcmap" in tensor_dict.keys():
+                num_no_data = torch.where(tensor_dict['wcmap'] == 0, 1, 0)
+                # if (torch.sum(num_no_data) > 0):
+                #     print(f"{key} contains nodata")
+                class_values = [10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 100]
+                label = tensor_dict['wcmap'].clone()
+                for i, val in enumerate(class_values):
+                    label = torch.where(
+                        label == val, i, label)
+                label = torch.nn.functional.one_hot(
+                    label.squeeze().type(torch.LongTensor), 11).permute(2, 0, 1)
+
+            if self.return_key:
+                tensor_dict['key'] = key
+        if self.return_type == dict:
+            return tensor_dict
+        else:
+            bands = []
+            for band in self.output_bands:
+                bands.append(tensor_dict[band.value])
+            rs_image = torch.stack(bands, 0).type(torch.float32)
+            
+            if self.transforms is not None:
+                image = self.transforms(rs_image)
+            else:
+                image = rs_image
+
+            if "classprops" in tensor_dict.keys():
+                class_props = tensor_dict['classprops']
+            else:
+                class_props = count_classes(tensor_dict['wcmap'])
+            return (image, label, class_props)