Spaces:
Runtime error
Runtime error
File size: 4,132 Bytes
06db6e9 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 |
#!/usr/bin/python
#
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch
"""
Utilities for dealing with bounding boxes
"""
def box_abs2rel(boxes, inside_boxes, obj_to_img):
inside_boxes = inside_boxes[obj_to_img]
ix0, iy0, ix1, iy1 = inside_boxes[:, 0], inside_boxes[:, 1], inside_boxes[:, 2], inside_boxes[:, 3]
xc = (boxes[:, 0] - ix0) / (ix1 - ix0)
yc = (boxes[:, 1] - iy0) / (iy1 - iy0)
w = boxes[:, 2] / (ix1 - ix0)
h = boxes[:, 3] / (iy1 - iy0)
return torch.stack([xc, yc, w, h], dim=1)
def box_rel2abs(boxes, inside_boxes, obj_to_img):
inside_boxes = inside_boxes[obj_to_img]
ix0, iy0, ix1, iy1 = inside_boxes[:, 0], inside_boxes[:, 1], inside_boxes[:, 2], inside_boxes[:, 3]
xc = boxes[:, 0] * (ix1 - ix0) + ix0
yc = boxes[:, 1] * (iy1 - iy0) + iy0
w = boxes[:, 2] * (ix1 - ix0)
h = boxes[:, 3] * (iy1 - iy0)
return torch.stack([xc, yc, w, h], dim=1)
def norms_to_indices(boxes,H,W=None):
if W is None:
W=H
x0,x1 = boxes[:,0]*(W-1),boxes[:,2]*(W-1)+1
y0,y1 = boxes[:,1]*(H-1),boxes[:,3]*(H-1)+1
return torch.stack([x0, y0, x1, y1], dim=1).round().long()
def apply_box_transform(anchors, transforms):
"""
Apply box transforms to a set of anchor boxes.
Inputs:
- anchors: Anchor boxes of shape (N, 4), where each anchor is specified
in the form [xc, yc, w, h]
- transforms: Box transforms of shape (N, 4) where each transform is
specified as [tx, ty, tw, th]
Returns:
- boxes: Transformed boxes of shape (N, 4) where each box is in the
format [xc, yc, w, h]
"""
# Unpack anchors
xa, ya = anchors[:, 0], anchors[:, 1]
wa, ha = anchors[:, 2], anchors[:, 3]
# Unpack transforms
tx, ty = transforms[:, 0], transforms[:, 1]
tw, th = transforms[:, 2], transforms[:, 3]
x = xa + tx * wa
y = ya + ty * ha
w = wa * tw.exp()
h = ha * th.exp()
boxes = torch.stack([x, y, w, h], dim=1)
return boxes
def invert_box_transform(anchors, boxes):
"""
Compute the box transform that, when applied to anchors, would give boxes.
Inputs:
- anchors: Box anchors of shape (N, 4) in the format [xc, yc, w, h]
- boxes: Target boxes of shape (N, 4) in the format [xc, yc, w, h]
Returns:
- transforms: Box transforms of shape (N, 4) in the format [tx, ty, tw, th]
"""
# Unpack anchors
xa, ya = anchors[:, 0], anchors[:, 1]
wa, ha = anchors[:, 2], anchors[:, 3]
# Unpack boxes
x, y = boxes[:, 0], boxes[:, 1]
w, h = boxes[:, 2], boxes[:, 3]
tx = (x - xa) / wa
ty = (y - ya) / ha
tw = w.log() - wa.log()
th = h.log() - ha.log()
transforms = torch.stack([tx, ty, tw, th], dim=1)
return transforms
def centers_to_extents(boxes):
"""
Convert boxes from [xc, yc, w, h] format to [x0, y0, x1, y1] format
Input:
- boxes: Input boxes of shape (N, 4) in [xc, yc, w, h] format
Returns:
- boxes: Output boxes of shape (N, 4) in [x0, y0, x1, y1] format
"""
xc, yc = boxes[:, 0], boxes[:, 1]
w, h = boxes[:, 2], boxes[:, 3]
x0 = xc - w / 2
x1 = x0 + w
y0 = yc - h / 2
y1 = y0 + h
boxes_out = torch.stack([x0, y0, x1, y1], dim=1)
return boxes_out
def extents_to_centers(boxes):
"""
Convert boxes from [x0, y0, x1, y1] format to [xc, yc, w, h] format
Input:
- boxes: Input boxes of shape (N, 4) in [x0, y0, x1, y1] format
Returns:
- boxes: Output boxes of shape (N, 4) in [xc, yc, w, h] format
"""
x0, y0 = boxes[:, 0], boxes[:, 1]
x1, y1 = boxes[:, 2], boxes[:, 3]
xc = 0.5 * (x0 + x1)
yc = 0.5 * (y0 + y1)
w = x1 - x0
h = y1 - y0
boxes_out = torch.stack([xc, yc, w, h], dim=1)
return boxes_out
|