WCv1LMDBReader.py

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

"""
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 count_classes(self, map: np.ndarray | torch.Tensor,output_type=None) -> np.ndarray | torch.Tensor:
        """function to count the class proportions of an segmentation map.
    
        Args:
            map (np.ndarray | torch.Tensor): input map on which the class proportions needs to be counted. Input can be a single map (np.ndarray) or batched tensor of multiple maps (torch.Tensor)
    
        Returns:
            np.ndarray | torch.Tensor: the class proportions of the input map. 
        """
        if len(map.shape) == 3:
            map = map.squeeze()
        
        if type(map) == np.ndarray:
            map = torch.tensor(map, dtype=torch.float32)
        
        output = []
        num_pixel = map.shape[0] * map.shape[1]
        
        for i in range(10, 110, 10):
            if len(map.shape) == 4:
                percentage = torch.sum(torch.where(map == i, 1, 0), dim=(1,2,3)) / num_pixel
            else:
                percentage = torch.sum(torch.where(map == i, 1, 0)) / num_pixel
            output.append(percentage)
            
            if i == 90:
                if len(map.shape) == 4:
                    percentage = torch.sum(torch.where(map == i, 1, 0), dim=(1,2,3)) / num_pixel
                else:
                    percentage = torch.sum(torch.where(map == i, 1, 0)) / num_pixel
                output.append(percentage)
        
        if len(map.shape) == 4:
            class_props = torch.stack(output, dim=1)
            class_props.requires_grad = True
        else:
            class_props = torch.tensor(output)
        
        if type(map) == np.ndarray:
            return class_props.cpu().detach().numpy()
        if type(map) == torch.Tensor:
            if output_type is not None:
                return class_props.type(dtype=output_type)
            else:
                return class_props

    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 = self.count_classes(tensor_dict['wcmap'])
            return (image, label, class_props)