melage 0.0.65__py3-none-any.whl → 1.0.0__py3-none-any.whl

melage/plugins/warpseg/warpseg_main/data_reader/DDSet.py

@@ -0,0 +1,303 @@
+import os.path
+from os.path import basename, splitext
+import random
+random.seed(0)
+import torch
+import numpy as np
+import traceback
+
+import matplotlib.pyplot as plt
+import json
+import torch.nn.functional as F
+import os
+
+
+from .baseData import baseData
+from .utils import remove_zero, restore_zero, pad_to_multiple_of_32, createPathData_IXI, creaePathData_LDM_fullhead
+
+import SimpleITK as sitk
+from .utils import resample_to_size, read_atlas_file
+import nibabel as nib
+from .utils import normalize as normalize_image
+
+
+
+
+def softmax_to_logits(softmax_probs, epsilon=1e-6):
+    softmax_probs = np.clip(softmax_probs, epsilon, 1 - epsilon)  # Avoid log(0)
+    return np.log(softmax_probs) - np.log(1 - softmax_probs)
+
+class DDSet(baseData):
+    def options(self, opt, type, novalid):
+        """
+        options of the data set
+        :param opt:
+        :return:
+        """
+        self.opt = opt
+        self.state = 'train'
+        self.opt = opt
+
+        images_IXI = createPathData_IXI()
+        if self.opt.state=='test':
+            self.ILpath = images_IXI
+        else:
+            image_full_head = creaePathData_LDM_fullhead()
+            self.ILpath = image_full_head + images_IXI
+            self.ILpath = self.ILpath[4000:]
+
+
+        target_shapes = [None]
+        self.y_true = []
+        self.probs = []
+        self.prob_file = '/atlas/processed/atlas_prob30_raw_fastSurfer.nii.gz'
+
+        prob_values_ = read_atlas_file(self.prob_file, save_again=True)
+        prob_values = prob_values_.get_fdata()
+
+        self.target_size = []
+        for target_shape in target_shapes:
+            #if target_shape==[128, 160, 128]:
+            #    print('r')
+            y_true, probs, target_size = self.compute_prob_atlas(prob_values, target_shape)
+            self.y_true.append(y_true)
+            self.probs.append(probs)
+            self.target_size.append(target_size)
+
+        self.max_count = self.__len__()+1
+        self.new_path = os.path.join(self.opt.chkptDir, 'save_images')
+        if not os.path.exists(self.new_path):
+            os.makedirs(self.new_path)
+
+    def compute_prob_atlas(self, prob_values, target_shape=None):
+
+        def resize_data(im, mode = 'trilinear'):
+            if mode=='nearest':
+                im = F.interpolate(torch.from_numpy(im).unsqueeze(0).unsqueeze(0), size=target_size,
+                              mode=mode)
+            else:
+                im = F.interpolate(torch.from_numpy(im).unsqueeze(0).unsqueeze(0), size=target_size,
+                             mode=mode, align_corners=False)
+            return im
+
+        #(192, 192, 192)
+        f_y_true = self.opt.atlas
+        #
+        if target_shape is None:
+            target_size = [224, 256, 192]
+            i_y_true = read_atlas_file(f_y_true, save_again=True)
+            i_y_true,pad_zero,_ = remove_zero(i_y_true.get_fdata())
+
+            mask = (i_y_true>0)
+
+            mask =resize_data(mask.astype(np.float32), mode='nearest').squeeze(0)>0
+            y_true = resize_data(i_y_true).squeeze().detach().cpu().numpy()
+            y_true = normalize_image(y_true)
+            y_true = torch.from_numpy(y_true).unsqueeze(0)
+            y_true[~mask] = 0
+            #self.y_true = y_true
+
+            prob_values_new = []
+            for ii in range(prob_values.shape[-1]):
+                i_y_true = prob_values[...,ii].copy()
+                i_y_true, _ ,_ = remove_zero(i_y_true, min_max=pad_zero)
+                prob_tm = resize_data(i_y_true).squeeze()
+                prob_values_new.append(prob_tm)
+
+            probs = torch.stack(prob_values_new)
+            return y_true, probs, target_size
+        else:
+            i_y_true = read_atlas_file(f_y_true, save_again=True)
+
+            mask = (i_y_true.get_fdata() > 0)
+            mask = resample_to_size(
+                nib.Nifti1Image(mask, i_y_true.affine, i_y_true.header),
+                new_size=target_shape,
+                method='nearest').get_fdata()>0
+
+            y_true = resample_to_size(
+                nib.Nifti1Image(i_y_true.get_fdata(), i_y_true.affine, i_y_true.header),
+                new_size=target_shape,
+                method='spline').get_fdata()
+
+            mask,pad_zero ,_ = remove_zero(mask)
+
+            y_true, _ ,_ = remove_zero(y_true, min_max=pad_zero)
+
+            y_true = normalize_image(y_true)
+            y_true[~mask] = 0
+            y_true, _ = pad_to_multiple_of_32(y_true, target_size=target_shape)
+            prob_values_new = []
+            for ii in range(prob_values.shape[-1]):
+                bg = resample_to_size(
+                    nib.Nifti1Image(prob_values[...,ii], i_y_true.affine, i_y_true.header),
+                    new_size=target_shape,
+                    method='nearest').get_fdata()
+                bg, _ ,_ = remove_zero(bg, min_max=pad_zero)
+                if ii==0:
+                    val_const = 1
+                else:
+                    val_const = 0
+                bg, _ = pad_to_multiple_of_32(bg, target_size=target_shape, val_const=val_const)
+                prob_values_new.append(bg)
+            probs = np.stack(prob_values_new)
+            return y_true, probs, target_shape
+
+
+
+
+    def plot_image_seg(self, imA, imB, outf):
+        fig, ax = plt.subplots(2)
+        ax[0].axis('off')
+        ax[1].axis('off')
+        ax[0].imshow(imB[:, :, imB.shape[2] // 2])
+        ax[1].imshow(imA[:, :, imB.shape[2] // 2])
+        plt.savefig(outf)
+        plt.close()
+
+    def __getitem__(self, item):
+        """
+        randomly select one image form the pool
+        :param item:
+        :return:
+        """
+
+        use_registation = True
+
+        ind_image = np.random.randint(len(self.ILpath[item]['T1']))
+
+        pathA = self.ILpath[item]['T1'][ind_image]
+
+        ##'Check is file avialable'
+ 
+        baseNameA = os.path.basename(pathA)
+        dirNameA = os.path.dirname(pathA)
+
+
+        pathMask = self.ILpath[item]['Mask'][ind_image]
+
+
+        pathMask_noCSF = self.ILpath[item]['Mask_NoCSF'][ind_image]
+
+        pathfile_affine = self.ILpath[item]['PathTransform'][ind_image]
+        pathfile_t1_original = self.ILpath[item]['PathA_original'][ind_image]
+
+        pathB = self.ILpath[item]['T2'][ind_image]
+
+        mask_noCSF = read_atlas_file(pathMask_noCSF, save_again=True).get_fdata()>0
+
+        try:
+
+            imA = read_atlas_file(pathA, save_again=True)
+            imB = read_atlas_file(pathB, save_again=True)
+            mask = read_atlas_file(pathMask, save_again=True).get_fdata()>0
+            if mask.sum()<100:
+                item = np.random.randint(len(self.ILpath)) % len(self.ILpath)
+                return self.__getitem__(item)
+            header = imB.header
+            affine = imB.affine
+
+            info_back = []
+            spacing = imA.header['pixdim'][1:4]
+
+            min_max = [[0, 0], [0, 0], [0, 0]]
+            shape_original = imA.shape
+
+            zero_r = False
+            if np.random.rand() > 0.5 and self.opt.state!='test':
+                zero_r = True
+
+            selcted_size = np.random.choice(len(self.y_true))
+
+            avaial_shape = self.target_size[selcted_size]
+            im_shape = imA.shape
+            comp_shapes = all([i1 <= i2 for [i1, i2] in zip(*[im_shape, avaial_shape])])
+            if use_registation:
+                zero_r = True  # for registration
+                _mask, _ ,_ = remove_zero(mask)
+                im_shape = _mask.shape
+                comp_shapes = all([i1 <= i2 for [i1, i2] in zip(*[im_shape, avaial_shape])])
+
+            y_true, probs, target_shape = self.y_true[selcted_size], self.probs[selcted_size], self.target_size[selcted_size]
+            image_original = imA.get_fdata()
+            if zero_r:
+                mask,min_max, shape_original = remove_zero(mask)
+                mask_noCSF, _, _ = remove_zero(mask_noCSF, min_max=min_max)
+                imA, _ ,_ = remove_zero(imA.get_fdata(), min_max=min_max)
+                imB, _ ,_ = remove_zero(imB.get_fdata(), min_max=min_max)
+            else:
+                imA = imA.get_fdata()
+                imB = imB.get_fdata()
+            mask = mask == 1
+
+            mask_noCSF = mask_noCSF == 1
+
+
+            imA = normalize_image(imA, mask)
+
+            imB = normalize_image(imB, mask)
+
+            if np.random.rand() > 0.5 and self.opt.state!='test':
+                imA[~mask] = 0
+                imB[~mask] = 0
+
+
+            imA = torch.from_numpy(imA).to(torch.float).unsqueeze(0)
+
+            pad_width = np.array([0,0,0], dtype=np.int32)
+            min_max = np.array(min_max, dtype=np.int32)
+            shape_original = np.array(shape_original, dtype=np.int32)
+
+            imB = torch.from_numpy(imB).to(torch.float).unsqueeze(0)
+            maskT1 = torch.from_numpy(mask).to(torch.int).unsqueeze(0)
+            maskT1_noCSF = torch.from_numpy(mask_noCSF).to(torch.int).unsqueeze(0)
+            atlas_probs = probs.to(torch.float)
+            imout = y_true.to(torch.float)
+            image_original = torch.from_numpy(image_original).to(torch.float).unsqueeze(0)
+            resized_im = False
+            return {'T1': imA,'T1_orig':image_original, 'atlas_probs':atlas_probs,'pathA': pathA, 'atlas': imout,'maskT1': maskT1, 'info_back':info_back,
+                    'pixdim':spacing, 'affine':affine, 'pad_width': pad_width, 'min_max': min_max, 'shape_original': shape_original,'resized': resized_im,
+                    'maskNoCSF': maskT1_noCSF, 'pathAffine': pathfile_affine, 'pathAOrig':pathfile_t1_original}
+        except Exception as e:
+            print(pathA)
+            print(e)
+            #print('Exception occurred:')
+            traceback.print_exc()
+            #print(min_max)
+            #print(shape_original)
+            #print(e)
+            item = np.random.randint(len(self.ILpath)) % len(self.ILpath)
+            return self.__getitem__(item)  
+
+    def __len__(self):
+        if self.state.lower() == 'train' or self.state.lower()=='total':
+            return len(self.ILpath)
+        elif self.state.lower() == 'valid':
+            return len(self.ILpath)
+        else:
+            return len(self.ILpath)
+
+    def name(self):
+        return "Tb"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

melage/plugins/warpseg/warpseg_main/data_reader/DDSetSeg.py

@@ -0,0 +1,279 @@
+import os
+import sys
+import random
+import json
+import warnings
+warnings.filterwarnings("ignore", message="pkg_resources is deprecated.*")
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # Suppress TensorFlow warnings
+from os.path import basename, splitext
+import numpy as np
+import torch
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+from .baseData import baseData
+from .utils import remove_zero
+from .utils import normalize as normalize_image
+import sys
+#sys.modules['tensorflow'] = None
+try:
+    from monai.transforms import RandRotateD, RandHistogramShiftd, RandGaussianNoised, RandBiasFieldd, ScaleIntensityd, \
+    Compose, ToTensor, ToTensorD, RandZoomD, OneOf, EnsureChannelFirstD, EnsureTypeD
+except:
+    pass
+# Suppress specific warnings
+warnings.filterwarnings("ignore", message="pkg_resources is deprecated.*")
+
+# Set random seed
+random.seed(0)
+
+# Define constants
+LABEL_MAPPING = {
+    'BACKGROUND': 0, 'CORTICAL_GM': 1, 'LAT_VENT_L': 3,
+    'CEREBELLUM_CORTEX_L': 5, 'CSF': 15, 'LAT_VENT_R': 19,
+    'CEREBELLUM_CORTEX_R': 21,
+}
+
+
+class DDSetSeg(baseData):
+    def options(self, opt, type, novalid):
+        """
+        options of the data set
+        :param opt:
+        :return:
+        """
+        self.opt = opt
+        self.state = 'train'
+
+        self.target_size = [
+            [128, 128, 96], [128, 128, 128], [128, 160, 128],
+            [160, 160, 128], [160, 160, 160], [160, 192, 160],
+            [192, 192, 160], [192, 224, 192], [192, 256, 192], [224, 256, 192]
+        ]
+
+        images_IXI = createPathData_IXI()
+        if self.opt.state == 'test':
+            self.ILpath =images_IXI #images_OASIS#adni#images_IXI#image_full_head#images_IXI[10:]
+
+
+        self.train_transforms = Compose([
+            # Step A: Add a channel dim ONLY to 'image' and 'mask'.
+            # 'prob' is skipped because it's not in the `keys` list.
+            EnsureChannelFirstD(keys=["image", "mask"], channel_dim='no_channel'),
+            # Step B: Convert all tensors to a float type for calculations.
+            EnsureTypeD(keys=["image", "prob", "mask"], dtype=torch.float32),
+            OneOf(transforms=[
+                RandHistogramShiftd(keys=["image"], prob=0.5),
+            ]),
+            # Step C: Apply the same affine transform to all keys.
+            # This works now because all tensors are 4D (C,D,H,W) and have matching spatial dims.
+            RandAffineD(
+                keys=["image", "prob", "mask"],
+                prob=1.0,  # Using 1.0 for testing
+                rotate_range=(np.pi / 12, np.pi / 12, np.pi / 12),
+                scale_range=(0.1, 0.1, 0.1),
+                mode=("bilinear", "bilinear", "nearest"),
+                padding_mode="zeros"
+            )
+        ])
+
+        self.max_count = self.__len__() + 1
+        self.new_path = os.path.join(self.opt.chkptDir, 'save_images')
+        if not os.path.exists(self.new_path):
+            os.makedirs(self.new_path)
+
+    def plot_image_seg(self, imA, imB, outf):
+        fig, ax = plt.subplots(2)
+        ax[0].axis('off')
+        ax[1].axis('off')
+        ax[0].imshow(imB[:, :, imB.shape[2] // 2])
+        ax[1].imshow(imA[:, :, imB.shape[2] // 2])
+        plt.savefig(outf)
+        plt.close()
+
+    def _weight_roi(self, seg, num_classes):
+        total_pixels = np.zeros(num_classes)
+        class_present = np.zeros(num_classes)
+
+        for c in range(num_classes):
+            class_mask = (seg == c)
+            pixel_count = class_mask.sum()
+            total_pixels[c] = pixel_count
+            if pixel_count > 0:
+                class_present[c] = 1  # only count if present at all in this volume
+        frequencies = total_pixels / (class_present + 1e-6)
+        weights = 1.0 / np.log(1.02 + frequencies)  # Smoothed Weighting Formula
+        return weights
+
+    def _make_tissue_(self, prob):
+        # Core deep gray matter indices
+        dgm_indices = [6, 7, 8, 9, 22, 23, 24, 25]
+        # Optional (extended) subcortical GM indices — sometimes included in DGM analyses
+        extended_dgm_indices = [13, 14, 16, 17, 26, 27, 28, 29]
+        dgm_indices += extended_dgm_indices
+        prob_tissues = torch.stack(
+            [prob[0], prob[[1, 5, 21]].sum(0), prob[[2, 18, 4, 12, 20]].sum(0), prob[[3, 19]].sum(0),
+             prob[[10, 11, 15]].sum(0),
+             prob[dgm_indices].sum(0)])
+        prob_tissues_d = prob_tissues.sum(dim=0, keepdim=True) + 1e-6  # [1, D, H, W]
+        prob_tissues = (prob_tissues) / prob_tissues_d
+        return prob_tissues
+
+    def __getitem__(self, item):
+        """
+        randomly select one image form the pool
+        :param item:
+        :return:
+        """
+        ind_image = 0
+
+        pathA = self.ILpath[item]['T1'][ind_image]
+        pathA_seg = self.ILpath[item]['T1_seg'][ind_image]
+        pathA_brain = self.ILpath[item]['T1_brain'][ind_image]
+        path_prob_A = self.ILpath[item]['probT1'][ind_image]
+        pathMaskA = self.ILpath[item]['Mask'][ind_image]
+
+
+        zero_r = False
+        if np.random.rand() < 0.5:
+            zero_r = True
+
+        if not os.path.isfile(path_prob_A) and self.opt.state != 'test':
+            next_item = (item + 1) % len(self.ILpath)
+            return self.__getitem__(next_item)
+
+        try:
+            imA = vxm.py.utils.read_atlas_file(pathA, save_again=True)
+            seg = vxm.py.utils.read_atlas_file(pathA_seg, save_again=True).get_fdata()
+            imA_brain = vxm.py.utils.read_atlas_file(pathA_brain, save_again=True).get_fdata()
+            mask = vxm.py.utils.read_atlas_file(pathMaskA, save_again=True)
+
+            mask = mask.get_fdata() > 0
+            # normalize intensities
+            header = imA.header
+            affine = imA.affine
+            spacing = imA.header['pixdim'][1:4]
+            min_max = [[0, 0], [0, 0], [0, 0]]
+            shape_original = imA.shape
+            imA = imA.get_fdata().copy()
+            imA = normalize_image(imA, mask)
+            imA_brain = normalize_image(imA_brain, mask)
+            imA = (np.random.uniform(0.5, 2) * imA_brain * (~mask) + imA)
+
+            prob = vxm.py.utils.read_atlas_file(path_prob_A, save_again=True)
+            prob = prob.get_fdata()
+            prob[0, seg == 0] = 100
+
+            if len(prob.shape) <= 3:
+                prob = None
+                seg = None
+            if prob is not None:
+                num_classes = prob.shape[0]
+                weights = self._weight_roi(seg, num_classes)
+
+                if self.opt.state == 'test':
+                    zero_r = False
+                if zero_r:
+                    if np.random.rand() < 0.5 or self.opt.state == 'test':
+                        mask, min_max, shape_original = remove_zero(mask)
+                      
+                        imA, _, _ = remove_zero(imA, min_max=min_max)
+                        prob = prob[:, min_max[0][0]:min_max[0][1] + 1, min_max[1][0]:min_max[1][1] + 1,
+                               min_max[2][0]:min_max[2][1] + 1]
+                    else:
+                        imA = imA * mask
+            else:
+                weights = None
+
+            avaial_shape = imA.shape
+
+            ind_selcted_size = np.random.choice(len(self.target_size))
+            selcted_size = self.target_size[ind_selcted_size]
+            
+            # The original code had a commented-out line `if self.opt.state=='test':`
+            # followed by `selcted_size = self.target_size[-1]`.
+            # This implies that for 'test' state, it was intended to always use the last target size.
+            # I'm keeping the behavior as it was in the original code, which was to always use the last size,
+            # regardless of the `if` condition being commented out.
+            selcted_size = self.target_size[-1]
+
+            if prob is not None:
+                prob = F.interpolate(torch.from_numpy(prob).unsqueeze(0), size=selcted_size, mode='trilinear',
+                                     align_corners=False).squeeze()
+            imA = F.interpolate(torch.from_numpy(imA).unsqueeze(0).unsqueeze(0), size=selcted_size, mode='trilinear',
+                                align_corners=False).squeeze()
+            mask = F.interpolate(torch.from_numpy(mask).to(torch.float).unsqueeze(0).unsqueeze(0), size=selcted_size,
+                                 mode='nearest').squeeze()
+
+            sample = {"image": imA, "prob": prob, "mask": mask}
+            if self.opt.state != 'test' and np.random.rand() < 0.5:
+                sample = self.train_transforms(sample)
+                imA = sample['image'].to(torch.float)
+                prob = sample['prob'].to(torch.float)
+                prob = prob / 100
+                prob_tissues = self._make_tissue_(prob)
+                mask = sample['mask'].to(torch.float)
+                weight_roi = torch.from_numpy(weights).to(torch.float)[:, None, None, None]
+            else:
+                imA = imA.unsqueeze(0)
+                if prob is not None:
+                    prob = prob.to(torch.float)
+                    prob = prob / 100
+                    prob_tissues = self._make_tissue_(prob)
+                    weight_roi = torch.from_numpy(weights).to(torch.float)[:, None, None, None]
+                else:
+                    prob_tissues = None
+                mask = mask.to(torch.float).unsqueeze(0)
+
+            if prob_tissues is not None:
+                num_classes = prob_tissues.shape[0]
+                seg_t = prob_tissues.argmax(0)
+                weights_tissue = self._weight_roi(seg_t, num_classes)
+                weights_tissue = torch.from_numpy(weights_tissue).to(torch.float)[:, None, None, None]
+            else:
+                weights_tissue = None
+            min_max = np.array(min_max, dtype=np.int32)
+            shape_original = np.array(shape_original, dtype=np.int32)
+            shape_original = torch.from_numpy(np.array(shape_original)).unsqueeze(0)
+            if prob is not None:
+                return {'T1': imA.to(torch.float), 'T1_prob': prob.to(torch.float),
+                        'T1_prob_edt': weight_roi.to(torch.float), 'pathA': pathA, 'maskT1': mask.to(torch.float),
+                        'pixdim': spacing, 'affine': affine, 'min_max': min_max, 'shape_original': shape_original,
+                        'interShape': avaial_shape, 'prob_tissue': prob_tissues.to(torch.float),
+                        'weight_tissue': weights_tissue.to(torch.float), }
+            else:
+                return {'T1': imA.to(torch.float), 'pathA': pathA, 'maskT1': mask.to(torch.float),
+                        'pixdim': spacing, 'affine': affine, 'min_max': min_max, 'shape_original': shape_original,
+                        'interShape': avaial_shape, }
+
+        except Exception as e:
+            print(e, pathA)
+            item = np.random.randint(len(self.ILpath)) % len(self.ILpath)
+            return self.__getitem__(item)
+
+    def __len__(self):
+        return len(self.ILpath)
+
+    def name(self):
+        return "Tb"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

melage/plugins/warpseg/warpseg_main/data_reader/__init__.py

@@ -0,0 +1,60 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from .DDSet import DDSet
+from .DDSetSeg import DDSetSeg
+import argparse
+from torch.utils.data.distributed import DistributedSampler
+# function loaders
+funcLoaders = {'D':DDSet,'segDN':DDSetSeg}
+import os
+from argparse import Namespace
+import os
+import torch
+from argparse import Namespace
+
+def get_dataloader(opt, split='train', pin_memory=True, prefetch_factor=2,
+                   name='D', num_workers=None, collate_fn=None, params=None):
+    # Use a shallow copy, as we are only modifying top-level attributes.
+    # If opt contained nested dicts/lists that you intended to modify,
+    # you would use opt_local = copy.deepcopy(opt)
+    opt_local = Namespace(**vars(opt))
+
+    # 1. Use a descriptive name like 'split' instead of 'type'
+    opt_local.state = split.lower()
+    is_train = (opt_local.state == 'train')
+
+    # 2. Set batch size for non-training splits
+    if not is_train:
+        opt_local.batchSize = 1
+
+    dataset = funcLoaders[name]()
+    dataset.options(opt_local, params, None)
+
+    # 3. Use a more sensible default for num_workers
+    if num_workers is None:
+        # Default to 4 workers, or all CPUs if less than 4 are available
+        num_workers = min(os.cpu_count(), 4)
+
+    print(f"Using {num_workers} workers for the '{split}' split.")
+
+    dataloader = torch.utils.data.DataLoader(
+        dataset,
+        batch_size=opt_local.batchSize,
+        # 4. Correctly set shuffle only for training
+        shuffle=is_train,
+        num_workers=num_workers,
+        prefetch_factor=prefetch_factor,
+        # 5. It's common to drop the last batch for training
+        drop_last=is_train,
+        pin_memory=pin_memory,
+        # 6. Fix typo
+        collate_fn=collate_fn
+    )
+
+    return dataloader
+
+
+
+if __name__=='__main__':
+    None

melage/plugins/warpseg/warpseg_main/data_reader/baseData.py

@@ -0,0 +1,18 @@
+import torch
+import torch.utils.data as data
+import abc
+
+class baseData(data.Dataset):
+    def __init__(self):
+        super(baseData, self).__init__()
+    @abc.abstractmethod
+    def options(self, opt):
+        raise NotImplementedError("Subclass should be implemented.")
+
+    @abc.abstractmethod
+    def __len__(self):
+        raise NotImplementedError("Subclass should be implemented.")
+
+    @abc.abstractmethod
+    def name(self):
+        raise NotImplementedError("Subclass should be implemented.")