python-wml 3.0.0__py3-none-any.whl

wml/object_detection2/wmath.py

@@ -0,0 +1,34 @@
+import numpy as np
+from numpy import seterr
+from typing import Optional
+import traceback
+import sys
+
+seterr(all='raise')
+
+def npsafe_divide(numerator, denominator, name=None):
+    try:
+        return np.where(
+        np.greater(denominator, 0),
+        np.divide(numerator, denominator),
+        np.zeros_like(numerator))
+    except Exception as e:
+        print(e)
+        traceback.print_exc(file=sys.stdout)
+
+
+
+def make_divisible(v: float, divisor: int, min_value: Optional[int] = None) -> int:
+    """
+    This function is taken from the original tf repo.
+    It ensures that all layers have a channel number that is divisible by 8
+    It can be seen here:
+    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
+    """
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than 10%.
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v

wml/semantic/basic_toolkit.py

@@ -0,0 +1,65 @@
+import numpy as np
+import cv2
+import wml.basic_img_utils as bwmli
+import sys
+
+def find_contours_in_bbox(mask,bbox):
+    bbox = np.array(bbox).astype(np.int32)
+    sub_mask = bwmli.crop_img_absolute_xy(mask,bbox)
+    if sub_mask.shape[0]<=1 or sub_mask.shape[1]<=1:
+        return []
+    contours,hierarchy = cv2.findContours(sub_mask,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
+    if len(contours) == 0:
+        return []
+    offset = np.array([bbox[0],bbox[1]],dtype=np.int32)
+    offset = np.reshape(offset,[1,1,2])
+    res = []
+    for x in contours:
+        res.append(x+offset)
+    return res
+
+def get_bboxes_by_contours(contours):
+    '''
+    contours:[[N,2]]
+    '''
+    if len(contours)==0:
+        return np.zeros([4],dtype=np.float32)
+    cn0 = np.reshape(contours[0],[-1,2])
+    x0 = np.min(cn0[:,0])
+    x1 = np.max(cn0[:,0])
+    y0 = np.min(cn0[:,1])
+    y1 = np.max(cn0[:,1])
+    for cn in contours[1:]:
+        cn = np.reshape(cn,[-1,2])
+        x0 = min(np.min(cn[:,0]),x0)
+        x1 = max(np.max(cn[:,0]),x1)
+        y0 = min(np.min(cn[:,1]),y0)
+        y1 = max(np.max(cn[:,1]),y1)
+
+    return np.array([x0,y0,x1,y1],dtype=np.float32)
+
+def findContours(mask,mode=cv2.RETR_TREE,method=cv2.CHAIN_APPROX_SIMPLE):
+    '''
+    mask: [H,W] value is 0 or 1, np.uint8
+    return:
+    contours: list[[N,2]] 
+    '''
+
+    _contours, hierarchy = cv2.findContours(mask, mode,method)
+    try:
+        hierarchy = np.reshape(hierarchy,[-1,4]) 
+    except Exception as e:
+        if len(_contours) != 0:
+            print(f"ERROR: {e}, {_contours} {hierarchy}")
+        hierarchy = np.zeros([0,4])
+        sys.stdout.flush()
+    contours = []
+    for he,cont in zip(hierarchy,_contours):
+        if he[-1]>=0 and cv2.contourArea(cont) < cv2.contourArea(_contours[he[-1]]):
+            continue
+        if len(cont.shape) == 3 and cont.shape[1] == 1:
+            contours.append(np.squeeze(cont,axis=1))
+        elif len(cont.shape)==2 and cont.shape[0]>2:
+            contours.append(cont)
+    return contours,hierarchy
+

wml/semantic/mask_utils.py

@@ -0,0 +1,156 @@
+#coding=utf-8
+import numpy as np
+import logging
+import wml.basic_img_utils as bwmli
+import cv2
+from .basic_toolkit import *
+import torch
+import math
+
+def np_iou(mask0,mask1):
+    if mask0.dtype is not np.bool:
+        mask0 = mask0.astype(np.bool)
+    if mask1.dtype is not np.bool:
+        mask1 = mask1.astype(np.bool)
+
+    if len(mask0.shape) != len(mask1.shape):
+        logging.warning("Mask not compatible with each other")
+        return 0.
+
+    different = np.logical_xor(mask0,mask1)
+    different = different.astype(np.float32)
+    different = np.sum(different)
+
+    union = np.logical_or(mask0,mask1)
+    union = union.astype(np.float32)
+    union = np.sum(union)
+    #logging.info("union={}, different={}, mask={}, gt={}".format(union,different,np.sum(mask0.astype(np.float32)),np.sum(mask1.astype(np.float32))))
+
+    if union == 0:
+        return 100.0
+
+    return 100.0-different*100.0/union
+
+'''
+mask:[H,W,NUM_CLASSES]
+mask:[H,W]
+'''
+def np_mask2masklabels(mask,begin_label=1):
+    res = np.zeros(mask.shape[:2],np.int32)
+    h = mask.shape[0]
+    w = mask.shape[1]
+    num_classes = mask.shape[2]
+
+    for i in range(h):
+        for j in range(w):
+            for k in range(num_classes):
+                if mask[i,j,k]>0:
+                    res[i,j] = k+begin_label
+                    break
+
+    return res
+
+def resize_img_and_mask(img,mask,size,img_pad_value=127,mask_pad_value=255,pad_type=1):
+    '''
+
+    Args:
+        img:
+        mask:
+        size: (w,h)
+        img_pad_value:
+        mask_pad_value:
+        pad_type:
+
+    Returns:
+
+    '''
+    img = np.array(img)
+    mask = np.array(mask)
+    img = bwmli.resize_img(img, size, keep_aspect_ratio=True)
+    mask = bwmli.resize_img(mask, img.shape[:2][::-1], keep_aspect_ratio=False, interpolation=cv2.INTER_NEAREST)
+    img, px0, px1, py0, py1 = bwmli.pad_img(img, size, pad_value=img_pad_value, pad_type=pad_type, return_pad_value=True)
+    mask = bwmli.pad_imgv2(mask, px0, px1, py0, py1, pad_value=mask_pad_value)
+    return img,mask
+
+'''
+mask:[H,W] value is 1 or 0
+rect:[ymin,xmin,ymax,xmax]
+output:
+the new mask in sub image and correspond bbox
+'''
+def cut_mask(mask,rect):
+    max_area = np.sum(mask)
+    cuted_mask = bwmli.sub_image(mask,rect)
+    ratio = np.sum(cuted_mask)/max(1,max_area)
+    if ratio <= 1e-6:
+        return None,None,ratio
+    ys,xs = np.where(cuted_mask)
+    xmin = np.min(xs)
+    xmax = np.max(xs)
+    ymin = np.min(ys)
+    ymax = np.max(ys)
+    bbox = np.array([xmin,ymin,xmax,ymax],dtype=np.int32)
+    return cuted_mask,bbox,ratio
+
+'''
+mask:[N,H,W] value is 1 or 0
+bboxes:[N,4] [ymin,xmin,ymax,xmax]
+output:
+the new mask in sub image and correspond bbox
+'''
+def cut_masks(masks,bboxes):
+    new_masks = []
+    new_bboxes = []
+    ratios = []
+    nr = len(masks)
+    for i in range(len(nr)):
+        n_mask,n_bbox,ratio = cut_mask(masks[i],bboxes[i])
+        new_masks.append(n_mask)
+        new_bboxes.append(n_bbox)
+        ratios.append(ratio)
+    
+    return new_masks,new_bboxes,ratios
+
+
+def resize_mask(mask,size=None,r=None,mode='nearest'):
+    '''
+    mask: [N,H,W]
+    size: (new_w,new_h)
+    mode (str): algorithm used for upsampling: 'nearest' | 'linear' | 'bilinear' | 'bicubic' | 'trilinear' | 'area' | 'nearest-exact'.
+                Default: 'nearest'
+    '''
+    if size is None:
+        size = (int(mask.shape[2]*r),int(mask.shape[1]*r))
+    if mask.numel()==0:
+        return mask.new_zeros([mask.shape[0],size[1],size[0]])
+
+    mask = torch.unsqueeze(mask,dim=0)
+    mask =  torch.nn.functional.interpolate(mask,size=(size[1],size[0]),mode=mode)
+    mask = torch.squeeze(mask,dim=0)
+    return mask
+
+def npresize_mask(mask,size=None,r=None):
+    '''
+    mask: [N,H,W]
+    size: (new_w,new_h)
+    '''
+    if mask.shape[0]==0:
+        return np.zeros([0,size[1],size[0]],dtype=mask.dtype)
+    new_mask = []
+    for i in range(mask.shape[0]):
+        cur_m = cv2.resize(mask[i],dsize=(size[0],size[1]),interpolation=cv2.INTER_NEAREST)
+        new_mask.append(cur_m)
+    new_mask = np.stack(new_mask,axis=0)
+    return new_mask
+
+def resize_mask_structures(mask,size):
+    '''
+    size:[W,H]
+    '''
+    if isinstance(mask,np.ndarray):
+        return npresize_mask(mask,size)
+    if torch.is_tensor(mask):
+        return resize_mask(mask,size)
+    if hasattr(mask,"resize"):
+        return mask.resize(size)
+    raise RuntimeError("Unimplement")

wml/semantic/semantic_test.py

@@ -0,0 +1,21 @@
+from wml.semantic.structures import *
+from wml.iotoolkit.labelme_toolkit import LabelMeData
+import wml.img_utils as wmli
+import wml.object_detection2.visualization as odv
+
+if __name__ == "__main__":
+    data = LabelMeData(use_polygon_mask=True)
+    data.read_data("~/ai/mldata1/B10CF/datasets/testv1.0/")
+    d = data[0]
+    mask = d[5]
+    crop_bbox = [1095,500,1235,600]
+    crop_bbox = [800,500,1235,600]
+    crop_bbox = [800,300,1235,600]
+    crop_bbox = [600,300,1600,600]
+    mask = mask.crop(crop_bbox)
+    img = wmli.imread(d[0])
+    img = wmli.crop_img_absolute_xy(img,crop_bbox)
+    img = odv.draw_maskv2(img,d[3],None,mask,is_relative_coordinate=False)
+    wmli.imwrite("tmp.jpg",img)
+
+    

wml/semantic/structures.py

@@ -0,0 +1 @@
+from wml.wstructures.mask_structures import WBaseMask, WBitmapMasks, WPolygonMaskItem, WPolygonMasks

wml/semantic/toolkit.py

@@ -0,0 +1,105 @@
+#coding=utf-8
+import sys
+import os
+from .mask_utils import np_iou
+import numpy as np
+from .visualization_utils import MIN_RANDOM_STANDARD_COLORS, draw_mask_on_image_array
+
+'''
+image:[height,width,3]
+mask:[height,width,N]
+colors:[N], string
+alpha:
+'''
+def np_draw_masks_on_image(image, mask, colors, alpha=0.4):
+    if image.dtype is not np.uint8:
+        image = image.astype(np.uint8)
+    if mask.dtype is not np.uint8:
+        mask = mask.astype(np.uint8)
+    mask = np.transpose(mask, axes=[2, 0, 1])
+    colors_nr = len(colors)
+
+    for i,msk in enumerate(mask):
+        image = draw_mask_on_image_array(image,msk,colors[i%colors_nr],alpha)
+
+    return image
+
+'''
+image:[batch_size,height,width,3]
+mask:[batch_size,height,width,N]
+alpha:
+'''
+def np_draw_masks_on_images(image,mask,alpha,colors=MIN_RANDOM_STANDARD_COLORS,no_first_mask=False):
+    if no_first_mask:
+        mask = mask[:,:,:,1:]
+    res_images = []
+
+    for img,msk in zip(image,mask):
+        new_img = np_draw_masks_on_image(image=img,mask=msk,colors=colors,alpha=alpha)
+        res_images.append(new_img)
+
+    return np.array(res_images)
+
+
+
+'''
+masks:[X,H,W]
+labels:[X]
+no_background: 如果为True, 那么labels的值域为[1,num_classes], 生成时labels转换为labels-1
+output:
+[num_classes,H,W]/[num_classes-1,H,W](no_background=True)
+'''
+def merge_masks(masks,labels,num_classes,size=None,no_background=False):
+    if size is not None:
+        width = size[1]
+        height = size[0]
+    elif len(masks.shape)>=3:
+        width = masks.shape[2]
+        height = masks.shape[1]
+
+    if no_background:
+        get_label = lambda x:max(0,x-1)
+        res = np.zeros([num_classes-1,height,width],dtype=np.int32)
+    else:
+        get_label = lambda x:x
+        res = np.zeros([num_classes,height,width],dtype=np.int32)
+
+    for i,mask in enumerate(masks):
+        label = get_label(labels[i])
+        res[label:label+1,:,:] = np.logical_or(res[label:label+1,:,:],np.expand_dims(mask,axis=0))
+
+    return res
+
+'''
+def get_fullsize_merged_mask(masks,bboxes,labels,size,num_classes,no_background=True):
+    fullsize_masks = ivs.get_fullsize_mask(bboxes,masks,size)
+    return merge_masks(fullsize_masks,labels,num_classes,size,no_background)
+'''
+
+class ModelPerformance:
+    def __init__(self,no_first_class=True):
+        self.test_nr = 0
+        self.total_iou = 0.
+        self.no_first_class = no_first_class
+
+
+    def clear(self):
+        self.test_nr = 0
+        self.total_iou = 0.
+
+    '''
+    mask_gt: [batch_size,h,w,num_classes]
+    mask_pred: [batch_size,h,w,num_classes]
+    background is [:,:,0]
+    '''
+    def __call__(self, mask_gt,mask_pred):
+        if self.no_first_class:
+            mask_gt = mask_gt[:,:,:,1:]
+            mask_pred = mask_pred[:,:,:,1:]
+        tmp_iou = np_iou(mask_gt,mask_pred)
+        self.total_iou += tmp_iou
+        self.test_nr += 1
+        return tmp_iou, self.mIOU()
+
+    def mIOU(self):
+        return self.total_iou/self.test_nr