python-wml 3.0.0__py3-none-any.whl

wml/iotoolkit/labelmemckeypoints_dataset.py

@@ -0,0 +1,169 @@
+#coding=utf-8
+import numpy as np
+import matplotlib.image as mpimg
+import xml.etree.ElementTree as ET
+from xml.dom.minidom import Document
+import random
+import os
+import math
+import wml.wml_utils
+import logging
+import shutil
+from functools import partial
+import wml.wml_utils as wmlu
+import wml.img_utils as wmli
+import copy
+from easydict import EasyDict
+from wml.object_detection2.standard_names import *
+import pickle
+from .common import *
+import wml.object_detection2.bboxes as odb
+from .pascal_voc_toolkit_fwd import *
+from wml.wstructures import WMCKeypoints
+from .labelme_toolkit_fwd import get_files,read_labelme_mckp_data
+
+
+class LabelmeMCKeypointsDataset(object):
+    def __init__(self, label_text2id=None, shuffle=False,
+                 filter_empty_files=False,
+                 resample_parameters=None,
+                 keep_no_json_img=False,
+                 ignore_case=True):
+        '''
+
+        :param label_text2id: trans a single label text to id:  int func(str)
+        :param shuffle:
+        :param image_sub_dir:
+        :param xml_sub_dir:
+        '''
+        self.files = None
+        self.shuffle = shuffle
+        self.filter_empty_files = filter_empty_files
+        self.keep_no_json_img = keep_no_json_img
+        if isinstance(label_text2id,dict):
+            if ignore_case:
+                new_dict = dict([(k.lower(),v) for k,v in label_text2id.items()])
+                self.label_text2id = partial(ignore_case_dict_label_text2id,dict_data=new_dict)
+            else:
+                self.label_text2id = partial(dict_label_text2id,dict_data=label_text2id)
+        else:
+            self.label_text2id = label_text2id
+
+        if resample_parameters is not None:
+            self.resample_parameters = {}
+            for k,v in resample_parameters.items():
+                if isinstance(k,(str,bytes)):
+                    k = self.label_text2id(k)
+                self.resample_parameters[k] = v
+            print("resample parameters")
+            wmlu.show_dict(self.resample_parameters)
+        else:
+            self.resample_parameters = None
+
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self,idx):
+        try:
+            fs = self.files[idx]
+        except Exception as e:
+            print(f"ERROR: {e} {self.files[idx]}")
+            print(self.files)
+        #print(xml_file)
+        try:
+            data = self.read_one_file(fs)
+            labels_names = data[GT_LABELS]
+            img_info = data[IMG_INFO]
+            if self.label_text2id is not None:
+                labels = [self.label_text2id(x) for x in labels_names]
+                keypoints = data[GT_KEYPOINTS]
+                keep = [x is not None for x in labels]
+                labels = list(filter(lambda x:x is not None,labels))
+                if len(labels)==0 or not isinstance(labels[0],(str,bytes)):
+                    labels = np.array(labels,dtype=np.int32)
+                keypoints = [keypoints[i] for i in np.where(keep)[0]]
+                data[GT_LABELS] = labels
+                data[GT_KEYPOINTS] = WMCKeypoints(keypoints,width=img_info[WIDTH],height=img_info[HEIGHT])
+            else:
+                keypoints = data[GT_KEYPOINTS]
+                data[GT_KEYPOINTS] = WMCKeypoints(keypoints,width=img_info[WIDTH],height=img_info[HEIGHT])
+
+        except Exception as e:
+            print(f"Read {fs} {e} faild.")
+            return None
+        return EasyDict(data)
+
+    def read_data(self,dir_path,img_suffix=wmli.BASE_IMG_SUFFIX):
+        if isinstance(dir_path,str):
+            print(f"Read {dir_path}")
+            if not os.path.exists(dir_path):
+                print(f"Data path {dir_path} not exists.")
+                return False
+            self.files = get_files(dir_path,img_suffix=img_suffix,keep_no_json_img=self.keep_no_json_img)
+        elif isinstance(dir_path,(list,tuple)) and isinstance(dir_path[0],(str,bytes)) and os.path.isdir(dir_path[0]):
+            self.files = []
+            for dp in dir_path:
+                self.files.extend(get_files(dp,
+                                            img_suffix=img_suffix,
+                                            keep_no_json_img=self.keep_no_json_img))
+        else:
+            self.files = dir_path
+        if self.filter_empty_files and self.label_text2id:
+            self.files = self.apply_filter_empty_files(self.files)
+        if self.resample_parameters is not None and self.label_text2id:
+            self.files = self.resample(self.files)
+        
+        if len(self.files) == 0:
+            return False
+
+        if self.shuffle:
+            random.shuffle(self.files)
+
+        return True
+
+    def read_one_file(self,data):
+        img_file,json_file = data 
+        image_info,labels,points = read_labelme_mckp_data(json_file,keep_no_json_img=self.keep_no_json_img)
+        image_info[FILEPATH] = img_file
+        datas = {}
+        datas[IMG_INFO] = image_info
+        datas[GT_LABELS] = labels
+        datas[GT_KEYPOINTS] = points
+        with open(img_file,"rb") as f:
+            img_data = f.read()
+        datas[IMAGE] = img_data
+        return datas
+
+    def apply_filter_empty_files(self,files):
+        new_files = []
+        for fs in files:
+            data = self.read_one_file(fs)
+            labels_name = data[GT_LABELS]
+            labels = [self.label_text2id(x) for x in labels_name]
+            is_none = [x is None for x in labels]
+            if not all(is_none):
+                new_files.append(fs)
+            else:
+                print(f"File {fs} is empty, labels names {labels_name}, labels {labels}")
+
+        return new_files
+    
+    def resample(self,files):
+        all_labels = []
+        for fs in files:
+            data = self.read_one_file(fs)
+            labels_name = data[GT_LABELS]
+            labels = [self.label_text2id(x) for x in labels_name]
+            all_labels.append(labels)
+
+        return resample(files,all_labels,self.resample_parameters)
+
+
+    def get_items(self):
+        '''
+        :return: 
+        full_path,img_size,category_ids,category_names,boxes,binary_masks,area,is_crowd,num_annotations_skipped
+        '''
+        for i in range(len(self.files)):
+            yield self.__getitem__(i)

wml/iotoolkit/lspet.py

@@ -0,0 +1,48 @@
+from wml.iotoolkit.mat_data import MatData
+import wml.object_detection2.keypoints as odk
+import numpy as np
+import wml.object_detection2.bboxes as odb
+'''
+Right ankle
+				Right knee
+				Right hip
+				Left hip
+				Left knee
+				Left ankle
+				Right wrist 6
+				Right elbow 7
+				Right shoulder 8
+ 				Left shoulder 9
+				Left elbow 10
+				Left wrist 11
+				Neck
+				Head top
+'''
+def read_lspet_data(path):
+    data = MatData(path).data['joints']
+    kps = np.transpose(data, [2, 0, 1])
+    bboxes = odk.npbatchget_bboxes(kps)
+    return kps,bboxes
+
+class Trans2COCO:
+    def __init__(self) -> None:
+        self.dst_idxs = [5,6,7,8,9,10,11,12,13,14,15,16]
+        self.src_idxs = [9,8,10,7,11,6,3,2,4,1,5,0]
+        self.coco_idxs = [0,1,2,3,4]
+
+    def __call__(self,mpii_kps,coco_kps):
+        if len(mpii_kps.shape)==2:
+            return self.trans_one(mpii_kps,coco_kps)
+        res = []
+        for mp,coco in zip(mpii_kps,coco_kps):
+            res.append(self.trans_one(mp,coco))
+        return np.array(res)
+
+    def trans_one(self,mpii_kps,coco_kps):
+        '''
+        img: [RGB]
+        '''
+        res = np.zeros([17,3],dtype=np.float32)
+        res[self.dst_idxs] = mpii_kps[self.src_idxs]
+        res[self.coco_idxs] = coco_kps[self.coco_idxs]
+        return res

wml/iotoolkit/mapillary_vistas_toolkit.py

@@ -0,0 +1,269 @@
+import json
+import wml.wml_utils as wmlu
+import numpy as np
+import os
+import cv2 as cv
+import sys
+import random
+from wml.iotoolkit.labelme_toolkit import get_labels_and_bboxes
+import re
+from .common import *
+
+
+def get_files(dir_path):
+    img_dir = os.path.join(dir_path, 'images')
+    label_dir = os.path.join(dir_path, "v2.0","polygons")
+    res = []
+    json_files = wmlu.recurse_get_filepath_in_dir(label_dir,suffix=".json")
+    for jf in json_files:
+        base_name = wmlu.base_name(jf)
+        igf = os.path.join(img_dir, base_name + ".jpg")
+        if os.path.exists(igf):
+            res.append((igf, jf))
+        else:
+            print(f"ERROR: Find {igf} faild, json file is {jf}")
+
+    return res
+
+class LabelsFn:
+    def __init__(self,data):
+        self.data = []
+        for x in data:
+            if isinstance(x,(tuple,list)):
+                self.data.append((re.compile(x[0]),x[1]))
+            else:
+                self.data.append(x)
+
+    def __call__(self,x):
+        for d in self.data:
+            if isinstance(d,(list,tuple)):
+                if d[0].fullmatch(x):
+                    return d[1]
+            elif isinstance(d,(str,bytes)) and d==x:
+                return x
+        return False
+
+class MapillaryVistasData(object):
+    def __init__(self, label_text2id=None, shuffle=False, ignored_labels=[],label_map={},
+                 allowed_labels_fn=None,
+                 use_semantic=True,
+                 absolute_coord=True):
+        self.files = None
+        self.label_text2id = label_text2id
+        self.shuffle = shuffle
+        self.ignored_labels = ignored_labels
+        self.label_map = label_map
+        self.use_semantic = use_semantic
+        self.absolute_coord = absolute_coord
+        if allowed_labels_fn is not None and isinstance(allowed_labels_fn,list):
+            self.allowed_labels_fn = LabelsFn(allowed_labels_fn)
+        else:
+            self.allowed_labels_fn = allowed_labels_fn
+
+    def read_data(self, dir_path,*args,**kwargs):
+        self.files = get_files(dir_path)
+        if self.shuffle:
+            random.shuffle(self.files)
+
+    def __len__(self):
+        return len(self.files)
+
+    def get_items(self,beg=0,end=None,filter=None):
+        '''
+        :return:
+        bboxes: [ymin,xmin,ymax,xmax]
+        binary_masks [N,H,W], value is 0 or 1,
+        full_path,img_size,category_ids,category_names,boxes,binary_masks,area,is_crowd,num_annotations_skipped
+        '''
+        if end is None:
+            end = len(self.files)
+        if beg is None:
+            beg = 0
+        for i, (img_file, json_file) in enumerate(self.files[beg:end]):
+            if filter is not None and not filter(img_file,json_file):
+                continue
+            print(img_file,json_file)
+            sys.stdout.write('\r>> read data %d/%d' % (i + 1, len(self.files)))
+            sys.stdout.flush()
+            image, annotations_list = self.read_json(json_file,use_semantic=self.use_semantic)
+            labels_names, bboxes = get_labels_and_bboxes(image, annotations_list,is_relative_coordinate=not self.absolute_coord)
+            try:
+                if self.use_semantic:
+                    masks = [ann["segmentation"] for ann in annotations_list]
+                    if len(masks) > 0:
+                        try:
+                            masks = np.stack(masks, axis=0)
+                        except:
+                            print("ERROR: stack masks faild.")
+                else:
+                    masks = None
+            except:
+                masks = None
+
+            if self.label_text2id is not None:
+                labels = [self.label_text2id(x) for x in labels_names]
+            else:
+                labels = None
+
+            yield DetData(img_file, [image['height'], image['width']], labels, labels_names, bboxes, masks, None, None, None)
+
+    def get_boxes_items(self):
+        '''
+        :return:
+        full_path,img_size,category_ids,boxes,is_crowd
+        '''
+        for i, (img_file, json_file) in enumerate(self.files):
+            sys.stdout.write('\r>> read data %d/%d' % (i + 1, len(self.files)))
+            sys.stdout.flush()
+            image, annotations_list = self.read_json(json_file,use_semantic=False)
+            labels_names, bboxes = get_labels_and_bboxes(image, annotations_list,is_relative_coordinate=not self.absolute_coord)
+            if self.label_text2id is not None:
+                labels = [self.label_text2id(x) for x in labels_names]
+            else:
+                labels = None
+            #file, img_size,category_ids, labels_text, bboxes, binary_mask, area, is_crowd, _
+            yield DetBboxesData(img_file, [image['height'], image['width']], labels, bboxes, None)
+
+    def read_json(self,file_path,use_semantic=True):
+        annotations_list = []
+        image = {}
+        with open(file_path, "r", encoding="gb18030") as f:
+            print(file_path)
+            data_str = f.read()
+            try:
+                json_data = json.loads(data_str)
+                img_width = int(json_data["width"])
+                img_height = int(json_data["height"])
+                image["height"] = int(img_height)
+                image["width"] = int(img_width)
+                image["file_name"] = wmlu.base_name(file_path)
+                for shape in json_data["objects"]:
+                    #label = shape["label"].split("--")[-1]
+                    label = shape["label"]
+                    if self.ignored_labels is not None and label in self.ignored_labels:
+                        continue
+                    if self.label_map is not None and label in self.label_map:
+                        label = self.label_map[label]
+                    if self.allowed_labels_fn is not None:
+                        nl = self.allowed_labels_fn(label)
+                        if not nl:
+                            continue
+                        if isinstance(nl,(str,bytes)):
+                            label = nl
+                    all_points = np.array([shape["polygon"]]).astype(np.int32)
+                    if len(all_points) < 1:
+                        continue
+                    points = np.transpose(all_points[0])
+                    x, y = np.vsplit(points, 2)
+                    x = np.reshape(x, [-1])
+                    y = np.reshape(y, [-1])
+                    x = np.minimum(np.maximum(0, x), img_width - 1)
+                    y = np.minimum(np.maximum(0, y), img_height - 1)
+                    xmin = np.min(x)
+                    xmax = np.max(x)
+                    ymin = np.min(y)
+                    ymax = np.max(y)
+                    if use_semantic:
+                        mask = np.zeros(shape=[img_height, img_width], dtype=np.uint8)
+                        segmentation = cv.drawContours(mask, all_points, -1, color=(1), thickness=cv.FILLED)
+                        annotations_list.append({"bbox": (xmin, ymin, xmax - xmin + 1, ymax - ymin + 1),
+                                                 "segmentation": segmentation,
+                                                 "category_id": label,
+                                                 "points_x": x,
+                                                 "points_y": y})
+                    else:
+                        annotations_list.append({"bbox": (xmin, ymin, xmax - xmin + 1, ymax - ymin + 1),
+                                             "category_id": label,
+                                             "points_x": x,
+                                             "points_y": y})
+            except:
+                print(f"Read file {os.path.basename(file_path)} faild.")
+                pass
+        if use_semantic:
+            '''
+            Each pixel only belong to one classes, and the latter annotation will overwrite the previous
+            '''
+            if len(annotations_list)>2:
+                mask = 1-annotations_list[-1]['segmentation']
+                for i in reversed(range(len(annotations_list)-1)):
+                    annotations_list[i]['segmentation'] = np.logical_and(annotations_list[i]['segmentation'], mask)
+                    mask = np.logical_and(mask,1-annotations_list[i]['segmentation'])
+        return image, annotations_list
+
+
+if __name__ == "__main__":
+    id = 0
+    # data_statistics("/home/vghost/ai/mldata/qualitycontrol/rdatasv3")
+    import wml.img_utils as wmli
+    import object_detection_tools.visualization as odv
+    import matplotlib.pyplot as plt
+
+    NAME2ID = {}
+    ID2NAME = {}
+
+
+    def name_to_id(x):
+        global id
+        if x in NAME2ID:
+            return NAME2ID[x]
+        else:
+            NAME2ID[x] = id
+            ID2NAME[id] = x
+            id += 1
+            return NAME2ID[x]
+
+
+    ignored_labels = [
+        'manhole', 'dashed', 'other-marking', 'static', 'front', 'back',
+        'solid', 'catch-basin','utility-pole', 'pole', 'street-light','direction-back', 'direction-front'
+         'ambiguous', 'other','text','diagonal','left','right','water-valve','general-single','temporary-front',
+        'wheeled-slow','parking-meter','split-left-or-straight','split-right-or-straight','zigzag',
+        'give-way-row','ground-animal','phone-booth','give-way-single','garage','temporary-back','caravan','other-barrier',
+        'chevron','pothole','sand'
+    ]
+    label_map = {
+        'individual':'person',
+        'cyclists':'person',
+        'other-rider':'person'
+    }
+    data = MapillaryVistasData(label_text2id=name_to_id, shuffle=False, ignored_labels=ignored_labels,label_map=label_map)
+    # data.read_data("/data/mldata/qualitycontrol/rdatasv5_splited/rdatasv5")
+    # data.read_data("/home/vghost/ai/mldata2/qualitycontrol/rdatav10_preproc")
+    # data.read_data("/home/vghost/ai/mldata2/qualitycontrol/rdatasv10_neg_preproc")
+    data.read_data(wmlu.home_dir("ai/mldata/mapillary_vistas/mapillary-vistas-dataset_public_v2.0"))
+
+
+    def filter(x):
+        return x in ['general-single', 'parking', 'temporary', 'general-horizontal']
+        # return x in ['terrain']
+        # return x in ['car']
+
+
+    # data.read_data("/home/vghost/ai/mldata2/qualitycontrol/x")
+    for x in data.get_items():
+        full_path, img_info, category_ids, category_names, boxes, binary_mask, area, is_crowd, num_annotations_skipped = x
+        img = wmli.imread(full_path)
+
+
+        def text_fn(classes, scores):
+            return f"{ID2NAME[classes]}"
+
+
+        if False:
+            is_keep = [filter(x) for x in category_names]
+            category_ids = np.array(category_ids)[is_keep]
+            boxes = np.array(boxes)[is_keep]
+            binary_mask = np.array(binary_mask)[is_keep]
+        if len(category_ids) == 0:
+            continue
+
+        wmlu.show_dict(NAME2ID)
+        odv.draw_bboxes_and_maskv2(
+            img=img, classes=category_ids, scores=None, bboxes=boxes, masks=binary_mask, color_fn=None,
+            text_fn=text_fn, thickness=4,
+            show_text=True,
+            fontScale=0.8)
+        plt.figure()
+        plt.imshow(img)
+        plt.show()
+

wml/iotoolkit/mat_data.py

@@ -0,0 +1,90 @@
+import scipy.io as scio
+import numpy as np
+
+class MatData:
+    def __init__(self,mat_path=None,data=None):
+        if mat_path is not None:
+            assert data is None,"Error arguments"
+            data = scio.loadmat(mat_path)
+        self.data = data
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self,item):
+        return self.get_item(item)
+
+    def __getattr__(self, item):
+        return self.get_item(item)
+
+    def get_item(self,item): 
+        if item == 'shape' and 'shape' in self.data.__dict__:
+            return self.data.shape
+
+        if item in self.__dict__:
+            return self.__dict__[item]
+        else:
+            data = self.data[item]
+            shape = data.shape
+            if len(shape)==2:
+                if shape[0] == 1:
+                    if shape[1] == 1:
+                        data=data[0,0]
+                        if data.shape==() and self.isscalar(data):
+                            return data
+                        return MatData(data=data)
+                    elif shape[1]>1:
+                        return MatData(data=data[0])
+                    else:
+                        return MatData(data=data)
+                elif shape[0] == 0 or shape[1]==0:
+                    return None
+                else:
+                    return MatData(data=data)
+            elif len(shape)==1:
+                if shape[0] == 1:
+                    data=data[0]
+                    if data.shape==() and self.isscalar(data):
+                        return data
+                    else:
+                        return MatData(data=data)
+                elif shape[0] == 0:
+                    return None
+                else:
+                    return MatData(data=data)
+            else:
+                return MatData(data=data)
+    def get_array_item(self,item): 
+        if item == 'shape' and 'shape' in self.data.__dict__:
+            return self.data.shape
+
+        if item in self.__dict__:
+            return self.__dict__[item]
+        else:
+            data = self.data[item]
+            shape = data.shape
+            if len(shape)==2:
+                if shape[0] == 1:
+                    return MatData(data=data[0])
+                elif shape[0] == 0 or shape[1]==0:
+                    return None
+                else:
+                    return MatData(data=data)
+            elif len(shape)==1:
+                if shape[0] == 0:
+                    return None
+                else:
+                    return MatData(data=data)
+            else:
+                return MatData(data=data)
+
+    @staticmethod
+    def isscalar(data):
+        type_str = type(data)
+        return type_str in [np.uint8,np.int8,np.uint16,np.int16,np.int32,np.uint32,np.int64,np.uint64,np.float32,np.float64,np.str_,np.str]
+
+    def item(self):
+        return self.data
+
+    def data_keys(self):
+        return self.data.dtype.names

wml/iotoolkit/mckeypoints_statistics.py

@@ -0,0 +1,28 @@
+import wml.wml_utils as wmlu
+from wml.object_detection2.standard_names import *
+import numpy as np
+
+def statistics_mckeypoints(dataset):
+    counter = wmlu.Counter()
+    samples_nr = 0
+    points_per_sample = []
+    max_classes_num_in_one_img = 0
+    for data in dataset:
+        points = data[GT_KEYPOINTS]
+        labels = data[GT_LABELS]
+        cur_nr = 0
+        for l,p in zip(labels,points):
+            counter.add(l,p.numel())
+            cur_nr += p.numel()
+        max_classes_num_in_one_img = max(max_classes_num_in_one_img,len(set(labels)))
+        samples_nr += 1
+        points_per_sample.append(cur_nr)
+    
+    points_per_sample = np.array(points_per_sample)
+    data = list(counter.items())
+    data = sorted(data,key=lambda x:x[1],reverse=True)
+    print(f"Total samples nr {len(dataset)}")
+    print(f"Mean samples per sample: {np.mean(points_per_sample)}, max: {np.max(points_per_sample)}, min: {np.min(points_per_sample)}")
+    print(f"Max num classes per sample: {max_classes_num_in_one_img}")
+    print(f"Points per classes:")
+    wmlu.show_list(data)

wml/iotoolkit/mot_datasets.py

@@ -0,0 +1,62 @@
+import wml.wml_utils as wmlu
+import os
+import numpy as np
+
+class MOTDatasets(object):
+    def __init__(self,dirs):
+        self.dirs = dirs
+        self.tid_curr = 0
+        self.dir_curr = 0
+
+    def get_data_items(self):
+        for seq_root in self.dirs:
+            seqs = wmlu.get_subdir_in_dir(seq_root)
+            for seq in seqs:
+                seq_info = open(os.path.join(seq_root, seq, 'seqinfo.ini')).read()
+                seq_width = int(seq_info[seq_info.find('imWidth=') + 8:seq_info.find('\nimHeight')])
+                seq_height = int(seq_info[seq_info.find('imHeight=') + 9:seq_info.find('\nimExt')])
+
+                gt_txt = os.path.join(seq_root, seq, 'gt', 'gt.txt')
+                if not os.path.exists(gt_txt):
+                    print(f"{gt_txt} not exists!")
+                    continue
+                gt = np.loadtxt(gt_txt, dtype=np.float64, delimiter=',')
+                idx = np.lexsort(gt.T[:2, :])
+                gt = gt[idx, :]
+
+                fid_datas = {}
+                for v in gt:
+                    fid, tid, x, y, w, h, mark, label, _ = v[:9]
+                    if mark == 0:
+                        continue
+                    if 'MOT15' not in seq_root and label !=1:
+                        continue
+                    if fid in fid_datas:
+                        fid_datas[fid].append(v[:9])
+                    else:
+                        fid_datas[fid] = [v[:9]]
+                tid_to_cls = {}
+                for fid,datas in fid_datas.items():
+                    tmp_data = []
+                    for _, tid, x, y, w, h, mark, label, _ in datas:
+                        fid = int(fid)
+                        tid = int(tid)
+                        if not tid in tid_to_cls:
+                            self.tid_curr += 1
+                            tid_to_cls[tid] = self.tid_curr
+                            cls = self.tid_curr
+                        else:
+                            cls = tid_to_cls[tid]
+                        xmin = x/seq_width
+                        ymin = y/seq_height
+                        xmax = (x+w)/seq_width
+                        ymax = (y+h)/seq_height
+                        tmp_data.append([cls,[ymin,xmin,ymax,xmax]])
+
+                    if len(tmp_data)>0:
+                        img_name = '{:06d}.jpg'.format(fid)
+                        img_path = os.path.join(seq_root,seq,"img1",img_name)
+                        img_data = {'img_width':seq_width,'img_height':seq_height,'img_path':img_path}
+                        yield img_data,tmp_data
+
+        print(f"Last tid value {self.tid_curr}")