python-wml 3.0.0__py3-none-any.whl

wml/iotoolkit/penn_action.py

@@ -0,0 +1,57 @@
+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
+import glob
+import os.path as osp
+'''
+1.  head       
+2.  left_shoulder  3.  right_shoulder
+4.  left_elbow     5.  right_elbow
+6.  left_wrist     7.  right_wrist     
+8.  left_hip       9.  right_hip 
+10. left_knee      11. right_knee 
+12. left_ankle     13. right_ankle
+'''
+def __read_one_file(file_path):
+    data = MatData(file_path).data
+    x = data['x'].astype(np.float32)
+    y = data['y'].astype(np.float32)
+    visibility = data['visibility'].astype(np.float32)
+    kps = np.stack([x,y,visibility],axis=-1)
+    bbox = data['bbox'].astype(np.float32)
+
+    return kps,bbox
+
+def read_penn_action_data(labels_path):
+    all_files = glob.glob(osp.join(labels_path,"*.mat"))
+
+    res = []
+    for file in all_files:
+        kps,bbox = __read_one_file(file)
+        res.append([file,kps,bbox])
+
+    return res
+
+class Trans2COCO:
+    def __init__(self) -> None:
+        self.dst_idxs = [5,6,7,8,9,10,11,12,13,14,15,16]
+        self.src_idxs = np.array([2,3,4,5,6,7,8,9,10,11,12,13],dtype=np.int32)-1
+        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/rawframe_dataset.py

@@ -0,0 +1,129 @@
+import os.path as osp
+import wml.wml_utils as wmlu
+import copy
+import random
+from typing import Type
+from itertools import chain
+from collections import namedtuple
+
+VideoInfo = namedtuple('VideoInfo',["dir_path","frames","label"])
+
+class RawFrameDataset:
+    get_item_in_namedtuple = False
+    def __init__(self,file_path=None) -> None:
+        self.data = []
+        self.dirname = None
+        if file_path is not None:
+            self.read(file_path)
+
+    @classmethod
+    def create(cls,other, data=None):
+        ds = cls()
+        if data is not None:
+            ds.data = data
+        else:
+            ds.data = copy.deepcopy(other.data)
+
+        ds.dirname = other.dirname
+
+        return ds
+
+    def read(self,file_path):
+        self.data = []
+        self.dirname = osp.dirname(file_path)
+        with open(file_path,"r") as f:
+            lines = f.readlines()
+        
+        for line in lines:
+            line = line.strip()
+            if "#" in line:
+                datas = line.split("#")
+            else:
+                datas = line.split(" ")
+            self.data.append([datas[0],int(datas[1]),int(datas[2])]) #sub dir name, total frames, type
+
+    def write(self,file_name,spliter="#"):
+        save_path = osp.join(self.dirname,file_name)
+        print(f"Save path {save_path}")
+        with open(save_path,"w") as f:
+            for dirname,frames_nr,f_type in self.data:
+                f.write(f"{dirname}{spliter}{frames_nr}{spliter}{f_type}\n")
+        
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self,idx):
+        data = self.data[idx]
+        if self.get_item_in_namedtuple:
+            return VideoInfo(osp.join(self.dirname,data[0]),data[1],data[2])
+        else:
+            return osp.join(self.dirname,data[0]),data[1],data[2]
+
+    def show_statistics_info(self):
+        print(f"Total {len(self.data)} files.")
+        counter = wmlu.MDict(dvalue=0)
+        for dirname,frames_nr,f_type in self.data:
+            counter[f_type] += 1
+        
+        datas = list(zip(counter.keys(),counter.values()))
+        datas.sort(key=lambda x:x[0])
+        for f_type,nr in datas:
+            print(f"Type {f_type:5d}: {nr}")
+
+    def split_data(self,percent=[0.5,-1], shuffle=True,per_classes=True):
+        '''
+        按percent分割数据，-1表示所有剩余的数据
+        '''
+        res = []
+        if not per_classes:
+            datas = RawFrameDataset.simple_split_data(self.data,percent,shuffle)
+            for data in datas:
+                res.append(RawFrameDataset.create(self,data))
+            return res
+        else:
+            type_dict = self.get_type_dict()
+
+            all_res = []
+            for k,v in type_dict.items():
+                datas = RawFrameDataset.simple_split_data(v,percent,shuffle)
+                all_res.append(datas)
+
+            datas = list(zip(*all_res))
+            for data in datas:
+                data = list(chain(*data))
+                if shuffle:
+                    random.shuffle(data)
+                res.append(RawFrameDataset.create(self,data))
+
+            return res
+        
+    def get_type_dict(self):
+        res = wmlu.MDict(dtype=list)
+        for data in self.data:
+            res[data[-1]].append(data)
+        
+        return res
+
+    @staticmethod
+    def simple_split_data(data,percent=[0.5,-1], shuffle=True):
+        data = copy.deepcopy(data)
+        total_nr = len(data)
+        if shuffle:
+            random.shuffle(data)
+        res = []
+        for x in percent:
+            if x>=0:
+                nr = int(total_nr*x+0.5)
+                res.append(data[:nr])
+                data = data[nr:]
+            else:
+                res.append(data)
+                break
+        return res
+
+
+
+
+            
+
+            

wml/iotoolkit/rewrite_pascal_voc.py

@@ -0,0 +1,28 @@
+#coding=utf-8
+import os
+import wml.object_detection2.utils as odu
+import wml.wml_utils as wmlu
+import shutil
+
+def rewrite(input_dir,output_dir,image_sub_dir="JPEGImages",xml_sub_dir="Annotations",img_suffix=".jpg",begin_index=1):
+    if output_dir is None:
+        output_dir = os.path.join(input_dir,"output")
+    if not os.path.isdir(output_dir):
+        os.makedirs(output_dir)
+    files = odu.getVOCFiles(input_dir,image_sub_dir=image_sub_dir,xml_sub_dir=xml_sub_dir,img_suffix=img_suffix)
+    print(f"Nr {len(files)}")
+    index = begin_index
+    for img_file,xml_file in files:
+        suffix = wmlu.suffix(img_file)
+        img_out_path = os.path.join(output_dir,f"IMG_{index:0>4}."+suffix)
+        xml_out_path = os.path.join(output_dir,f"IMG_{index:0>4}."+"xml")
+        if os.path.exists(img_out_path):
+            print(f"Error file {img_out_path} exists.")
+            break
+        print(img_file,"->",img_out_path)
+        print(xml_file,"->",xml_out_path)
+        index += 1
+
+        shutil.copy(img_file,img_out_path)
+        shape, bboxes, labels_text, difficult, truncated = odu.read_voc_xml(xml_file)
+        odu.write_voc_xml(xml_out_path, img_out_path, shape, bboxes, labels_text, difficult,truncated)

wml/iotoolkit/semantic_data.py

@@ -0,0 +1,49 @@
+from PIL import Image
+import os
+from wml.semantic.visualization_utils import RGB_STANDARD_COLORS
+import wml.wml_utils as wmlu
+import numpy as np
+
+class SemanticData(object):
+    def __init__(self,img_suffix=".jpg",label_suffix=".png",img_sub_dir=None,label_sub_dir=None,
+                 color_map=None):
+        if color_map is None:
+            color_map = RGB_STANDARD_COLORS
+        self.color_map = []
+        for x in color_map:
+            self.color_map += list(x)
+        self.img_suffix = img_suffix
+        self.label_suffix = label_suffix
+        self.img_sub_dir = img_sub_dir
+        self.label_sub_dir = label_sub_dir
+        self.files = []
+
+    def read_data(self,dir_path):
+        label_dir = dir_path if self.label_sub_dir is None else os.path.join(dir_path,self.label_sub_dir)
+        img_dir = dir_path if self.img_sub_dir is None else os.path.join(dir_path,self.img_sub_dir)
+        image_files = wmlu.recurse_get_filepath_in_dir(img_dir,suffix=self.img_suffix)
+        self.files = []
+        for ifn in image_files:
+            base_name = wmlu.base_name(ifn)
+            label_path = os.path.join(label_dir,base_name+self.label_suffix)
+            if not os.path.exists(label_path):
+                print(f"ERROR: Find label file {label_path} for image {ifn} faild.")
+                continue
+            else:
+                self.files.append([ifn,label_path])
+
+    def __len__(self):
+        return len(self.files)
+
+    def get_items(self):
+        for i in range(len(self.files)):
+            yield self.__getitem__(i)
+
+    def __getitem__(self, item):
+        ifn,lfn = self.files[item]
+        img = Image.open(ifn).convert('RGB')
+        '''
+        mask:[H,W], value is label
+        '''
+        mask = Image.open(lfn)
+        return [ifn,lfn],np.array(img),np.array(mask)

wml/iotoolkit/split_file_by_type.py

@@ -0,0 +1,29 @@
+import shutil
+import wml.wml_utils as wmlu
+import os
+from wml.iotoolkit.pascal_voc_toolkit import PascalVOCData
+
+def copy_to_dir(files,save_dir):
+    wmlu.create_empty_dir(save_dir,remove_if_exists=False)
+    for f in files:
+        wmlu.safe_copy(f,save_dir)
+
+def split_file_by_type(datas,save_dir,get_buddy_files=None):
+    for data in datas:
+        img_file, shape, labels, labels_names, bboxes, _, _, difficult, _ = data
+        names = set(labels_names)
+        files = [img_file]
+        if get_buddy_files is not None:
+            files = files + get_buddy_files(img_file)
+
+        for name in names:
+            t_save_dir = os.path.join(save_dir,name)
+            copy_to_dir(files,t_save_dir)
+
+
+if __name__ == "__main__":
+    dataset = PascalVOCData()
+    dataset.read_data("/3_data/wj/mldata/cell/deep_data/")
+    def get_buddy_file(img_file):
+        return [wmlu.change_suffix(img_file,"xml")]
+    split_file_by_type(dataset.get_items(),"/3_data/wj/mldata/cell/deep_data_split2",get_buddy_files=get_buddy_file)

wml/iotoolkit/sports_mot_datasets.py

@@ -0,0 +1,78 @@
+import wml.wml_utils as wmlu
+import os
+import numpy as np
+import os.path as osp
+from .common import *
+
+class SportsMOTDatasets(object):
+    def __init__(self,dirs,absolute_coord=False,use_det=False):
+        if not isinstance(dirs,list):
+            dirs = [dirs]
+        self.dirs = dirs
+        self.tid_curr = 0
+        self.dir_curr = 0
+        self.absolute_coord = absolute_coord
+        self.use_det = use_det
+
+    def get_data_items(self):
+        dir_idx = -1
+        for seq_root in self.dirs:
+            seqs = wmlu.get_subdir_in_dir(seq_root)
+            for seq in seqs:
+                dir_idx += 1
+                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')])
+
+                if self.use_det:
+                    gt_txt = osp.join(seq_root,seq,"det","det.txt")
+                else:
+                    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, score,*_ = v[:9]
+                    if not self.use_det and score == 0:
+                        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():
+                    labels = []
+                    bboxes = []
+                    for _, tid, x, y, w, h, *_ 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]
+                        if not self.absolute_coord:
+                            xmin = x/seq_width
+                            ymin = y/seq_height
+                            xmax = (x+w)/seq_width
+                            ymax = (y+h)/seq_height
+                        else:
+                            xmin = x
+                            ymin = y
+                            xmax = x + w
+                            ymax = y + h
+                        labels.append(cls)
+                        bboxes.append([ymin,xmin,ymax,xmax])
+
+                    if len(labels)>0:
+                        img_name = '{:06d}.jpg'.format(fid)
+                        img_path = os.path.join(seq_root,seq,"img1",img_name)
+                        yield DetData(img_path, [seq_height,seq_width], labels, None, bboxes, None, None, None,dir_idx)
+
+        print(f"Last tid value {self.tid_curr}")

wml/iotoolkit/vis_objectdetection_dataset.py

@@ -0,0 +1,70 @@
+import wml.img_utils as wmli
+import random
+import matplotlib.pyplot as plt
+import time
+import wml.wml_utils as wmlu
+import os.path as osp
+import wml.object_detection2.visualization as odv
+import numpy as np
+
+def trans_name(name:str):
+    return name.replace("/","_")
+
+
+def vis_dataset(dataset,save_dir,max_nr_per_dir=20,max_view_imgs=2000,is_relative_coordinate=False):
+    wmlu.create_empty_dir_remove_if(save_dir)
+    idxs = list(range(len(dataset)))
+    random.seed(time.time())
+    idxs = idxs[:max_view_imgs]
+    random.shuffle(idxs)
+
+    def text_fn(classes, scores):
+        return dataset.id2name[classes]
+
+    counter = wmlu.MDict(dvalue=0)
+    for id,name in dataset.id2name.items():
+        counter[id] = 0
+
+    for idx in idxs:
+        x = dataset[idx]
+        full_path, shape,category_ids, category_names, boxes, binary_mask, area, is_crowd, num_annotations_skipped = x
+        category_ids = np.array(category_ids)
+        boxes = np.array(boxes)
+        need_view = False
+        for id in category_ids:
+            if counter[id]<max_nr_per_dir:
+                need_view = True
+                break
+        if not need_view:
+            continue
+
+        img = wmli.imread(full_path)
+
+
+        t_img = odv.draw_bboxes(
+            img=np.copy(img), classes=category_ids, scores=None, bboxes=boxes, color_fn=None,
+            text_fn=text_fn, thickness=1,
+            show_text=True,
+            font_scale=0.8,
+            is_relative_coordinate=is_relative_coordinate)
+        file_basename = osp.basename(full_path)
+        save_path = osp.join(save_dir,"all",file_basename)
+        wmli.imwrite(save_path,t_img)
+
+        for id in set(category_ids):
+            if counter[id]<max_nr_per_dir:
+                mask = category_ids==id
+                t_labels = category_ids[mask]
+                t_boxes = boxes[mask]
+                t_img = odv.draw_bboxes(
+                    img=np.copy(img), classes=t_labels, scores=None, bboxes=t_boxes, color_fn=None,
+                    text_fn=text_fn, thickness=1,
+                    show_text=True,
+                    font_scale=0.8,
+                    is_relative_coordinate=is_relative_coordinate)
+                counter[id] = counter[id]+1
+                t_save_path = osp.join(save_dir,str(id)+"_"+trans_name(dataset.id2name[id]),file_basename)
+                wmlu.make_dir_for_file(t_save_path)
+                wmli.imwrite(t_save_path,t_img)
+        if np.all(np.array(list(counter.values()))>max_nr_per_dir):
+            break

wml/iotoolkit/vis_torch_data.py

@@ -0,0 +1,39 @@
+from wml.iotoolkit.coco_toolkit import *
+import wml.img_utils as wmli
+import wml.object_detection2.visualization as odv
+import os.path as osp
+import random
+import time
+
+def trans_file_name(filename,image_dir):
+    names = filename.split("/")[-2:]
+    return osp.join(*names)
+random.seed(time.time())
+COCOData.trans_file_name = trans_file_name
+data = TorchCOCOData("/home/wj/ai/mldata/o365/train",
+                     "/home/wj/ai/mldata/o365/train/zhiyuan_objv2_train.json")
+save_dir = "tmp/imgs"
+
+wmlu.create_empty_dir_remove_if(save_dir)
+
+max_show_nr = 1000
+idxs = list(range(len(data)))
+random.shuffle(idxs)
+idxs = idxs[:max_show_nr]
+
+
+for idx in idxs:
+    img,gts = data[idx]
+    bboxes = [x['bbox'] for x in gts]
+    labels = np.array([x['category_id'] for x in gts])
+    bboxes = np.array(bboxes)
+    bboxes[:,2:] = bboxes[:,:2]+bboxes[:,2:]
+    img = np.array(img)
+    img = odv.draw_bboxes_xy(
+        img=img, classes=labels, scores=None, bboxes=bboxes,  color_fn=None,
+        thickness=4,
+        show_text=True,
+        font_scale=0.8)
+    save_path = osp.join(save_dir,f"{idx}.jpg")
+    print(f"Save {save_path}")
+    wmli.imwrite(save_path,img)

wml/iotoolkit/yolo_toolkit.py

@@ -0,0 +1,38 @@
+import wml.object_detection2.bboxes as odb
+import wml.img_utils as wmli
+
+def write_yolo_txt(save_path,img_path,labels,bboxes):
+    '''
+    bboxes: [y0,x0,y1,x1]
+    '''
+    h,w = wmli.get_img_size(img_path)[:2]
+    bboxes = odb.absolutely_boxes_to_relative_boxes(bboxes,width=w,height=h)
+    bboxes = odb.npchangexyorder(bboxes) #(x0,y0,x1,y1)
+    bboxes = odb.npto_cyxhw(bboxes) #->(cx,cy,w,h)
+    with open(save_path,"w") as f:
+        for l,bbox in zip(labels,bboxes):
+            #每一行为label cx cy w h
+            f.write(f"{l} {bbox[0]} {bbox[1]} {bbox[2]} {bbox[3]}\n")
+
+def write_yoloseg_txt(save_path,img_path,labels,masks):
+    '''
+    masks:WPolygonMasks
+    '''
+    h,w = wmli.get_img_size(img_path)[:2]
+    with open(save_path,"w") as f:
+        for l,mask_items in zip(labels,masks):
+            #每一行为label x0 y0 x1 y1 ...
+            if len(mask_items.points) ==0:
+                continue
+            points = mask_items.points[0]
+
+            if len(points)<3:
+                continue
+            info = f"{l} "
+
+            for p in points:
+                x = p[0]/w
+                y = p[1]/h
+                info += f"{x} {y} "
+            info += "\n"
+            f.write(info)

wml/object_detection2/__init__.py

@@ -0,0 +1,4 @@
+from .standard_names import *
+from .bboxes import iou_matrix,npbboxes_jaccard,npbboxes_intersection_of_box0
+from .visualization import draw_bboxes_and_mask,draw_bboxes_and_maskv2,draw_bboxes_xy,draw_bboxes
+from .odtools import make_text2label

wml/object_detection2/basic_visualization.py

@@ -0,0 +1,37 @@
+#coding=utf-8
+import numpy as np
+from PIL import Image
+
+def convert_semantic_to_rgb(semantic,color_map,return_nparray=False):
+    '''
+    convert semantic label map to rgb PIL image or a np.ndarray
+    Args:
+        semantic: [H,W] label value
+        color_map: list[int], [r0,g0,b0,r1,g1,b1,....]
+    Returns:
+        image: [H,W,3]
+    '''
+    new_mask = Image.fromarray(semantic.astype(np.uint8)).convert('P')
+    new_mask.putpalette(color_map)
+    if return_nparray:
+        return np.array(new_mask.convert('RGB'))
+    return new_mask
+
+def draw_semantic_on_image(image,semantic,color_map,alpha=0.4,ignored_label=0):
+    '''
+    draw semantic on image
+    Args:
+        image:
+        semantic: [H,W] label value
+        color_map: list[int], [r0,g0,b0,r1,g1,b1,....]
+        alpha: mask percent
+        ignored_label:
+    Returns:
+        return image*(1-alpha)+semantic+alpha
+    '''
+    mask = convert_semantic_to_rgb(semantic,color_map=color_map,return_nparray=True)
+    new_img = image.astype(np.float32)*(1-alpha)+mask.astype(np.float32)*alpha
+    new_img = np.clip(new_img,0,255).astype(np.uint8)
+    pred = np.expand_dims(semantic!=ignored_label,axis=-1)
+    new_img = np.where(pred,new_img,image)
+    return new_img