python-wml 3.0.0__py3-none-any.whl

wml/object_detection2/npod_toolkit.py

@@ -0,0 +1,361 @@
+#coding=utf-8
+import numpy as np
+import math
+
+'''
+bboxes:[X,4], ymin,xmin,ymax,xmax, relative coordinate
+'''
+def bboxes_jaccard(bboxes1, bboxes2):
+
+    bboxes1 = np.transpose(bboxes1)
+    bboxes2 = np.transpose(bboxes2)
+
+    int_ymin = np.maximum(bboxes1[0], bboxes2[0])
+    int_xmin = np.maximum(bboxes1[1], bboxes2[1])
+    int_ymax = np.minimum(bboxes1[2], bboxes2[2])
+    int_xmax = np.minimum(bboxes1[3], bboxes2[3])
+
+    int_h = np.maximum(int_ymax - int_ymin, 0.)
+    int_w = np.maximum(int_xmax - int_xmin, 0.)
+    int_vol = int_h * int_w
+
+    vol1 = (bboxes1[2] - bboxes1[0]) * (bboxes1[3] - bboxes1[1])
+    vol2 = (bboxes2[2] - bboxes2[0]) * (bboxes2[3] - bboxes2[1])
+    jaccard = int_vol / (vol1 + vol2 - int_vol)
+    return jaccard
+'''
+box0,box1: ymin,xmin,ymax,xmax
+'''
+def box_jaccard(box0,box1):
+    ymin0, xmin0, ymax0, xmax0 = box0[0],box0[1],box0[2],box0[3]
+    ymin1, xmin1, ymax1, xmax1 = box1[0],box1[1],box1[2],box1[3]
+    int_ymin = max(ymin0,ymin1)
+    int_xmin = max(xmin0,xmin1)
+    int_ymax = min(ymax0,ymax1)
+    int_xmax = min(xmax0,xmax1)
+    int_w = max(int_xmax-int_xmin,0.)
+    int_h = max(int_ymax-int_ymin,0.)
+    int_vol = int_w*int_h
+    union_box_vol = box_vol(box0)+box_vol(box1)-int_vol
+
+    if union_box_vol < 1e-8:
+        return 0.0
+    return int_vol/union_box_vol
+'''
+get the unio volume over bboxes's volume.
+bboxes_ref:[4] ymin,xmin,ymax,xmax, relative coordinate
+bboxes2:[X,4], ymin,xmin,ymax,xmax, relative coordinate
+'''
+def bboxes_intersection(bboxes_ref, bboxes):
+
+    bboxes_ref = np.transpose(bboxes_ref)
+    bboxes = np.transpose(bboxes)
+    # Intersection bbox and volume.
+    int_ymin = np.maximum(bboxes_ref[0], bboxes[0])
+    int_xmin = np.maximum(bboxes_ref[1], bboxes[1])
+    int_ymax = np.minimum(bboxes_ref[2], bboxes[2])
+    int_xmax = np.minimum(bboxes_ref[3], bboxes[3])
+
+    int_h = np.maximum(int_ymax - int_ymin, 0.)
+    int_w = np.maximum(int_xmax - int_xmin, 0.)
+    int_vol = int_h * int_w
+    # Union volume.
+    vol = (bboxes[2] - bboxes[0]) * (bboxes[3] - bboxes[1])
+    score = int_vol / vol
+    return score
+
+'''
+get the unio volume over bboxes_ref's volume.
+bboxes_ref:[4] ymin,xmin,ymax,xmax, relative coordinate
+bboxes2:[X,4], ymin,xmin,ymax,xmax, relative coordinate
+'''
+def bboxes_intersection_r(bboxes_ref, bboxes):
+    if bboxes.shape[0] == 0 or bboxes_ref.shape[0] == 0:
+        return np.array([],dtype=np.float32)
+
+    bboxes = np.transpose(bboxes)
+    # Intersection bbox and volume.
+    int_ymin = np.maximum([bboxes_ref[0]], bboxes[0])
+    int_xmin = np.maximum([bboxes_ref[1]], bboxes[1])
+    int_ymax = np.minimum([bboxes_ref[2]], bboxes[2])
+    int_xmax = np.minimum([bboxes_ref[3]], bboxes[3])
+
+    int_h = np.maximum(int_ymax - int_ymin, 0.)
+    int_w = np.maximum(int_xmax - int_xmin, 0.)
+    int_vol = int_h * int_w
+    # Union volume.
+    vol = (bboxes_ref[2] - bboxes_ref[0]) * (bboxes_ref[3] - bboxes_ref[1])
+    score = int_vol / vol
+    return score
+
+'''
+classes wise nms implementation by numpy.
+classes:[X]
+scores:[X]
+bboxes:[X,4]
+'''
+def bboxes_nms(classes, scores, bboxes, nms_threshold=0.5):
+
+    keep_bboxes = np.ones(scores.shape, dtype=np.bool)
+    for i in range(scores.size-1):
+        if keep_bboxes[i]:
+            # Computer overlap with bboxes which are following.
+            overlap = bboxes_jaccard(bboxes[i], bboxes[(i+1):])
+            # Overlap threshold for keeping + checking part of the same class
+            keep_overlap = np.logical_or(overlap < nms_threshold, classes[(i+1):] != classes[i])
+            keep_bboxes[(i+1):] = np.logical_and(keep_bboxes[(i+1):], keep_overlap)
+
+    idxes = np.where(keep_bboxes)
+    return classes[idxes], scores[idxes], bboxes[idxes]
+
+'''
+crop a sub area sub_box in image, return the boxes IOU with sub_box greater than remove_threshold
+bboxes:[X,4] ymin,xmin,ymax,xmax, relative coordinate
+return:
+bboxes:[Y,4],mask [X]
+'''
+def crop_box(bboxes,sub_box,remove_threshold=0.7):
+    h = sub_box[2]-sub_box[0]
+    w = sub_box[3]-sub_box[1]
+    if h<1e-8 or w<1e-8:
+        return None
+    if not isinstance(bboxes,np.ndarray):
+        bboxes = np.array(bboxes)
+    jaccard = bboxes_intersection(bboxes_ref=sub_box,bboxes=bboxes)
+    mask = jaccard>remove_threshold
+    bboxes = bboxes[mask]
+    if bboxes.shape[0] == 0:
+        return bboxes,mask
+    top_left = np.array([[sub_box[0],sub_box[1],sub_box[0],sub_box[1]]],dtype=np.float32)
+    bboxes = (bboxes-top_left)/np.array([[h,w,h,w]],dtype=np.float32)
+    bboxes = correct_boxes(bboxes)
+    return bboxes,mask
+
+'''
+bboxes:[X,4], ymin,xmin,ymax,xmax releative coordinate.
+'''
+def correct_boxes(bboxes):
+    bboxes = np.transpose(bboxes,[1,0])
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    ymin = np.maximum(ymin,0.)
+    ymax = np.minimum(ymax,1.)
+    xmin = np.maximum(xmin,0.)
+    xmax = np.minimum(xmax,1.)
+    bboxes = np.stack([ymin,xmin,ymax,xmax],axis=0)
+    bboxes = np.transpose(bboxes)
+    return bboxes
+
+def box_vol(box):
+    return (box[2]-box[0])*(box[3]-box[1])
+'''
+box0,box1: shape=[4] ymin,xmin,ymax,xmax
+交叉面积占box0的百分比
+'''
+def bbox_intersection(box0,box1):
+    ymin0, xmin0, ymax0, xmax0 = box0[0],box0[1],box0[2],box0[3]
+    ymin1, xmin1, ymax1, xmax1 = box1[0],box1[1],box1[2],box1[3]
+    int_ymin = max(ymin0,ymin1)
+    int_xmin = max(xmin0,xmin1)
+    int_ymax = min(ymax0,ymax1)
+    int_xmax = min(xmax0,xmax1)
+    int_w = max(int_xmax-int_xmin,0.)
+    int_h = max(int_ymax-int_ymin,0.)
+    int_vol = int_w*int_h
+    box0_vol  = box_vol(box0)
+
+    if box0_vol < 1e-8:
+        return 0.0
+    return int_vol/box0_vol
+
+'''
+删除与边界nms大于指定值的box
+boundary:[h,w]
+'''
+def remove_boundary_boxes(bboxes,boundary=[0.1,0.1],threshold=0.9):
+    assert len(bboxes.shape)==2,"error bboxes shape"
+    boxes_nr = bboxes.shape[0]
+    boundary_w = boundary[1]
+    boundary_h = boundary[0]
+    if boxes_nr == 0:
+        return bboxes,np.array([],dtype=np.bool)
+    keep_indicts = np.ones(shape=[boxes_nr],dtype=np.bool)
+    boundary_boxes = np.array([[0.0,0.0,1.0,boundary_w],
+                               [0.0, 1-boundary_w, 1.0, 1.0],
+                              [0.0,0.0,boundary_h,1.0],
+                               [1.0-boundary_h, 0.0, 1.0, 1.0]],dtype=np.float32)
+
+    for i in range(boxes_nr):
+        for j in range(boundary_boxes.shape[0]):
+            if bbox_intersection(bboxes[i],boundary_boxes[j]) > threshold:
+                keep_indicts[i] = False
+                break
+
+    return bboxes[keep_indicts],keep_indicts
+'''
+box：[x,4] 使用相对坐标表示，其参考区域为sub_box
+sub_box: [ymin,xmin,ymax,xmax] 可使用相对坐标或绝对坐标，返回的box表示与sub_box相同
+函数返回box在[0,0,1,1]区域的表示值
+'''
+def restore_sub_area(bboxes,sub_box):
+    h = sub_box[2]-sub_box[0]
+    w = sub_box[3]-sub_box[1]
+    bboxes = np.transpose(bboxes,[1,0])
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    ymin = ymin*h+sub_box[0]
+    ymax = ymax*h+sub_box[0]
+    xmin = xmin*w+sub_box[1]
+    xmax = xmax*w+sub_box[1]
+    bboxes = np.stack([ymin,xmin,ymax,xmax],axis=0)
+    bboxes = np.transpose(bboxes)
+    return bboxes
+
+def bboxes_flip_left_right(bboxes):
+    bboxes = np.transpose(bboxes)
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    nxmax = 1.0-xmin
+    nxmin = 1.0-xmax
+    bboxes = np.stack([ymin,nxmin,ymax,nxmax],axis=0)
+    bboxes = np.transpose(bboxes)
+    return bboxes
+
+def bboxes_flip_up_down(bboxes):
+    bboxes = np.transpose(bboxes)
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    nymax = 1.0-ymin
+    nymin = 1.0- ymax
+    bboxes = np.stack([nymin,xmin,nymax,xmax],axis=0)
+    bboxes = np.transpose(bboxes)
+    return bboxes
+
+'''
+get a envolope box of boxes.
+bboxes:[X,4]
+'''
+def envolope_of_boxes(bboxes):
+    if bboxes.shape[0]==0:
+        return np.array([0.,0.,1.,1.],dtype=np.float32)
+    bboxes = np.transpose(bboxes,[1,0])
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    ymin = ymin.min()
+    xmin = xmin.min()
+    ymax = ymax.max()
+    xmax = xmax.max()
+
+    return np.array([ymin,xmin,ymax,xmax])
+
+def minmax_to_cyxhw(bboxes):
+    bboxes = np.transpose(bboxes,[1,0])
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    cx = (xmax+xmin)/2.
+    cy = (ymax+ymin)/2.
+    w = (xmax-xmin)
+    h = (ymax-ymin)
+    bboxes = np.stack([cy,cx,h,w],axis=0)
+    bboxes = np.transpose(bboxes,axes=[1,0])
+    return bboxes
+
+def minmax_to_cyxsr(bboxes,h=1.0,w=1.0):
+    bboxes = np.transpose(bboxes,[1,0])
+    ymin,xmin,ymax,xmax = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    cx = (xmax+xmin)/2.
+    cy = (ymax+ymin)/2.
+    w = (xmax-xmin)*w
+    h = (ymax-ymin)*h
+    s = w*h
+    r = h/w
+    bboxes = np.stack([cy,cx,s,r],axis=0)
+    bboxes = np.transpose(bboxes,axes=[1,0])
+    return bboxes
+
+def cyxhw_to_minmax(bboxes):
+    bboxes = np.transpose(bboxes,[1,0])
+    cy, cx, h, w = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    ymin = cy-h/2.
+    ymax = cy+h/2.
+    xmin = cx-w/2.
+    xmax = cx+w/2.
+    bboxes = np.stack([ymin,xmin,ymax,xmax],axis=0)
+    bboxes = np.transpose(bboxes)
+    return bboxes
+'''
+return the distance of two boxes's center point.
+'''
+def box_dis(box0,box1):
+    box0 = minmax_to_cyxhw([box0])
+    box1 = minmax_to_cyxhw([box1])
+
+    dy = box0[0][0]-box1[0][0]
+    dx = box0[0][1]-box1[0][1]
+    return math.sqrt(dy*dy+dx*dx)
+'''
+return the aspect(h/w) of a box.
+'''
+def box_aspect(boxes):
+    bboxes = minmax_to_cyxhw(boxes)
+    bboxes = np.transpose(bboxes,[1,0])
+    cy, cx, h, w = bboxes[0],bboxes[1],bboxes[2],bboxes[3]
+    aspect = h/w
+    return aspect
+
+def bboxes_decode(feat_localizations,
+                      anchor_bboxes,
+                      prior_scaling=[0.1, 0.1, 0.2, 0.2]):
+
+    l_shape = feat_localizations.shape
+    feat_localizations = np.reshape(feat_localizations,
+                                    (-1, l_shape[-2], l_shape[-1]))
+    yref, xref, href, wref = anchor_bboxes
+    xref = np.reshape(xref, [-1, 1])
+    yref = np.reshape(yref, [-1, 1])
+
+    cx = feat_localizations[:, :, 0] * wref * prior_scaling[0] + xref
+    cy = feat_localizations[:, :, 1] * href * prior_scaling[1] + yref
+    w = wref * np.exp(feat_localizations[:, :, 2] * prior_scaling[2])
+    h = href * np.exp(feat_localizations[:, :, 3] * prior_scaling[3])
+    # bboxes: ymin, xmin, xmax, ymax.
+    bboxes = np.zeros_like(feat_localizations)
+    bboxes[:, :, 0] = cy - h / 2.
+    bboxes[:, :, 1] = cx - w / 2.
+    bboxes[:, :, 2] = cy + h / 2.
+    bboxes[:, :, 3] = cx + w / 2.
+    bboxes = np.reshape(bboxes, l_shape)
+    return bboxes
+
+def bboxes_selectv2(predictions_layer,
+                            localizations_layer,
+                            select_threshold=0.5):
+
+    p_shape = predictions_layer.shape
+    batch_size = p_shape[0] if len(p_shape) == 5 else 1
+    predictions_layer = np.reshape(predictions_layer,
+                                   (batch_size, -1, p_shape[-1]))
+    l_shape = localizations_layer.shape
+    localizations_layer = np.reshape(localizations_layer,
+                                     (batch_size, -1, l_shape[-1]))
+
+    sub_predictions = predictions_layer[:, :, 1:]
+    idxes = np.where(sub_predictions > select_threshold)
+    classes = idxes[-1] + 1
+    scores = sub_predictions[idxes]
+    bboxes = localizations_layer[idxes[:-1]]
+
+    return classes, scores, bboxes
+
+def bboxes_sort(classes, scores, bboxes, top_k=400):
+    idxes = np.argsort(-scores)
+    classes = classes[idxes][:top_k]
+    scores = scores[idxes][:top_k]
+    bboxes = bboxes[idxes][:top_k]
+    return classes, scores, bboxes
+
+def bboxes_filter(bboxes,labels, probs,threshold=0.5):
+
+    keep_bboxes = np.greater_equal(probs,threshold)
+    idxes = np.where(keep_bboxes)
+    if not isinstance(bboxes,np.ndarray):
+        bboxes = np.array(bboxes)
+    if not isinstance(labels,np.ndarray):
+        labels = np.array(labels)
+    if not isinstance(probs,np.ndarray):
+        probs = np.array(probs)
+    return bboxes[idxes],labels[idxes],probs[idxes],idxes

wml/object_detection2/odtools.py

@@ -0,0 +1,243 @@
+#coding=utf-8
+import numpy as np
+import wml.object_detection2.bboxes as odb
+import wml.img_utils as wmli
+import copy
+from .mask import get_bboxes_by_mask
+from itertools import count
+
+
+'''
+image_data:[h,w,c]
+bboxes:[N,4] absolute coordinate
+rect:[ymin,xmin,ymax,xmax) absolute coordinate
+'''
+def cut_bboxes(bboxes,labels,img,rect,threshold=0.5,fill_color=None,is_sub_img=False):
+    res_bboxes = []
+    res_labels = []
+
+    if not isinstance(labels,np.ndarray):
+        labels = np.array(labels)
+
+    remove_bboxes = []
+    no_zero = 1e-3
+    for i in range(labels.shape[0]):
+        iou = odb.npbboxes_intersection_of_box0([bboxes[i]],rect)
+        if iou<threshold and iou>no_zero:
+            remove_bboxes.append(bboxes[i])
+        elif iou>=threshold:
+            res_bboxes.append(bboxes[i])
+            res_labels.append(labels[i])
+
+    if not is_sub_img:
+        img = wmli.sub_image(img,rect)
+
+    if fill_color is not None and len(remove_bboxes)>0:
+        remove_bboxes = np.stack(remove_bboxes, axis=0) - np.array([[rect[0], rect[1], rect[0], rect[1]]])
+        remove_bboxes = remove_bboxes.astype(np.int32)
+        img = wmli.remove_boxes_of_img(img,remove_bboxes,default_value=fill_color)
+
+    if len(res_labels)>0:
+        res_bboxes = np.stack(res_bboxes,axis=0) - np.array([[rect[0],rect[1],rect[0],rect[1]]])
+        res_labels = np.array(res_labels)
+    else:
+        res_bboxes = np.zeros(shape=[0,4],dtype=bboxes.dtype)
+        res_labels = np.zeros(shape=[0],dtype=labels.dtype)
+
+    return res_bboxes,res_labels,img
+
+'''
+在每一个标目标附近裁剪出一个子图
+bboxes: [N,4] absolute coordinate
+size:[H,W]
+return:
+[N,4] (ymin,xmin,ymax,xmax) absolute coordinate
+'''
+def get_random_cut_bboxes_rect(bboxes,size,img_size):
+    res = []
+    y_max,x_max = img_size[0],img_size[1]
+    if not isinstance(bboxes,np.ndarray):
+        bboxes = np.array(bboxes)
+    if bboxes.shape[0] == 0:
+        return []
+    obj_ann_bboxes = odb.expand_bbox_by_size(bboxes,[x//2 for x in size],format='yxminmax')
+    obj_ann_bboxes = odb.to_xyminwh(obj_ann_bboxes)
+
+
+    for t_bbox in obj_ann_bboxes:
+        t_bbox = list(t_bbox)
+        t_bbox[1] = max(0,min(t_bbox[1],y_max))
+        t_bbox[0] = max(0,min(t_bbox[0],x_max))
+        t_bbox = odb.random_bbox_in_bbox(t_bbox,size)
+        rect = (t_bbox[1],t_bbox[0],t_bbox[1]+t_bbox[3],t_bbox[0]+t_bbox[2])
+
+        res.append(rect)
+    return res
+
+'''
+在每一个标目标附近裁剪出一个子图, 如果一个bbox已经出现在前面的某一个rect中则跳过
+用于保证一个instance仅在结果中出现一次
+bboxes: [N,4] absolute coordinate
+size:[H,W]
+return:
+[N,4] (ymin,xmin,ymax,xmax) absolute coordinate
+'''
+def get_random_cut_bboxes_rectv2(bboxes,size,img_size,labels=None,force_cut_labels=None):
+    res = []
+    y_max,x_max = img_size[0],img_size[1]
+    if not isinstance(bboxes,np.ndarray):
+        bboxes = np.array(bboxes)
+    if bboxes.shape[0] == 0:
+        return []
+    obj_ann_bboxes = odb.expand_bbox_by_size(bboxes,[x//2 for x in size],format='yxminmax')
+    obj_ann_bboxes = odb.to_xyminwh(obj_ann_bboxes)
+
+
+    for i,t_bbox in enumerate(obj_ann_bboxes):
+        bbox = bboxes[i]
+        if len(res)>0:
+            if labels is None or (labels[i] not in force_cut_labels):
+                ious = odb.npbboxes_intersection_of_box0(bbox,res)
+                max_index = np.argmax(ious)
+                if ious[max_index]>0.9:
+                    continue
+        t_bbox = list(t_bbox)
+        t_bbox[1] = max(0,min(t_bbox[1],y_max))
+        t_bbox[0] = max(0,min(t_bbox[0],x_max))
+        t_bbox = odb.random_bbox_in_bbox(t_bbox,size)
+        rect = (t_bbox[1],t_bbox[0],t_bbox[1]+t_bbox[3],t_bbox[0]+t_bbox[2])
+
+        res.append(rect)
+    return res
+
+def filter_by_classeswise_thresholds(labels,bboxes,probs,thresholds):
+    '''
+
+    :param labels: [N]
+    :param bboxes: [N,4]
+    :param probs: [N]
+    :param thresholds: 不包含背景0
+    :return:
+    '''
+    n_labels = []
+    n_bboxes = []
+    n_probs = []
+
+    for i,l in enumerate(labels):
+        tp = thresholds[l-1]
+        p = probs[i]
+        if tp<=p:
+            n_labels.append(l)
+            n_bboxes.append(bboxes[i])
+            n_probs.append(p)
+
+    return np.array(n_labels),np.array(n_bboxes),np.array(n_probs)
+
+class WCrop:
+    '''
+    '''
+
+    def __init__(self,
+                 img_pad_value=127,
+                 mask_pad_value=0,
+                 bbox_keep_ratio=0.2,
+                 mask_domina=True):
+                 
+        self.img_pad_value = img_pad_value
+        self.mask_pad_value = mask_pad_value
+        self.bbox_keep_ratio = bbox_keep_ratio
+        self.mask_domina = mask_domina
+
+    def apply(self, results,crop_bbox):
+        """Random crop and around padding the original image.
+
+        Args:
+            results (dict): Image infomations in the augment pipeline.
+
+        Returns:
+            results (dict): The updated dict.
+        """
+        img = results['img']
+        patch = crop_bbox
+        try:
+            cropped_img = wmli.crop_and_pad(img, patch,pad_color=self.img_pad_value)
+        except:
+            print("Crop error:",patch)
+
+        x_offset = patch[0]
+        y_offset = patch[1]
+        new_w = patch[2]-x_offset
+        new_h = patch[3]-y_offset
+        results['img'] = cropped_img
+        results['img_shape'] = cropped_img.shape
+        results['pad_shape'] = cropped_img.shape
+
+        # crop bboxes accordingly and clip to the image boundary
+        for key in results.get('bbox_fields', ['gt_bboxes']):
+            bboxes = results[key]
+            old_bboxes = copy.deepcopy(bboxes)
+            old_area = odb.area(old_bboxes)
+            bboxes[:, 0:4:2] -= x_offset
+            bboxes[:, 1:4:2] -= y_offset
+            bboxes[:, 0:4:2] = np.clip(bboxes[:, 0:4:2], 0, new_w)
+            bboxes[:, 1:4:2] = np.clip(bboxes[:, 1:4:2], 0, new_h)
+            keep0 = (bboxes[:, 2] > bboxes[:, 0]) & (
+                bboxes[:, 3] > bboxes[:, 1])
+            new_area = odb.area(bboxes)
+            area_ratio = new_area/(old_area+1e-6)
+            keep1 = area_ratio>self.bbox_keep_ratio
+            keep = np.logical_and(keep0,keep1)
+            bboxes = bboxes[keep]
+            results[key] = bboxes
+            if key in ['gt_bboxes']:
+                if 'gt_labels' in results:
+                    labels = results['gt_labels']
+                    labels = labels[keep]
+                    results['gt_labels'] = labels
+                if 'gt_masks' in results:
+                    gt_masks = results['gt_masks']
+                    gt_masks = gt_masks[keep]
+                    gt_masks = wmli.crop_masks_absolute_xy(gt_masks,patch)
+                    results['gt_masks'] = gt_masks
+
+                    if self.mask_domina:
+                        old_area = old_area[keep]
+                        bboxes = get_bboxes_by_mask(gt_masks)
+                        new_area = odb.area(bboxes)
+                        area_ratio = new_area/(old_area+1e-6)
+                        keep = area_ratio>self.bbox_keep_ratio
+                        bboxes = bboxes[keep]
+                        results[key] = bboxes
+                        if 'gt_labels' in results:
+                            labels = results['gt_labels']
+                            labels = labels[keep]
+                            results['gt_labels'] = labels
+                        gt_masks = gt_masks[keep]
+                        results['gt_masks'] = gt_masks
+
+            return results
+
+    def __call__(self, results,crop_bbox):
+        return self.apply(results,crop_bbox)
+
+
+def make_text2label(classes=None,label_text2id={}):
+    res = {}
+    if classes is not None:
+        tmp_d = dict(zip(classes,count()))
+        res.update(tmp_d)
+    
+    if label_text2id is not None:
+        for k,v in label_text2id.items():
+            if isinstance(v,(str,bytes)) and v in res:
+                res[k] = res[v]
+            else:
+                res[k] = v
+    
+    for k,v in list(res.items()):
+        if isinstance(v,(str,bytes)) and v in res:
+            res[k] = res[v]
+    
+    return res
+
+

wml/object_detection2/standard_names.py

@@ -0,0 +1,75 @@
+#coding=utf-8
+SCORES = "scores"
+INDICES = "indices"
+BOXES = "boxes"
+LABELS = "labels"
+PROBABILITY = "probability"
+RAW_PROBABILITY = "raw_probability"
+IMAGE = 'img'
+HEIGHT = "height"
+WIDTH = "width"
+MASKS = "masks"
+ANN_INFO = "ann_info"
+IMG_INFO = "img_info"
+IS_CROWD = 'is_crowd'
+MASK_AREA = "mask_area"
+ORG_HEIGHT = "org_height"
+ORG_WIDTH = "org_width"
+LOGITS = "logits"
+BOXES_REGS = "box_regs"
+SEMANTIC = "semantic"
+COEFFICIENT = "coefficient"
+IMG_METAS = "img_metas"
+PROPOSAL_BBOXES = "proposal_bboxes"
+SAMPLED_BBOXES = "sampled_bboxes"
+
+GT_BOXES = 'gt_bboxes'
+GT_LENGTH = 'gt_length'
+GT_LABELS = 'gt_labels'
+IMG_INDEX = 'idata_index'
+GT_MASKS = 'gt_masks'
+GT_KEYPOINTS = 'gt_keypoints'
+GT_SEMANTIC_LABELS = 'gt_semantic_mask_labels'
+GT_SEG_MAP = 'gt_seg_map'
+GT_SEM_SEG = 'gt_sem_seg'
+GT_SEMANTIC_SEG = 'gt_semantic_seg'
+FILEINDEX = "fileindex"
+FILENAME = "filename"
+FILEPATH = "filepath"
+GT_OBJECT_LOGITS = "gt_object_logits"
+
+BBOX_FIELDS = "bbox_fields"
+#Encoded data
+ED_GT_OBJECT_LOGITS = "gt_object_logits"
+ED_SCORES = "scores"
+ED_INDICES = "indices"
+ED_BOXES = "boxes"
+ED_GT_BOXES = GT_BOXES
+ED_GT_LABELS = GT_LABELS
+ED_GT_DELTAS = "deltas"
+ED_GT_DELTAS = "deltas"
+
+#Results Data
+RD_BOXES = BOXES
+RD_BOXES_ABSOLUTE = BOXES+"_absolute"
+RD_LABELS = LABELS
+RD_PROBABILITY = PROBABILITY
+RD_RAW_PROBABILITY = RAW_PROBABILITY
+RD_INDICES = INDICES
+RD_LENGTH = "length"
+RD_MASKS = "masks"  #标准格式为[batch_size,N,h,w]
+RD_SEMANTIC = "semantic"  #标准格式为[batch_size,N,h,w]
+RD_SPARSE_SEMANTIC = "sparse_semantic"  #标准格式为[batch_size,N,h,w]
+RD_FULL_SIZE_MASKS = "full_size_masks"  #标准格式为[batch_size,N,H,W]
+RD_RESULT_IMAGE = "result_image"
+RD_KEYPOINT = "keypoint"
+RD_MASK_AREA = MASK_AREA
+RD_ID = "rd_id"
+
+#Proposal network't result
+PD_BOXES = "boxes"
+PD_PROBABILITY = PROBABILITY
+
+
+GRADIENT_DEBUG_COLLECTION = "gradient_debug_collection"
+