def test_prune_non_overlapping_boxes(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2], [0.0, 0.0, 20.0, 20.0, 0.3]]) boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) minoverlap = 0.5 exp_output_1 = boxes1 exp_output_2 = rbox_list.RBoxList(rbox2[:1]) output_1, keep_indices_1 = rbox_list_ops.prune_non_overlapping_boxes( boxes1, boxes2, min_overlap=minoverlap) output_2, keep_indices_2 = rbox_list_ops.prune_non_overlapping_boxes( boxes2, boxes1, min_overlap=minoverlap) with self.test_session() as sess: (output_1_, keep_indices_1_, output_2_, keep_indices_2_, exp_output_1_, exp_output_2_) = sess.run([ output_1.get(), keep_indices_1, output_2.get(), keep_indices_2, exp_output_1.get(), exp_output_2.get() ]) self.assertAllClose(output_1_, exp_output_1_) self.assertAllClose(output_2_, exp_output_2_) self.assertAllEqual(keep_indices_1_, [0, 1]) self.assertAllEqual(keep_indices_2_, [0])
def test_concatenate_with_missing_fields(self): corners1 = tf.constant([[0, 0, 0, 0, 0], [1, 2, 3, 4, 5]], tf.float32) scores1 = tf.constant([1.0, 2.1]) corners2 = tf.constant([[0, 3, 1, 6, 7], [2, 4, 3, 8, 9]], tf.float32) boxlist1 = rbox_list.RBoxList(corners1) boxlist1.add_field('scores', scores1) boxlist2 = rbox_list.RBoxList(corners2) with self.assertRaises(ValueError): rbox_list_ops.concatenate([boxlist1, boxlist2])
def test_batch_assign_multidimensional_targets_rbox(self): rbox_list1 = rbox_list.RBoxList(tf.constant([[0., 0., 0.2, 0.2, 0.0]])) rbox_list2 = rbox_list.RBoxList( tf.constant([[0, 0.25123152, 1, 1, 0.0], [0.015789, 0.0985, 0.55789, 0.3842, 0.0]])) gt_box_batch = [rbox_list1, rbox_list2] class_targets1 = tf.constant([[[0, 1, 1], [1, 1, 0]]], tf.float32) class_targets2 = tf.constant( [[[0, 1, 1], [1, 1, 0]], [[0, 0, 1], [0, 0, 1]]], tf.float32) gt_class_targets = [class_targets1, class_targets2] anchors = tf.constant([[0, 0, .25, .25, 0.0], [0, .25, 1, 1, 0.0], [0, .1, .5, .5, 0.0], [.75, .75, 1, 1, 0.0]]) anchors_rbox = rbox_list.RBoxList(anchors) exp_reg_targets = [[[0, 0, -0.223143, -0.223143, 0.0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], [[0, 0, 0, 0, 0], [0, 0.00123152, 0, 0, 0.0], [0.031578, -0.00300001, 0.109554, -0.263445, 0.0], [0, 0, 0, 0, 0]]] exp_cls_weights = [[1, 1, 1, 1], [1, 1, 1, 1]] exp_cls_targets = [[[[0., 1., 1.], [1., 1., 0.]], [[0., 0., 0.], [0., 0., 0.]], [[0., 0., 0.], [0., 0., 0.]], [[0., 0., 0.], [0., 0., 0.]]], [[[0., 0., 0.], [0., 0., 0.]], [[0., 1., 1.], [1., 1., 0.]], [[0., 0., 1.], [0., 0., 1.]], [[0., 0., 0.], [0., 0., 0.]]]] exp_reg_weights = [[1, 0, 0, 0], [0, 1, 1, 0]] exp_match_0 = [0] exp_match_1 = [1, 2] multiclass_target_assigner = self._get_multi_dimensional_target_assigner_rbox( target_dimensions=(2, 3)) (cls_targets, cls_weights, reg_targets, reg_weights, match_list) = \ targetassigner.batch_assign_targets(multiclass_target_assigner, anchors_rbox, gt_box_batch, gt_class_targets) self.assertTrue(isinstance(match_list, list) and len(match_list) == 2) with self.test_session() as sess: (cls_targets_out, cls_weights_out, reg_targets_out, reg_weights_out, match_out_0, match_out_1) = sess.run( [cls_targets, cls_weights, reg_targets, reg_weights] + [match.matched_column_indices() for match in match_list]) self.assertAllClose(cls_targets_out, exp_cls_targets) self.assertAllClose(cls_weights_out, exp_cls_weights) self.assertAllClose(reg_targets_out, exp_reg_targets) self.assertAllClose(reg_weights_out, exp_reg_weights) self.assertAllClose(match_out_0, exp_match_0) self.assertAllClose(match_out_1, exp_match_1)
def test_gather_with_invalid_inputs(self): corners = tf.constant( [5 * [0.0], 5 * [1.0], 5 * [2.0], 5 * [3.0], 5 * [4.0]]) indices_float32 = tf.constant([0, 2, 4], tf.float32) boxes = rbox_list.RBoxList(corners) with self.assertRaises(ValueError): _ = rbox_list_ops.gather(boxes, indices_float32) indices_2d = tf.constant([[0, 2, 4]], tf.int32) boxes = rbox_list.RBoxList(corners) with self.assertRaises(ValueError): _ = rbox_list_ops.gather(boxes, indices_2d)
def test_concatenate_with_incompatible_field_shapes(self): rbox1 = tf.constant([[0, 0, 0, 0, 0], [1, 2, 3, 4, 5]], tf.float32) scores1 = tf.constant([1.0, 2.1]) robx2 = tf.constant([[0, 3, 1, 6, 7], [2, 4, 3, 8, 9]], tf.float32) scores2 = tf.constant([[1.0, 1.0], [2.1, 3.2]]) boxlist1 = rbox_list.RBoxList(rbox1) boxlist1.add_field('scores', scores1) boxlist2 = rbox_list.RBoxList(robx2) boxlist2.add_field('scores', scores2) with self.assertRaises(ValueError): rbox_list_ops.concatenate([boxlist1, boxlist2])
def test_box_list_invalid_inputs(self): data0 = tf.constant([[[0, 0, 1, 1], [3, 4, 5, 5]]], tf.float32) data1 = tf.constant([[0, 0, 1], [1, 1, 2], [3, 4, 5]], tf.float32) data2 = tf.constant([[0, 0, 1], [1, 1, 2], [3, 4, 5]], tf.int32) with self.assertRaises(ValueError): _ = rbox_list.RBoxList(data0) with self.assertRaises(ValueError): _ = rbox_list.RBoxList(data1) with self.assertRaises(ValueError): _ = rbox_list.RBoxList(data2)
def test_get_correct_pairwise_similarity_based_on_iou_rbox(self): corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.0], [5.0, 6.0, 10.0, 7.0, 0.0]]) corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.0], [14.0, 14.0, 15.0, 15.0, 0.0], [0.0, 0.0, 20.0, 20.0, 0.0]]) exp_output = [[0.495495, 0, 0.0875], [0.388235, 0.036907, 0.175]] rboxes1 = rbox_list.RBoxList(corners1) rboxes2 = rbox_list.RBoxList(corners2) iou_similarity_calculator = region_similarity_calculator.IouSimilarity() iou_similarity = iou_similarity_calculator.compare(rboxes1, rboxes2) with self.test_session() as sess: iou_output = sess.run(iou_similarity) self.assertAllClose(iou_output, exp_output)
def test_matched_iou(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2]]) exp_output = [27.025812 / 55.974188, 7.2258 / 287.7742] boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) iou = rbox_list_ops.matched_iou(boxes1, boxes2) with self.test_session() as sess: iou_output = sess.run(iou) self.assertAllClose(iou_output, exp_output)
def test_matched_intersection(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2]]) exp_output = [27.025812, 7.2258] boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) intersect = rbox_list_ops.matched_intersection(boxes1, boxes2) with self.test_session() as sess: intersect_output = sess.run(intersect) self.assertAllClose(intersect_output, exp_output)
def test_assign_multidimensional_class_targets_rbox(self): similarity_calc = region_similarity_calculator.IouSimilarity() matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5, unmatched_threshold=0.3) box_coder = faster_rcnn_rbox_coder.FasterRcnnRBoxCoder() unmatched_cls_target = tf.constant([[0, 0], [0, 0]], tf.float32) target_assigner = targetassigner.TargetAssigner( similarity_calc, matcher, box_coder, unmatched_cls_target=unmatched_cls_target) anchors = tf.constant([[0.0, 0.0, 0.5, 0.5, 0.0], [0.5, 0.5, 1.0, 0.8, 0.0], [0, 0.5, .5, 1.0, 0.0], [.75, 0, 1.0, .25, 0.0]]) anchors_rbox = rbox_list.RBoxList(anchors) box_corners = [[0.0, 0.0, 0.5, 0.5, 0.0], [0.5, 0.5, 0.9, 0.9, 0.0], [.75, 0, .95, .27, 0.0]] rboxes = rbox_list.RBoxList(tf.constant(box_corners)) groundtruth_labels = tf.constant( [[[0, 1], [1, 0]], [[1, 0], [0, 1]], [[0, 1], [1, .5]]], tf.float32) exp_cls_targets = [[[0, 1], [1, 0]], [[1, 0], [0, 1]], [[0, 0], [0, 0]], [[0, 1], [1, .5]]] exp_cls_weights = [1, 1, 1, 1] exp_reg_targets = [[0, 0, 0, 0, 0], [0, 0, -0.105361, 0.117783, 0], [0, 0, 0, 0, 0], [0, 0, -0.0512933, .0769611, 0]] exp_reg_weights = [1, 1, 0, 1] exp_matching_anchors = [0, 1, 3] result = target_assigner.assign(anchors_rbox, rboxes, groundtruth_labels) (cls_targets, cls_weights, reg_targets, reg_weights, match) = result with self.test_session() as sess: (cls_targets_out, cls_weights_out, reg_targets_out, reg_weights_out, matching_anchors_out) = \ sess.run([cls_targets, cls_weights, reg_targets, reg_weights, match.matched_column_indices()]) self.assertAllClose(cls_targets_out, exp_cls_targets) self.assertAllClose(cls_weights_out, exp_cls_weights) self.assertAllClose(reg_targets_out, exp_reg_targets) self.assertAllClose(reg_weights_out, exp_reg_weights) self.assertAllClose(matching_anchors_out, exp_matching_anchors) self.assertEquals(cls_targets_out.dtype, np.float32) self.assertEquals(cls_weights_out.dtype, np.float32) self.assertEquals(reg_targets_out.dtype, np.float32) self.assertEquals(reg_weights_out.dtype, np.float32) self.assertEquals(matching_anchors_out.dtype, np.int32)
def test_intersection_shapely(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2], [0.0, 0.0, 20.0, 20.0, 0.3]]) exp_output = [[27.025812, 0., 35.], [30.889588, 7.2258, 63.043903]] boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) intersect = rbox_list_ops.intersection(boxes1, boxes2, ver='shapely') with self.test_session() as sess: intersect_output = sess.run(intersect) self.assertAllClose(intersect_output, exp_output)
def test_get_correct_relative_codes_after_encoding(self): boxes = [[10.0, 10.0, 20.0, 15.0, 0.1], [0.2, 0.1, 0.5, 0.4, 0.2]] anchors = [[15.0, 12.0, 30.0, 18.0, 0.15], [0.1, 0.0, 0.7, 0.9, 0.1]] expected_rel_codes = [[ -0.154833, -0.151374, -0.405465, -0.182322, -0.031831 ], [0.127882, 0.121649, -0.336472, -0.810930, 0.063662]] boxes = rbox_list.RBoxList(tf.constant(boxes)) anchors = rbox_list.RBoxList(tf.constant(anchors)) coder = faster_rcnn_rbox_coder.FasterRcnnRBoxCoder() rel_codes = coder.encode(boxes, anchors) with self.test_session() as sess: rel_codes_out, = sess.run([rel_codes]) self.assertAllClose(rel_codes_out, expected_rel_codes)
def test_change_coordinate_frame(self): corners = tf.constant([[0.25, 0.5, 0.75, 0.75, 0.1], [0.5, 0.0, 1.0, 1.0, 0.2]]) window = tf.constant([0.25, 0.25, 0.75, 0.75]) boxes = rbox_list.RBoxList(corners) expected_corners = tf.constant([[0, 0.5, 1.5, 1.5, 0.1], [0.5, -0.5, 2.0, 2.0, 0.2]]) expected_boxes = rbox_list.RBoxList(expected_corners) output = rbox_list_ops.change_coordinate_frame(boxes, window) with self.test_session() as sess: output_, expected_boxes_ = sess.run( [output.get(), expected_boxes.get()]) self.assertAllClose(output_, expected_boxes_)
def test_sort_by_field_descending_order(self): exp_corners = [[0, 0, 1, 1, 0.1], [0, 0.1, 1, 1.1, 0.2], [0, -0.1, 1, 0.9, 0.3], [0, 10, 1, 11, 0.4], [0, 10.1, 1, 11.1, 0.5], [0, 100, 1, 101, 0.6]] exp_scores = [.95, .9, .75, .6, .5, .3] exp_weights = [.2, .45, .6, .75, .8, .92] shuffle = [2, 4, 0, 5, 1, 3] corners = tf.constant([exp_corners[i] for i in shuffle], tf.float32) rboxes = rbox_list.RBoxList(corners) rboxes.add_field( 'scores', tf.constant([exp_scores[i] for i in shuffle], tf.float32)) rboxes.add_field( 'weights', tf.constant([exp_weights[i] for i in shuffle], tf.float32)) sort_by_score = rbox_list_ops.sort_by_field(rboxes, 'scores') with self.test_session() as sess: rboxes_out, corners_out, scores_out, weights_out = sess.run([ rboxes.get_field('scores'), sort_by_score.get(), sort_by_score.get_field('scores'), sort_by_score.get_field('weights') ]) self.assertAllClose(corners_out, exp_corners) self.assertAllClose(scores_out, exp_scores) self.assertAllClose(weights_out, exp_weights)
def test_get_correct_relative_codes_after_encoding_with_scaling(self): boxes = [[10.0, 10.0, 20.0, 15.0, 0.1], [0.2, 0.1, 0.5, 0.4, 0.2]] anchors = [[15.0, 12.0, 30.0, 18.0, 0.15], [0.1, 0.0, 0.7, 0.9, 0.1]] scale_factors = [2, 3, 4, 5, 6] expected_rel_codes = [[ -0.309665, -0.454122, -1.621860, -0.911607, -0.190986 ], [0.2557630, 0.364945, -1.345888, -4.054651, 0.381972]] boxes = rbox_list.RBoxList(tf.constant(boxes)) anchors = rbox_list.RBoxList(tf.constant(anchors)) coder = faster_rcnn_rbox_coder.FasterRcnnRBoxCoder( scale_factors=scale_factors) rel_codes = coder.encode(boxes, anchors) with self.test_session() as sess: rel_codes_out, = sess.run([rel_codes]) self.assertAllClose(rel_codes_out, expected_rel_codes)
def _decode(self, rel_codes, anchors): """Decode relative codes to rboxes. Args: rel_codes: a tensor representing N anchor-encoded rboxes. anchors: BoxList of anchors. Returns: boxes: BoxList holding N bounding rboxes. """ ycenter_a, xcenter_a, ha, wa, ang_a = tf.unstack( tf.transpose(anchors.get())) ty, tx, th, tw, ta = tf.unstack(tf.transpose(rel_codes)) if self._scale_factors: ty /= self._scale_factors[0] tx /= self._scale_factors[1] th /= self._scale_factors[2] tw /= self._scale_factors[3] ta /= self._scale_factors[4] ycenter = tx * wa * tf.sin(ang_a) + ty * ha * tf.cos(ang_a) + ycenter_a xcenter = tx * wa * tf.cos( ang_a) + ty * ha * -tf.sin(ang_a) + xcenter_a w = tf.exp(tw) * wa h = tf.exp(th) * ha ang = ta * (math.pi / 2) + ang_a return rbox_list.RBoxList( tf.transpose(tf.stack([ycenter, xcenter, h, w, ang])))
def test_copy_extra_fields(self): corners = tf.constant([[0, 0, 1, 1, 0], [0, 0.1, 1, 1.1, 0]], tf.float32) rboxes = rbox_list.RBoxList(corners) tensor1 = np.array([[1], [4]]) tensor2 = np.array([[1, 1], [2, 2]]) rboxes.add_field('tensor1', tf.constant(tensor1)) rboxes.add_field('tensor2', tf.constant(tensor2)) new_boxes = rbox_list.RBoxList( tf.constant([[0, 0, 10, 10, 0], [1, 3, 5, 5, 0]], tf.float32)) new_boxes = rbox_list_ops._copy_extra_fields(new_boxes, rboxes) with self.test_session() as sess: self.assertAllClose(tensor1, sess.run(new_boxes.get_field('tensor1'))) self.assertAllClose(tensor2, sess.run(new_boxes.get_field('tensor2')))
def test_as_tensor_dict_missing_field(self): rboxlist = rbox_list.RBoxList( tf.constant([[0.1, 0.1, 0.4, 0.4, 0.1], [0.1, 0.1, 0.5, 0.5, 0.2]], tf.float32)) rboxlist.add_field('classes', tf.constant([0, 1])) rboxlist.add_field('scores', tf.constant([0.75, 0.2])) with self.assertRaises(ValueError): rboxlist.as_tensor_dict(['foo', 'bar'])
def test_invalid_input_box_list_list(self): with self.assertRaises(ValueError): rbox_list_ops.concatenate(None) with self.assertRaises(ValueError): rbox_list_ops.concatenate([]) with self.assertRaises(ValueError): corners = tf.constant([[0, 0, 0, 0, 0]], tf.float32) boxlist = rbox_list.RBoxList(corners) rbox_list_ops.concatenate([boxlist, 2])
def test_iou(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2], [0.0, 0.0, 20.0, 20.0, 0.3], [0.0, 0.0, 20.0, 20.0, -1.57]]) exp_output = [[27.025812 / 55.974188, 0. / 260, 35. / 400, -1], [ 30.889588 / 87.110412, 7.2258 / 287.7742, 63.043903 / 406.956097, -1 ]] boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) iou = rbox_list_ops.iou(boxes1, boxes2) with self.test_session() as sess: iou_output = sess.run(iou) self.assertAllClose(iou_output, exp_output)
def test_area(self): rbox = tf.constant([[0.0, 0.0, 10.0, 20.0, 0.1], [1.0, 2.0, 3.0, 4.0, 0.2]]) exp_output = [200.0, 12.0] boxes = rbox_list.RBoxList(rbox) areas = rbox_list_ops.area(boxes) with self.test_session() as sess: areas_output = sess.run(areas) self.assertAllClose(areas_output, exp_output)
def test_ioaworks_on_empty_inputs(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2], [0.0, 0.0, 20.0, 20.0, 0.3]]) boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) boxes_empty = rbox_list.RBoxList(tf.zeros((0, 5))) ioa_empty_1 = rbox_list_ops.ioa(boxes1, boxes_empty) ioa_empty_2 = rbox_list_ops.ioa(boxes_empty, boxes2) ioa_empty_3 = rbox_list_ops.ioa(boxes_empty, boxes_empty) with self.test_session() as sess: ioa_output_1, ioa_output_2, ioa_output_3 = sess.run( [ioa_empty_1, ioa_empty_2, ioa_empty_3]) self.assertAllEqual(ioa_output_1.shape, (2, 0)) self.assertAllEqual(ioa_output_2.shape, (0, 3)) self.assertAllEqual(ioa_output_3.shape, (0, 0))
def test_gather_with_invalid_field(self): corners = tf.constant([5 * [0.0], 5 * [1.0]]) indices = tf.constant([0, 1], tf.int32) weights = tf.constant([[.1], [.3]], tf.float32) boxes = rbox_list.RBoxList(corners) boxes.add_field('weights', weights) with self.assertRaises(ValueError): rbox_list_ops.gather(boxes, indices, ['foo', 'bar'])
def test_create_target_assigner(self): """Tests that named constructor gives working target assigners. TODO: Make this test more general. """ corners = [[0.0, 0.0, 1.0, 1.0]] groundtruth = box_list.BoxList(tf.constant(corners)) priors = box_list.BoxList(tf.constant(corners)) prior_stddevs = tf.constant([[1.0, 1.0, 1.0, 1.0]]) priors.add_field('stddev', prior_stddevs) multibox_ta = (targetassigner.create_target_assigner('Multibox', stage='proposal')) multibox_ta.assign(priors, groundtruth) # No tests on output, as that may vary arbitrarily as new target assigners # are added. As long as it is constructed correctly and runs without errors, # tests on the individual assigners cover correctness of the assignments. anchors = box_list.BoxList(tf.constant(corners)) faster_rcnn_proposals_ta = (targetassigner.create_target_assigner( 'FasterRCNN', stage='proposal')) faster_rcnn_proposals_ta.assign(anchors, groundtruth) fast_rcnn_ta = (targetassigner.create_target_assigner('FastRCNN')) fast_rcnn_ta.assign(anchors, groundtruth) faster_rcnn_detection_ta = (targetassigner.create_target_assigner( 'FasterRCNN', stage='detection')) faster_rcnn_detection_ta.assign(anchors, groundtruth) corners = [[0.0, 0.0, 1.0, 1.0, 0.0]] groundtruth = rbox_list.RBoxList(tf.constant(corners)) anchors = rbox_list.RBoxList(tf.constant(corners)) rfaster_rcnn_proposals_ta = (targetassigner.create_target_assigner( 'RFasterRCNN', stage='proposal')) rfaster_rcnn_proposals_ta.assign(anchors, groundtruth) rfaster_rcnn_detection_ta = (targetassigner.create_target_assigner( 'RFasterRCNN', stage='detection')) rfaster_rcnn_detection_ta.assign(anchors, groundtruth) with self.assertRaises(ValueError): targetassigner.create_target_assigner('InvalidDetector', stage='invalid_stage')
def test_ioa(self): rbox1 = tf.constant([[4.0, 3.0, 7.0, 5.0, 0.1], [5.0, 6.0, 10.0, 7.0, 0.2]]) rbox2 = tf.constant([[3.0, 4.0, 6.0, 8.0, 0.1], [14.0, 14.0, 15.0, 15.0, 0.2], [0.0, 0.0, 20.0, 20.0, 0.3]]) exp_output_1 = [[27.025812 / 48, 0. / 225, 35. / 400], [30.889588 / 48, 7.2258 / 225, 63.043903 / 400]] exp_output_2 = [[27.025812 / 35, 30.889588 / 70], [0. / 35, 7.2258 / 70], [35. / 35, 63.043903 / 70]] boxes1 = rbox_list.RBoxList(rbox1) boxes2 = rbox_list.RBoxList(rbox2) ioa_1 = rbox_list_ops.ioa(boxes1, boxes2) ioa_2 = rbox_list_ops.ioa(boxes2, boxes1) with self.test_session() as sess: ioa_output_1, ioa_output_2 = sess.run([ioa_1, ioa_2]) self.assertAllClose(ioa_output_1, exp_output_1) self.assertAllClose(ioa_output_2, exp_output_2)
def test_num_boxes(self): data = tf.constant( [[0, 0, 1, 1, 0.1], [1, 1, 2, 3, 0.2], [3, 4, 5, 5, 0.3]], tf.float32) expected_num_boxes = 3 rboxes = rbox_list.RBoxList(data) with self.test_session() as sess: num_boxes_output = sess.run(rboxes.num_boxes()) self.assertEquals(num_boxes_output, expected_num_boxes)
def test_boolean_mask(self): corners = tf.constant( [5 * [0.0], 5 * [1.0], 5 * [2.0], 5 * [3.0], 5 * [4.0]]) indicator = tf.constant([True, False, True, False, True], tf.bool) expected_subset = [5 * [0.0], 5 * [2.0], 5 * [4.0]] boxes = rbox_list.RBoxList(corners) subset = rbox_list_ops.boolean_mask(boxes, indicator) with self.test_session() as sess: subset_output = sess.run(subset.get()) self.assertAllClose(subset_output, expected_subset)
def test_gather(self): corners = tf.constant( [5 * [0.0], 5 * [1.0], 5 * [2.0], 5 * [3.0], 5 * [4.0]]) indices = tf.constant([0, 2, 4], tf.int32) expected_subset = [5 * [0.0], 5 * [2.0], 5 * [4.0]] boxes = rbox_list.RBoxList(corners) subset = rbox_list_ops.gather(boxes, indices) with self.test_session() as sess: subset_output = sess.run(subset.get()) self.assertAllClose(subset_output, expected_subset)
def test_to_absolute_coordinates_already_abolute(self): coordinates = tf.constant( [[0, 0, 100, 100, 0.1], [25, 25, 75, 75, 0.1]], tf.float32) img = tf.ones((128, 100, 100, 3)) rboxlist = rbox_list.RBoxList(coordinates) absolute_rboxlist = rbox_list_ops.to_absolute_coordinates( rboxlist, tf.shape(img)[1], tf.shape(img)[2], check_range=True) with self.test_session() as sess: with self.assertRaisesOpError('assertion failed'): sess.run(absolute_rboxlist.get())
def test_to_normalized_coordinates_already_normalized(self): coordinates = tf.constant( [[0, 0, 1, 1, 0.1], [0.25, 0.25, 0.75, 0.75, 0.1]], tf.float32) img = tf.ones((128, 100, 100, 3)) boxlist = rbox_list.RBoxList(coordinates) normalized_boxlist = rbox_list_ops.to_normalized_coordinates( boxlist, tf.shape(img)[1], tf.shape(img)[2], check_range=True) with self.test_session() as sess: with self.assertRaisesOpError('assertion failed'): sess.run(normalized_boxlist.get())