Python np_box_mask_list.BoxMaskList方法代碼示例

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def box_list_to_box_mask_list(boxlist):
  """Converts a BoxList containing 'masks' into a BoxMaskList.

  Args:
    boxlist: An np_box_list.BoxList object.

  Returns:
    An np_box_mask_list.BoxMaskList object.

  Raises:
    ValueError: If boxlist does not contain `masks` as a field.
  """
  if not boxlist.has_field('masks'):
    raise ValueError('boxlist does not contain mask field.')
  box_mask_list = np_box_mask_list.BoxMaskList(
      box_data=boxlist.get(),
      mask_data=boxlist.get_field('masks'))
  extra_fields = boxlist.get_extra_fields()
  for key in extra_fields:
    if key != 'masks':
      box_mask_list.data[key] = boxlist.get_field(key)
  return box_mask_list 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def sort_by_field(box_mask_list, field,
                  order=np_box_list_ops.SortOrder.DESCEND):
  """Sort boxes and associated fields according to a scalar field.

  A common use case is reordering the boxes according to descending scores.

  Args:
    box_mask_list: BoxMaskList holding N boxes.
    field: A BoxMaskList field for sorting and reordering the BoxMaskList.
    order: (Optional) 'descend' or 'ascend'. Default is descend.

  Returns:
    sorted_box_mask_list: A sorted BoxMaskList with the field in the specified
      order.
  """
  return box_list_to_box_mask_list(
      np_box_list_ops.sort_by_field(
          boxlist=box_mask_list, field=field, order=order)) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def prune_non_overlapping_masks(box_mask_list1, box_mask_list2, minoverlap=0.0):
  """Prunes the boxes in list1 that overlap less than thresh with list2.

  For each mask in box_mask_list1, we want its IOA to be more than minoverlap
  with at least one of the masks in box_mask_list2. If it does not, we remove
  it. If the masks are not full size image, we do the pruning based on boxes.

  Args:
    box_mask_list1: np_box_mask_list.BoxMaskList holding N boxes and masks.
    box_mask_list2: np_box_mask_list.BoxMaskList holding M boxes and masks.
    minoverlap: Minimum required overlap between boxes, to count them as
                overlapping.

  Returns:
    A pruned box_mask_list with size [N', 4].
  """
  intersection_over_area = ioa(box_mask_list2, box_mask_list1)  # [M, N] tensor
  intersection_over_area = np.amax(intersection_over_area, axis=0)  # [N] tensor
  keep_bool = np.greater_equal(intersection_over_area, np.array(minoverlap))
  keep_inds = np.nonzero(keep_bool)[0]
  new_box_mask_list1 = gather(box_mask_list1, keep_inds)
  return new_box_mask_list1 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_invalid_box_mask_data(self):
    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=[0, 0, 1, 1],
          mask_data=np.zeros([1, 3, 3], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([[0, 0, 1, 1]], dtype=int),
          mask_data=np.zeros([1, 3, 3], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([0, 1, 1, 3, 4], dtype=float),
          mask_data=np.zeros([1, 3, 3], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([[0, 1, 1, 3], [3, 1, 1, 5]], dtype=float),
          mask_data=np.zeros([2, 3, 3], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([[0, 1, 1, 3], [1, 1, 1, 5]], dtype=float),
          mask_data=np.zeros([3, 5, 5], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([[0, 1, 1, 3], [1, 1, 1, 5]], dtype=float),
          mask_data=np.zeros([2, 5], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([[0, 1, 1, 3], [1, 1, 1, 5]], dtype=float),
          mask_data=np.zeros([2, 5, 5, 5], dtype=np.uint8))

    with self.assertRaises(ValueError):
      np_box_mask_list.BoxMaskList(
          box_data=np.array([[0, 1, 1, 3], [1, 1, 1, 5]], dtype=float),
          mask_data=np.zeros([2, 5, 5], dtype=np.int32)) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_has_field_with_existed_field(self):
    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
                      [0.0, 0.0, 20.0, 20.0]],
                     dtype=float)
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=boxes, mask_data=np.zeros([3, 5, 5], dtype=np.uint8))
    self.assertTrue(box_mask_list.has_field('boxes'))
    self.assertTrue(box_mask_list.has_field('masks')) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_has_field_with_nonexisted_field(self):
    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
                      [0.0, 0.0, 20.0, 20.0]],
                     dtype=float)
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=boxes, mask_data=np.zeros([3, 3, 3], dtype=np.uint8))
    self.assertFalse(box_mask_list.has_field('scores')) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_get_field_with_existed_field(self):
    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
                      [0.0, 0.0, 20.0, 20.0]],
                     dtype=float)
    masks = np.zeros([3, 3, 3], dtype=np.uint8)
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=boxes, mask_data=masks)
    self.assertTrue(np.allclose(box_mask_list.get_field('boxes'), boxes))
    self.assertTrue(np.allclose(box_mask_list.get_field('masks'), masks)) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_get_field_with_nonexited_field(self):
    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
                      [0.0, 0.0, 20.0, 20.0]],
                     dtype=float)
    masks = np.zeros([3, 3, 3], dtype=np.uint8)
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=boxes, mask_data=masks)
    with self.assertRaises(ValueError):
      box_mask_list.get_field('scores') 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_num_boxes(self):
    boxes = np.array([[0., 0., 100., 100.], [10., 30., 50., 70.]], dtype=float)
    masks = np.zeros([2, 5, 5], dtype=np.uint8)
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=boxes, mask_data=masks)
    expected_num_boxes = 2
    self.assertEquals(box_mask_list.num_boxes(), expected_num_boxes) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_with_no_scores_field(self):
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=self.boxes1, mask_data=self.masks1)
    max_output_size = 3
    iou_threshold = 0.5

    with self.assertRaises(ValueError):
      np_box_mask_list_ops.non_max_suppression(
          box_mask_list, max_output_size, iou_threshold) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def test_nms_disabled_max_output_size_equals_one(self):
    box_mask_list = np_box_mask_list.BoxMaskList(
        box_data=self.boxes2, mask_data=self.masks2)
    box_mask_list.add_field('scores',
                            np.array([.9, .75, .6], dtype=float))
    max_output_size = 1
    iou_threshold = 1.  # No NMS
    expected_boxes = np.array([[3.0, 4.0, 6.0, 8.0]], dtype=float)
    expected_masks = np.array(
        [[[0, 1, 0], [1, 1, 1], [0, 0, 0]]], dtype=np.uint8)
    nms_box_mask_list = np_box_mask_list_ops.non_max_suppression(
        box_mask_list, max_output_size, iou_threshold)
    self.assertAllClose(nms_box_mask_list.get(), expected_boxes)
    self.assertAllClose(nms_box_mask_list.get_masks(), expected_masks) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def area(box_mask_list):
  """Computes area of masks.

  Args:
    box_mask_list: np_box_mask_list.BoxMaskList holding N boxes and masks

  Returns:
    a numpy array with shape [N*1] representing mask areas
  """
  return np_mask_ops.area(box_mask_list.get_masks()) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def intersection(box_mask_list1, box_mask_list2):
  """Compute pairwise intersection areas between masks.

  Args:
    box_mask_list1: BoxMaskList holding N boxes and masks
    box_mask_list2: BoxMaskList holding M boxes and masks

  Returns:
    a numpy array with shape [N*M] representing pairwise intersection area
  """
  return np_mask_ops.intersection(box_mask_list1.get_masks(),
                                  box_mask_list2.get_masks()) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def iou(box_mask_list1, box_mask_list2):
  """Computes pairwise intersection-over-union between box and mask collections.

  Args:
    box_mask_list1: BoxMaskList holding N boxes and masks
    box_mask_list2: BoxMaskList holding M boxes and masks

  Returns:
    a numpy array with shape [N, M] representing pairwise iou scores.
  """
  return np_mask_ops.iou(box_mask_list1.get_masks(),
                         box_mask_list2.get_masks()) 

# 需要導入模塊: from object_detection.utils import np_box_mask_list [as 別名]
# 或者: from object_detection.utils.np_box_mask_list import BoxMaskList [as 別名]
def gather(box_mask_list, indices, fields=None):
  """Gather boxes from np_box_mask_list.BoxMaskList according to indices.

  By default, gather returns boxes corresponding to the input index list, as
  well as all additional fields stored in the box_mask_list (indexing into the
  first dimension).  However one can optionally only gather from a
  subset of fields.

  Args:
    box_mask_list: np_box_mask_list.BoxMaskList holding N boxes
    indices: a 1-d numpy array of type int_
    fields: (optional) list of fields to also gather from.  If None (default),
        all fields are gathered from.  Pass an empty fields list to only gather
        the box coordinates.

  Returns:
    subbox_mask_list: a np_box_mask_list.BoxMaskList corresponding to the subset
        of the input box_mask_list specified by indices

  Raises:
    ValueError: if specified field is not contained in box_mask_list or if the
        indices are not of type int_
  """
  if fields is not None:
    if 'masks' not in fields:
      fields.append('masks')
  return box_list_to_box_mask_list(
      np_box_list_ops.gather(
          boxlist=box_mask_list, indices=indices, fields=fields))