python-wml 3.0.0__py3-none-any.whl

wml/object_detection2/data_process_toolkit.py

@@ -0,0 +1,146 @@
+import wml.img_utils as wmli
+import wml.object_detection2.bboxes as odb
+import cv2 as cv
+import numpy as np
+from wml.semantic.mask_utils import cut_mask
+
+def motion_blur(image, degree=10, angle=20):
+    image = np.array(image)
+    # 这里生成任意角度的运动模糊kernel的矩阵， degree越大，模糊程度越高
+    M = cv.getRotationMatrix2D((degree / 2, degree / 2), angle, 1)
+    motion_blur_kernel = np.diag(np.ones(degree))
+    motion_blur_kernel = cv.warpAffine(motion_blur_kernel, M, (degree, degree))
+
+    motion_blur_kernel = motion_blur_kernel / degree
+    blurred = cv.filter2D(image, -1, motion_blur_kernel)
+    # convert to uint8
+    cv.normalize(blurred, blurred, 0, 255, cv.NORM_MINMAX)
+    blurred = np.array(blurred, dtype=np.uint8)
+    return blurred
+
+'''
+cnt is a contour in a image, cut the area of rect
+cnt:[[x,y],[x,y],...]
+rect:[ymin,xmin,ymax,xmax]
+output:
+the new contours in sub image
+'''
+def cut_contour(cnt,rect):
+    bbox = bbox_of_contour(cnt)
+    width = max(bbox[3],rect[3])
+    height = max(bbox[2],rect[2])
+    img = np.zeros(shape=(height,width),dtype=np.uint8)
+    segmentation = cv.drawContours(img,[cnt],-1,color=(1),thickness=cv.FILLED)
+    cuted_img = wmli.sub_image(segmentation,rect)
+    contours,hierarchy = cv.findContours(cuted_img,cv.CV_RETR_LIST,cv.CHAIN_APPROX_SIMPLE)
+    return contours
+
+'''
+find the contours in rect of segmentation
+segmentation:[H,W] value is 1 or 0
+rect:[ymin,xmin,ymax,xmax]
+output:
+the new contours in sub image and correspond bbox
+'''
+def cut_contourv2(segmentation,rect):
+    org_contours,org_hierarchy = cv.findContours(segmentation,cv.RETR_LIST,cv.CHAIN_APPROX_SIMPLE)
+    max_area = np.sum(segmentation)
+    cuted_img = wmli.sub_image(segmentation,rect)
+    contours,hierarchy = cv.findContours(cuted_img,cv.RETR_LIST,cv.CHAIN_APPROX_SIMPLE)
+    boxes = []
+    ratio = []
+    for cnt in contours:
+        boxes.append(bbox_of_contour(cnt))
+        ratio.append(cv.contourArea(cnt)/max_area)
+    return contours,boxes,ratio
+
+def remove_class_in_image(bboxes,labels,labels_to_remove,image,default_value=127,scale=1.1):
+    bboxes = bboxes.astype(np.int32)
+    mask = np.ones_like(labels,dtype=np.bool)
+    for l in labels_to_remove:
+        tm = labels==l
+        mask = np.logical_and(tm,mask)
+    keep_mask = np.logical_not(mask)
+    keep_bboxes = bboxes[keep_mask]
+    remove_bboxes = bboxes[mask]
+    img_mask = np.ones(image.shape[:2],dtype=np.bool)
+
+    wmli.remove_boxes_of_img(img_mask,remove_bboxes,False)
+    if scale>1.0:
+        t_keep_bboxes = npscale_bboxes(keep_bboxes,scale).astype(np.int32)
+    else:
+        t_keep_bboxes = keep_bboxes
+    wmli.remove_boxes_of_img(img_mask,t_keep_bboxes,True)
+
+    img_mask = np.expand_dims(img_mask,axis=-1)
+    img_mask = np.tile(img_mask,[1,1,3])
+    remove_image = np.ones_like(image)*default_value
+    image = np.where(img_mask,image,remove_image)
+    return image,keep_bboxes,labels[keep_mask]
+
+def remove_class(bboxes,labels,scores=None,labels_to_remove=[]):
+    bboxes = bboxes.astype(np.int32)
+    mask = np.ones_like(labels,dtype=np.bool)
+    for i,l in enumerate(labels):
+        if l in labels_to_remove:
+            mask[i] = False
+    bboxes = bboxes[mask]
+    labels = labels[mask]
+    if scores is not None:
+        scores = scores[mask]
+    
+    return bboxes,labels,scores,mask
+
+
+def cut_annotation(cut_bbox,img,labels,bboxes,masks=None,adjust_bbox=True,keep_ratio=0):
+    '''
+    cut_bbox: [y0,x0,y1,x1]
+    img: [H,W,3/1]
+    bboxes: [N,4] [y0,x0,y1,x1]
+    masks: [N,H,W]
+    '''
+    cut_bbox = list(cut_bbox)
+    if adjust_bbox:
+        b_w = cut_bbox[3]-cut_bbox[1]
+        b_h = cut_bbox[2]-cut_bbox[0]
+        cut_bbox[0] = min(img.shape[0],cut_bbox[2])-b_h
+        cut_bbox[1] = min(img.shape[1],cut_bbox[3])-b_w
+
+    cut_bbox[0] = max(0,cut_bbox[0])
+    cut_bbox[1] = max(0,cut_bbox[1])
+
+    cut_bbox[2] = min(cut_bbox[2],img.shape[0])
+    cut_bbox[3] = min(cut_bbox[3],img.shape[1])
+
+    new_bboxes = []
+    new_labels = []
+    new_img = wmli.sub_image(img,cut_bbox)
+    if masks is not None:
+        new_masks = []
+        for i in range(len(labels)):
+            n_mask,n_bbox,ratio = cut_mask(masks[i],cut_bbox)
+            if n_mask is not None and n_bbox is not None and ratio>keep_ratio:
+                new_bboxes.append(n_bbox)
+                new_labels.append(labels[i])
+                new_masks.append(n_mask)
+        if len(new_labels)>0:
+            new_labels = np.concatenate(new_labels,axis=0)
+            new_bboxes = np.concatenate(new_bboxes,axis=0)
+            new_masks = np.concatenate(new_masks,axis=0)
+        else:
+            new_labels = np.zeros([0],dtype=labels.dtype)
+            new_bboxes = np.zeros([0,4],dtype=bboxes.dtype)
+            new_masks = np.zeros([0,new_img.shape[0],new_img.shape[1]],dtype=masks.dtype)
+    else:
+        new_masks = None
+        bbox_area = odb.area(bboxes)
+        new_bboxes = odb.cut_boxes_by_box0(box0=cut_bbox,box1=bboxes)
+        new_bbox_area = odb.area(new_bboxes)
+        ratios = new_bbox_area/np.maximum(bbox_area,1)
+        keep = ratios>keep_ratio
+        new_labels = labels[keep]
+        new_bboxes = new_bboxes[keep]
+        offset = np.reshape(np.array([cut_bbox[0],cut_bbox[1],cut_bbox[0],cut_bbox[1]],dtype=new_bboxes.dtype),[1,4])
+        new_bboxes = new_bboxes-offset
+
+    return new_img,new_labels,new_bboxes,new_masks

wml/object_detection2/keypoints.py

@@ -0,0 +1,292 @@
+import cv2
+import numpy as np
+import math
+
+def npget_bbox(keypoints,threshold=0.02):
+    '''
+
+    Args:
+        keypoints: [N,3] or [N,2] ,[x,y,visible]
+        threshold:
+
+    Returns:
+        [xmin,ymin,xmax,ymax]
+
+    '''
+    assert len(keypoints.shape)==2,f"ERROR kps shape {keypoints.shape}"
+
+    if keypoints.shape[-1]>=3:
+        mask = keypoints[:,2]>threshold
+        if np.any(mask):
+            keypoints = keypoints[mask]
+        else:
+            return None
+    xmin = np.min(keypoints[:,0])
+    xmax = np.max(keypoints[:,0])
+    ymin = np.min(keypoints[:,1])
+    ymax = np.max(keypoints[:,1])
+    return np.array([xmin,ymin,xmax,ymax],dtype=np.float32)
+
+def expand_bbox_by_kps(bbox,keypoints,threshold=0.02):
+    '''
+
+    Args:
+        bbox: [xmin,ymin,xmax,ymax]
+        keypoints: [[x,y,score],...]
+        threshold:
+
+    Returns:
+        [xmin,ymin,xmax,ymax]
+
+    '''
+    kp_bbox = npget_bbox(keypoints,threshold=threshold)
+    if kp_bbox is None:
+        return bbox
+    xmin,ymin,xmax,ymax = bbox
+    xmin = np.minimum(xmin,kp_bbox[0])
+    ymin = np.minimum(ymin,kp_bbox[1])
+    xmax = np.maximum(xmax,kp_bbox[2])
+    ymax = np.maximum(ymax,kp_bbox[3])
+
+    return np.array([xmin,ymin,xmax,ymax],dtype=np.float32)
+
+def expand_yxyx_bbox_by_kps(bbox,keypoints,threshold=0.02):
+    '''
+
+    Args:
+        bbox: [ymin,xmin,ymax,xmax]
+        keypoints: [[x,y,score],...]
+        threshold:
+
+    Returns:
+        [ymin,xmin,ymax,xmax]
+
+    '''
+    kp_bbox = npget_bbox(keypoints, threshold=threshold)
+    if kp_bbox is None:
+        return bbox
+    ymin, xmin, ymax, xmax = bbox
+    xmin = np.minimum(xmin, kp_bbox[0])
+    ymin = np.minimum(ymin, kp_bbox[1])
+    xmax = np.maximum(xmax, kp_bbox[2])
+    ymax = np.maximum(ymax, kp_bbox[3])
+
+    return np.array([ymin, xmin, ymax, xmax], dtype=np.float32)
+
+
+def npbatchget_bboxes(keypoints,threshold=0.02):
+    if not isinstance(keypoints,np.ndarray):
+        keypoints = np.array(keypoints)
+
+    if len(keypoints.shape)==2:
+        return npget_bbox(keypoints,threshold)
+
+    bboxes = []
+    for kps in keypoints:
+        bboxes.append(npget_bbox(kps,threshold))
+    return np.array(bboxes)
+
+def keypoint_distance(kp0,kp1,use_score=True,score_threshold=0.1,max_dis=1e8):
+    '''
+
+    Args:
+        kp0: [NP_NR,2/3] (x,y) or (x,y,score)
+        kp1: [NP_NR,2/3] (x,y) or (x,y,score)
+        use_score:
+        score_threshold:
+        max_dis:
+
+    Returns:
+    '''
+    KP_NR = kp0.shape[0]
+    NR_THRESHOLD = KP_NR/4
+    def point_dis(p0,p1):
+        dx = p0[0]-p1[0]
+        dy = p0[1]-p1[1]
+        return math.sqrt(dx*dx+dy*dy)
+
+    if use_score:
+        count_nr = 0
+        sum_dis = 0.0
+        for i in range(KP_NR):
+            if kp0[i][2]>score_threshold and kp1[i][2]>score_threshold:
+                count_nr += 1
+                sum_dis += point_dis(kp0[i],kp1[i])
+        if count_nr<=NR_THRESHOLD:
+            return max_dis
+        else:
+            return sum_dis/count_nr
+    else:
+        sum_dis = 0.0
+        for i in range(KP_NR):
+            sum_dis += point_dis(kp0[i],kp1[i])
+
+        return sum_dis/KP_NR
+
+def keypoint_distancev2(kp0,kp1,bbox0,bbox1,use_score=True,score_threshold=0.1,max_dis=1e8):
+    dis = keypoint_distance(kp0,kp1,use_score,score_threshold,max_dis)
+    bboxes = np.stack([bbox0,bbox1],axis=0)
+    hw = bboxes[...,2:]-bboxes[...,:2]
+    size = np.maximum(1e-8,hw[...,0]*hw[...,1])
+    size = np.sqrt(size)
+    size = np.mean(size)
+    return dis/size
+
+
+def keypoints_distance(kps,use_score=True,score_threshold=0.1,max_dis=1e8):
+    '''
+
+    Args:
+        kps: [N,KP_NR,3/2] (x,y) or (x,y,score)
+        use_score:
+        score_threshold:
+
+    Returns:
+
+    '''
+
+    N = kps.shape[0]
+    res = np.zeros([N],dtype=np.float32)
+
+    for i in range(1,N):
+        res[i] = keypoint_distance(kps[i-1],kps[i],use_score,score_threshold,max_dis)
+
+    return res
+
+def keypoints_distancev2(kps,bboxes,use_score=True,score_threshold=0.1,max_dis=1e8):
+    '''
+
+    Args:
+        kps: [N,KP_NR,2/3]
+        bboxes: [N,4] [ymin,xmin,ymax,xmax]
+        use_score:
+        score_threshold:
+        max_dis:
+
+    Returns:
+
+    '''
+    dis = keypoints_distance(kps,use_score,score_threshold,max_dis)
+
+    hw = bboxes[...,2:]-bboxes[...,:2]
+    size = np.maximum(1e-8,hw[...,0]*hw[...,1])
+    size = np.sqrt(size)
+    dis = dis/size
+    return dis
+
+def affine_transform(pt, t):
+    new_pt = np.array([pt[0], pt[1], 1.]).T
+    new_pt = np.dot(t, new_pt)
+    return new_pt[:2]
+
+def rotate(angle,img,kps,bbox,scale=1.0):
+    '''
+
+    Args:
+        angle: [-360,360]
+        img: [RGB]
+        kps: [N,2]/[N,3]
+        bbox: [xmin,ymin,xmax,ymax]
+
+    Returns:
+
+    '''
+    cx = (bbox[0]+bbox[2])/2
+    cy = (bbox[1] + bbox[3]) / 2
+    matrix = cv2.getRotationMatrix2D([cx,cy],angle,scale)
+    img = cv2.warpAffine(img,matrix,dsize=(img.shape[1],img.shape[0]),
+                         flags=cv2.INTER_LINEAR)
+    num_joints = kps.shape[0]
+
+    def is_good_point(p):
+        return p[0]>=0 and p[1]>=0 and p[0]<img.shape[1] and p[1]<img.shape[0]
+
+    for i in range(num_joints):
+        if kps[i, 2] > 0.0:
+            kps[i, 0:2] = affine_transform(kps[i, 0:2], matrix)
+            if not is_good_point(kps[i]):
+                kps[i,:] = 0
+    points = [bbox[:2],[bbox[0],bbox[3]],bbox[2:],[bbox[2],bbox[1]]]
+    res_points = []
+    for p in points:
+        p = affine_transform(np.array(p),matrix)
+        res_points.append(p)
+    res_points = np.array(res_points)
+    x0y0 = np.maximum(np.min(res_points,axis=0),0)
+    x1y1 = np.minimum(np.max(res_points,axis=0),[img.shape[1]-1,img.shape[0]-1])
+    bbox = np.concatenate([x0y0,x1y1],axis=0)
+
+    return img,kps,bbox
+
+def fliplr_joints(joints, width, matched_parts,joints_vis):
+    """
+    flip coords
+    """
+    # Flip horizontal
+    joints[:, 0] = width - joints[:, 0] - 1
+
+    # Change left-right parts
+    for pair in matched_parts:
+        joints[pair[0], :], joints[pair[1], :] = \
+            joints[pair[1], :], joints[pair[0], :].copy()
+        if joints_vis is not None:
+            joints_vis[pair[0], :], joints_vis[pair[1], :] = \
+                joints_vis[pair[1], :], joints_vis[pair[0], :].copy()
+
+    return joints,joints_vis
+
+def flip(img,kps,joints_vis,matched_parts,bbox=None):
+    '''
+
+    Args:
+        img:
+        kps: [N,3] x,y,vis
+        joints_vis: [N,3]
+        matched_parts: [[id0_0,id0_1],...]
+        bboxes: [xmin,ymin,xmax,ymax]
+
+    Returns:
+
+    '''
+    img = img[:, ::-1, :]
+    joints, joints_vis = fliplr_joints(
+                    kps,img.shape[1], matched_parts,joints_vis)
+    if bbox is not None:
+        xmax = img.shape[1] - bbox[0] - 1
+        bbox[0] = img.shape[1] - bbox[2] - 1
+        bbox[2] = xmax
+
+    return img,joints,joints_vis,bbox
+
+
+def cut2size(kps,bbox,dst_size):
+    '''
+    bbox:[xmin,ymin,xmax,ymax]
+    dst_size:[W,H]
+    kps:[N,3]/[N,2]
+    '''
+    kps[...,:2] = kps[...,:2]-np.array([[bbox[0],bbox[1]]],dtype=np.float32)
+    bbox_w = bbox[2]-bbox[0]
+    bbox_h = bbox[3]-bbox[1]
+    if bbox_w<1e-8 or bbox_h<1e-8:
+        print(f"object_detection2.keypoints: ERROR bbox in cut2size.")
+        bbox_w = max(1.0,bbox_w)
+        bbox_h = max(1.0,bbox_h)
+    kps[...,:2] = kps[...,:2]*np.array([[dst_size[0]/bbox_w,dst_size[1]/bbox_h]],dtype=np.float32)
+    return kps
+
+
+def mckps_distance_matrix(kps0,kps1):
+    '''
+    kps0: [N,2]
+    kps1: [M,2]
+    return:
+    [N,M]
+    '''
+    kps0 = np.expand_dims(kps0,axis=1)
+    kps1 = np.expand_dims(kps1,axis=0)
+    delta = kps0-kps1
+    pdelta = np.square(delta)
+    ssquare = np.sum(pdelta,axis=-1,keepdims=False)
+    dis = np.sqrt(ssquare)
+    return dis

wml/object_detection2/mask.py

@@ -0,0 +1,120 @@
+#coding=utf-8
+import numpy as np
+
+'''
+mask: [N,H,W] value is 0 or 1
+labels: [N] labels of mask
+return:
+[H,W] value is labels' value
+'''
+def dense_mask_to_sparse_mask(mask:np.ndarray,labels,default_label=0):
+    if len(labels) == 0 and not isinstance(mask,np.ndarray):
+        return None
+    elif len(labels)==0:
+        _,H,W = mask.shape
+        return np.ones([H,W],dtype=np.int32)*default_label
+    else:
+        N,H,W = mask.shape
+        res_mask = np.ones([H,W],dtype=np.int32)*default_label
+        for i in range(N):
+            pos_mask = mask[i].astype(np.bool)
+            res_mask[pos_mask] = labels[i]
+        return res_mask
+
+def dense_mask_to_sparse_maskv2(mask:np.ndarray,labels,labels_order,default_label=0):
+    '''
+    generate the mask by labels order
+    Args:
+        mask:
+        labels:
+        labels_order:
+        default_label:
+
+    Returns:
+
+    '''
+    labels = list(labels)
+    if len(labels) == 0 and not isinstance(mask,np.ndarray):
+        return None
+    elif len(labels)==0:
+        _,H,W = mask.shape
+        return np.ones([H,W],dtype=np.int32)*default_label
+    else:
+        N,H,W = mask.shape
+        res_mask = np.ones([H,W],dtype=np.int32)*default_label
+        for l in labels_order:
+            if l not in labels:
+                continue
+            for i in range(N):
+                if labels[i] != l:
+                    continue
+                pos_mask = mask[i].astype(np.bool)
+                res_mask[pos_mask] = l
+        return res_mask
+
+
+'''
+mask: [N,H,W] value is 0 or 1
+labels: [N] labels of mask
+small object overwrite big object 
+'''
+def dense_mask_to_sparse_maskv3(mask:np.ndarray,labels,default_label=0):
+    if len(labels) == 0 and not isinstance(mask,np.ndarray):
+        return None
+    elif len(labels)==0:
+        _,H,W = mask.shape
+        return np.ones([H,W],dtype=np.int32)*default_label
+    else:
+        N,H,W = mask.shape
+        nrs = np.sum(mask,axis=(1,2))
+        orders = np.argsort(-nrs)
+        res_mask = np.ones([H,W],dtype=np.int32)*default_label
+        for i in orders:
+            pos_mask = mask[i].astype(np.bool)
+            res_mask[pos_mask] = labels[i]
+        return res_mask
+
+def get_bboxes_by_mask(masks):
+    '''
+    masks: [N,H,W]
+    return :
+    [N,4] (xmin,ymin,xmax,ymax)
+    '''
+    if len(masks) == 0:
+        return np.zeros([0,4],dtype=np.float32)
+
+    bboxes = []
+    for i in range(masks.shape[0]):
+        cur_mask = masks[i]
+        idx = np.nonzero(cur_mask)
+        xs = idx[1]
+        ys = idx[0]
+        if len(xs)==0:
+            bboxes.append(np.zeros([4],dtype=np.float32))
+        else:
+            x0 = np.min(xs)
+            y0 = np.min(ys)
+            x1 = np.max(xs)
+            y1 = np.max(ys)
+            bboxes.append(np.array([x0,y0,x1,y1],dtype=np.float32))
+    
+    bboxes = np.array(bboxes)
+
+    return bboxes
+
+def crop_masks_by_bboxes(masks,bboxes):
+    '''
+    masks: [N,H,W]
+    bboxes: [N,4] (x0,y0,x1,y1), absolute coordinate
+    '''
+    shape = masks.shape[1:]
+    bboxes[:,0:4:2] = np.clip(bboxes[:,0:4:2],0.0,shape[1])
+    bboxes[:,1:4:2] = np.clip(bboxes[:,1:4:2],0.0,shape[0])
+    bboxes = bboxes.astype(np.int32)
+    res = []
+    for i in range(bboxes.shape[0]):
+        x0,y0,x1,y1 = bboxes[i]
+        m = masks[i,y0:y1,x0:x1].copy()
+        res.append(m)
+    
+    return res

wml/object_detection2/metrics/__init__.py

@@ -0,0 +1,3 @@
+from .toolkit import *
+from .mckps_toolkit import *
+from .classifier_toolkit import *

wml/object_detection2/metrics/build.py

@@ -0,0 +1,15 @@
+from wml.thirdparty.registry import Registry
+import copy
+
+METRICS_REGISTRY = Registry("Metrics")
+CLASSIFIER_METRICS_REGISTRY = Registry("ClassifierMetrics")
+
+def build_metrics(cfg):
+    cfg = copy.deepcopy(cfg)
+    type_str = cfg.pop("type")
+    return METRICS_REGISTRY.get(type_str)(**cfg)
+
+def build_classifier_metrics(cfg):
+    cfg = copy.deepcopy(cfg)
+    type_str = cfg.pop("type")
+    return CLASSIFIER_METRICS_REGISTRY.get(type_str)(**cfg)