Python cv2.IMREAD_IGNORE_ORIENTATION Examples
The following are 24
code examples of cv2.IMREAD_IGNORE_ORIENTATION().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
cv2
, or try the search function
.
.
Example #1
| Source File: image.py From ImageAnalysis with MIT License | 6 votes |
|
def load_rgb(self, equalize=False):
# print("Loading:", self.image_file)
try:
img_rgb = cv2.imread(self.image_file, flags=cv2.IMREAD_ANYCOLOR|cv2.IMREAD_ANYDEPTH|cv2.IMREAD_IGNORE_ORIENTATION)
if equalize:
# equalize val (essentially gray scale level)
clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
hsv = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2HSV)
hue, sat, val = cv2.split(hsv)
aeq = clahe.apply(val)
# recombine
hsv = cv2.merge((hue,sat,aeq))
# convert back to rgb
img_rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
h, w = img_rgb.shape[:2]
self.node.setInt('height', h)
self.node.setInt('width', w)
return img_rgb
except:
print(self.image_file + ":\n" + " rgb load error: " \
+ str(sys.exc_info()[1]))
return None
Example #2
| Source File: JointsDataset_PoseAgg.py From PoseWarper with Apache License 2.0 | 5 votes |
|
def read_image(self, image_path):
r = open(image_path,'rb').read()
img_array = np.asarray(bytearray(r), dtype=np.uint8)
img = cv2.imdecode(img_array, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
return img
Example #3
| Source File: ac3d.py From ImageAnalysis with MIT License | 5 votes |
|
def make_textures_opencv(src_dir, project_dir, image_list, resolution=256):
dst_dir = os.path.join(project_dir, 'models')
if not os.path.exists(dst_dir):
print("Notice: creating texture directory =", dst_dir)
os.makedirs(dst_dir)
for image in image_list:
src = image.image_file
dst = os.path.join(dst_dir, image.name + '.JPG')
if not os.path.exists(dst):
print(src)
src = cv2.imread(src, flags=cv2.IMREAD_ANYCOLOR|cv2.IMREAD_ANYDEPTH|cv2.IMREAD_IGNORE_ORIENTATION)
height, width = src.shape[:2]
# downscale image first
method = cv2.INTER_AREA # cv2.INTER_AREA
scale = cv2.resize(src, (0,0),
fx=resolution/float(width),
fy=resolution/float(height),
interpolation=method)
# convert to hsv color space
hsv = cv2.cvtColor(scale, cv2.COLOR_BGR2HSV)
hue,sat,val = cv2.split(hsv)
# adaptive histogram equalization on 'value' channel
clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
aeq = clahe.apply(val)
# recombine
hsv = cv2.merge((hue,sat,aeq))
# convert back to rgb
result = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite(dst, result)
print("Texture %dx%d %s" % (resolution, resolution, dst))
Example #4
| Source File: image.py From Sequence-Level-Semantics-Aggregation with Apache License 2.0 | 5 votes |
|
def get_image(roidb, config):
"""
preprocess image and return processed roidb
:param roidb: a list of roidb
:return: list of img as in mxnet format
roidb add new item['im_info']
0 --- x (width, second dim of im)
|
y (height, first dim of im)
"""
num_images = len(roidb)
processed_ims = []
processed_roidb = []
for i in range(num_images):
roi_rec = roidb[i]
if 'tar' in roi_rec['pattern']:
assert os.path.exists(roi_rec['pattern']), '%s does not exist'.format(roi_rec['pattern'])
im = imread_from_tar(roi_rec['pattern'], roi_rec['image'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
else:
assert os.path.exists(roi_rec['image']), '%s does not exist'.format(roi_rec['image'])
im = cv2.imread(roi_rec['image'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
if roidb[i]['flipped']:
im = im[:, ::-1, :]
new_rec = roi_rec.copy()
scale_ind = random.randrange(len(config.SCALES))
target_size = config.SCALES[scale_ind][0]
max_size = config.SCALES[scale_ind][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
processed_ims.append(im_tensor)
im_info = [im_tensor.shape[2], im_tensor.shape[3], im_scale]
new_rec['boxes'] = clip_boxes(np.round(roi_rec['boxes'].copy() * im_scale), im_info[:2])
new_rec['im_info'] = im_info
processed_roidb.append(new_rec)
return processed_ims, processed_roidb
Example #5
| Source File: pose_estimation.py From cvToolkit with MIT License | 5 votes |
|
def pre_process(image, bboxs, scores, cfg, thred_score=0.8):
if type(image) == str:
data_numpy = cv2.imread(image, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
else:
data_numpy = image
inputs = []
centers = []
scales = []
score_num = np.sum(scores>thred_score)
max_box = min(5, score_num)
for bbox in bboxs[:max_box]:
x1,y1,x2,y2 = bbox
box = [x1, y1, x2-x1, y2-y1]
# 截取 box fron image --> return center, scale
c, s = _box2cs(box, data_numpy.shape[0], data_numpy.shape[1])
centers.append(c)
scales.append(s)
r = 0
trans = get_affine_transform(c, s, r, cfg.MODEL.IMAGE_SIZE)
input = cv2.warpAffine(
data_numpy,
trans,
(int(cfg.MODEL.IMAGE_SIZE[0]), int(cfg.MODEL.IMAGE_SIZE[1])),
flags=cv2.INTER_LINEAR)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
input = transform(input).unsqueeze(0)
inputs.append(input)
inputs = torch.cat(inputs)
return inputs, data_numpy, centers, scales
Example #6
| Source File: image.py From RoITransformer_DOTA with MIT License | 5 votes |
|
def get_image(roidb, config):
"""
preprocess image and return processed roidb
:param roidb: a list of roidb
:return: list of img as in mxnet format
roidb add new item['im_info']
0 --- x (width, second dim of im)
|
y (height, first dim of im)
"""
num_images = len(roidb)
processed_ims = []
processed_roidb = []
for i in range(num_images):
roi_rec = roidb[i]
assert os.path.exists(roi_rec['image']), '%s does not exist'.format(roi_rec['image'])
im = cv2.imread(roi_rec['image'], cv2.IMREAD_COLOR|cv2.IMREAD_IGNORE_ORIENTATION)
# print (roidb[i])
if roidb[i]['flipped']:
im = im[:, ::-1, :]
new_rec = roi_rec.copy()
scale_ind = random.randrange(len(config.SCALES))
target_size = config.SCALES[scale_ind][0]
# pdb.set_trace()
max_size = config.SCALES[scale_ind][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
processed_ims.append(im_tensor)
im_info = [im_tensor.shape[2], im_tensor.shape[3], im_scale]
new_rec['boxes'] = clip_boxes(np.round(roi_rec['boxes'].copy() * im_scale), im_info[:2])
new_rec['im_info'] = im_info
processed_roidb.append(new_rec)
return processed_ims, processed_roidb
Example #7
| Source File: image.py From RoITransformer_DOTA with MIT License | 5 votes |
|
def get_test_image(roidb, config):
"""
preprocess image and return processed roidb
:param roidb: a list of roidb
:return: list of img as in mxnet format
roidb add new item['im_info']
0 --- x (width, second dim of im)
|
y (height, first dim of im)
"""
num_images = len(roidb)
processed_ims = []
processed_roidb = []
for i in range(num_images):
roi_rec = roidb[i]
assert os.path.exists(roi_rec['image']), '%s does not exist'.format(roi_rec['image'])
im = cv2.imread(roi_rec['image'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
# print (roidb[i])
# if roidb[i]['flipped']:
# im = im[:, ::-1, :]
new_rec = roi_rec.copy()
scale_ind = random.randrange(len(config.SCALES))
# print "config.SCALES[scale_ind]:",config.SCALES[scale_ind]
target_size = config.SCALES[scale_ind][0]
max_size = config.SCALES[scale_ind][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
processed_ims.append(im_tensor)
im_info = [im_tensor.shape[2], im_tensor.shape[3], im_scale]
# new_rec['boxes'] = clip_boxes(np.round(roi_rec['boxes'].copy() * im_scale), im_info[:2])
new_rec['im_info'] = im_info
processed_roidb.append(new_rec)
return processed_ims, processed_roidb
Example #8
| Source File: coco.py From HRNet-MaskRCNN-Benchmark with MIT License | 5 votes |
|
def __getitem__(self, idx):
#img, anno = super(COCODataset, self).__getitem__(idx)
# use zipreader, change the function of super.getitem
coco = self.coco
img_id = self.ids[idx]
ann_ids = coco.getAnnIds(imgIds=img_id)
anno = coco.loadAnns(ann_ids)
path = coco.loadImgs(img_id)[0]['file_name']
# In philly cluster use zipreader instead Image.open
#img = Image.open(os.path.join(self.root, path)).convert('RGB')
img = zipreader.imread(os.path.join(self.root, path), \
cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
img = Image.fromarray(img)
# filter crowd annotations
# TODO might be better to add an extra field
anno = [obj for obj in anno if obj["iscrowd"] == 0]
boxes = [obj["bbox"] for obj in anno]
boxes = torch.as_tensor(boxes).reshape(-1, 4) # guard against no boxes
target = BoxList(boxes, img.size, mode="xywh").convert("xyxy")
classes = [obj["category_id"] for obj in anno]
classes = [self.json_category_id_to_contiguous_id[c] for c in classes]
classes = torch.tensor(classes)
target.add_field("labels", classes)
masks = [obj["segmentation"] for obj in anno]
masks = SegmentationMask(masks, img.size)
target.add_field("masks", masks)
target = target.clip_to_image(remove_empty=True)
if self.transforms is not None:
img, target = self.transforms(img, target)
return img, target, idx
Example #9
| Source File: CrowdPoseDataset.py From HigherHRNet-Human-Pose-Estimation with MIT License | 5 votes |
|
def __getitem__(self, index):
"""
Args:
index (int): Index
Returns:
tuple: Tuple (image, target). target is the object returned by ``coco.loadAnns``.
"""
coco = self.coco
img_id = self.ids[index]
ann_ids = coco.getAnnIds(imgIds=img_id)
target = coco.loadAnns(ann_ids)
file_name = coco.loadImgs(img_id)[0]['file_name']
if self.data_format == 'zip':
img = zipreader.imread(
self._get_image_path(file_name),
cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION
)
else:
img = cv2.imread(
self._get_image_path(file_name),
cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION
)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
if self.transform is not None:
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
return img, target
Example #10
| Source File: COCODataset.py From HigherHRNet-Human-Pose-Estimation with MIT License | 5 votes |
|
def __getitem__(self, index):
"""
Args:
index (int): Index
Returns:
tuple: Tuple (image, target). target is the object returned by ``coco.loadAnns``.
"""
coco = self.coco
img_id = self.ids[index]
ann_ids = coco.getAnnIds(imgIds=img_id)
target = coco.loadAnns(ann_ids)
file_name = coco.loadImgs(img_id)[0]['file_name']
if self.data_format == 'zip':
img = zipreader.imread(
self._get_image_path(file_name),
cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION
)
else:
img = cv2.imread(
self._get_image_path(file_name),
cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION
)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
if self.transform is not None:
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
return img, target
Example #11
| Source File: JointsDataset.py From PoseWarper with Apache License 2.0 | 5 votes |
|
def read_image(self, image_path):
r = open(image_path,'rb').read()
img_array = np.asarray(bytearray(r), dtype=np.uint8)
img = cv2.imdecode(img_array, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
return img
Example #12
| Source File: joints_dataset.py From multiview-human-pose-estimation-pytorch with MIT License | 4 votes |
|
def __getitem__(self, idx):
db_rec = copy.deepcopy(self.db[idx])
image_dir = 'images.zip@' if self.data_format == 'zip' else ''
image_file = osp.join(self.root, db_rec['source'], image_dir, 'images',
db_rec['image'])
if self.data_format == 'zip':
from utils import zipreader
data_numpy = zipreader.imread(
image_file, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
else:
data_numpy = cv2.imread(
image_file, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
joints = db_rec['joints_2d'].copy()
joints_vis = db_rec['joints_vis'].copy()
center = np.array(db_rec['center']).copy()
scale = np.array(db_rec['scale']).copy()
rotation = 0
if self.is_train:
sf = self.scale_factor
rf = self.rotation_factor
scale = scale * np.clip(np.random.randn() * sf + 1, 1 - sf, 1 + sf)
rotation = np.clip(np.random.randn() * rf, -rf * 2, rf * 2) \
if random.random() <= 0.6 else 0
trans = get_affine_transform(center, scale, rotation, self.image_size)
input = cv2.warpAffine(
data_numpy,
trans, (int(self.image_size[0]), int(self.image_size[1])),
flags=cv2.INTER_LINEAR)
if self.transform:
input = self.transform(input)
for i in range(self.num_joints):
if joints_vis[i, 0] > 0.0:
joints[i, 0:2] = affine_transform(joints[i, 0:2], trans)
if (np.min(joints[i, :2]) < 0 or
joints[i, 0] >= self.image_size[0] or
joints[i, 1] >= self.image_size[1]):
joints_vis[i, :] = 0
target, target_weight = self.generate_target(joints, joints_vis)
target = torch.from_numpy(target)
target_weight = torch.from_numpy(target_weight)
meta = {
'scale': scale,
'center': center,
'rotation': rotation,
'joints_2d': db_rec['joints_2d'],
'joints_2d_transformed': joints,
'joints_vis': joints_vis,
'source': db_rec['source']
}
return input, target, target_weight, meta
Example #13
| Source File: deform_conv_demo.py From Deformable-ConvNets with MIT License | 4 votes |
|
def main():
# get symbol
pprint.pprint(config)
sym_instance = eval(config.symbol + '.' + config.symbol)()
sym = sym_instance.get_symbol(config, is_train=False)
# load demo data
image_names = ['000240.jpg', '000437.jpg', '004072.jpg', '007912.jpg']
image_all = []
data = []
for im_name in image_names:
assert os.path.exists(cur_path + '/../demo/deform_conv/' + im_name), \
('%s does not exist'.format('../demo/deform_conv/' + im_name))
im = cv2.imread(cur_path + '/../demo/deform_conv/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
image_all.append(im)
target_size = config.SCALES[0][0]
max_size = config.SCALES[0][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32)
data.append({'data': im_tensor, 'im_info': im_info})
# get predictor
data_names = ['data', 'im_info']
label_names = []
data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))]
max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]]
provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))]
provide_label = [None for i in xrange(len(data))]
arg_params, aux_params = load_param(cur_path + '/../model/deform_conv', 0, process=True)
predictor = Predictor(sym, data_names, label_names,
context=[mx.gpu(0)], max_data_shapes=max_data_shape,
provide_data=provide_data, provide_label=provide_label,
arg_params=arg_params, aux_params=aux_params)
# test
for idx, _ in enumerate(image_names):
data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx,
provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]],
provide_label=[None])
output = predictor.predict(data_batch)
res5a_offset = output[0]['res5a_branch2b_offset_output'].asnumpy()
res5b_offset = output[0]['res5b_branch2b_offset_output'].asnumpy()
res5c_offset = output[0]['res5c_branch2b_offset_output'].asnumpy()
im = image_all[idx]
im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
show_dconv_offset(im, [res5c_offset, res5b_offset, res5a_offset])
Example #14
| Source File: deform_psroi_demo.py From Deformable-ConvNets with MIT License | 4 votes |
|
def main():
# get symbol
pprint.pprint(config)
sym_instance = eval(config.symbol + '.' + config.symbol)()
sym = sym_instance.get_symbol_rfcn(config, is_train=False)
# load demo data
image_names = ['000057.jpg', '000149.jpg', '000351.jpg', '002535.jpg']
image_all = []
# ground truth boxes
gt_boxes_all = [np.array([[132, 52, 384, 357]]), np.array([[113, 1, 350, 360]]),
np.array([[0, 27, 329, 155]]), np.array([[8, 40, 499, 289]])]
gt_classes_all = [np.array([3]), np.array([16]), np.array([7]), np.array([12])]
data = []
for idx, im_name in enumerate(image_names):
assert os.path.exists(cur_path + '/../demo/deform_psroi/' + im_name), \
('%s does not exist'.format('../demo/deform_psroi/' + im_name))
im = cv2.imread(cur_path + '/../demo/deform_psroi/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
image_all.append(im)
target_size = config.SCALES[0][0]
max_size = config.SCALES[0][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
gt_boxes = gt_boxes_all[idx]
gt_boxes = np.round(gt_boxes * im_scale)
data.append({'data': im_tensor, 'rois': np.hstack((np.zeros((gt_boxes.shape[0], 1)), gt_boxes))})
# get predictor
data_names = ['data', 'rois']
label_names = []
data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))]
max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]]
provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))]
provide_label = [None for i in xrange(len(data))]
arg_params, aux_params = load_param(cur_path + '/../model/deform_psroi', 0, process=True)
predictor = Predictor(sym, data_names, label_names,
context=[mx.gpu(0)], max_data_shapes=max_data_shape,
provide_data=provide_data, provide_label=provide_label,
arg_params=arg_params, aux_params=aux_params)
# test
for idx, _ in enumerate(image_names):
data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx,
provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]],
provide_label=[None])
output = predictor.predict(data_batch)
cls_offset = output[0]['rfcn_cls_offset_output'].asnumpy()
im = image_all[idx]
im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
boxes = gt_boxes_all[idx]
show_dpsroi_offset(im, boxes, cls_offset, gt_classes_all[idx])
Example #15
| Source File: dataset.py From 3DMPPE_ROOTNET_RELEASE with MIT License | 4 votes |
|
def __getitem__(self, index):
joints_have_depth = self.joints_have_depth
data = copy.deepcopy(self.db[index])
bbox = data['bbox']
root_img = np.array(data['root_img'])
root_vis = np.array(data['root_vis'])
area = data['area']
f = data['f']
# 1. load image
cvimg = cv2.imread(data['img_path'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
if not isinstance(cvimg, np.ndarray):
raise IOError("Fail to read %s" % data['img_path'])
img_height, img_width, img_channels = cvimg.shape
# 2. get augmentation params
if self.do_augment:
rot, do_flip, color_scale = get_aug_config()
else:
rot, do_flip, color_scale = 0, False, [1.0, 1.0, 1.0]
# 3. crop patch from img and perform data augmentation (flip, rot, color scale)
img_patch, trans = generate_patch_image(cvimg, bbox, do_flip, rot)
for i in range(img_channels):
img_patch[:, :, i] = np.clip(img_patch[:, :, i] * color_scale[i], 0, 255)
# 4. generate patch joint, area_ratio, and ground truth
# flip joints and apply Affine Transform on joints
if do_flip:
root_img[0] = img_width - root_img[0] - 1
root_img[0:2] = trans_point2d(root_img[0:2], trans)
root_vis *= (
(root_img[0] >= 0) & \
(root_img[0] < cfg.input_shape[1]) & \
(root_img[1] >= 0) & \
(root_img[1] < cfg.input_shape[0])
)
# change coordinates to output space
root_img[0] = root_img[0] / cfg.input_shape[1] * cfg.output_shape[1]
root_img[1] = root_img[1] / cfg.input_shape[0] * cfg.output_shape[0]
if self.is_train:
img_patch = self.transform(img_patch)
k_value = np.array([math.sqrt(cfg.bbox_real[0]*cfg.bbox_real[1]*f[0]*f[1]/(area))]).astype(np.float32)
root_img = root_img.astype(np.float32)
root_vis = root_vis.astype(np.float32)
joints_have_depth = np.array([joints_have_depth]).astype(np.float32)
return img_patch, k_value, root_img, root_vis, joints_have_depth
else:
img_patch = self.transform(img_patch)
k_value = np.array([math.sqrt(cfg.bbox_real[0]*cfg.bbox_real[1]*f[0]*f[1]/(area))]).astype(np.float32)
return img_patch, k_value
Example #16
| Source File: deform_psroi_demo.py From kaggle-rsna18 with MIT License | 4 votes |
|
def main():
# get symbol
pprint.pprint(config)
sym_instance = eval(config.symbol + '.' + config.symbol)()
sym = sym_instance.get_symbol_rfcn(config, is_train=False)
# load demo data
image_names = ['000057.jpg', '000149.jpg', '000351.jpg', '002535.jpg']
image_all = []
# ground truth boxes
gt_boxes_all = [np.array([[132, 52, 384, 357]]), np.array([[113, 1, 350, 360]]),
np.array([[0, 27, 329, 155]]), np.array([[8, 40, 499, 289]])]
gt_classes_all = [np.array([3]), np.array([16]), np.array([7]), np.array([12])]
data = []
for idx, im_name in enumerate(image_names):
assert os.path.exists(cur_path + '/../demo/deform_psroi/' + im_name), \
('%s does not exist'.format('../demo/deform_psroi/' + im_name))
im = cv2.imread(cur_path + '/../demo/deform_psroi/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
image_all.append(im)
target_size = config.SCALES[0][0]
max_size = config.SCALES[0][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
gt_boxes = gt_boxes_all[idx]
gt_boxes = np.round(gt_boxes * im_scale)
data.append({'data': im_tensor, 'rois': np.hstack((np.zeros((gt_boxes.shape[0], 1)), gt_boxes))})
# get predictor
data_names = ['data', 'rois']
label_names = []
data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))]
max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]]
provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))]
provide_label = [None for i in xrange(len(data))]
arg_params, aux_params = load_param(cur_path + '/../model/deform_psroi', 0, process=True)
predictor = Predictor(sym, data_names, label_names,
context=[mx.gpu(0)], max_data_shapes=max_data_shape,
provide_data=provide_data, provide_label=provide_label,
arg_params=arg_params, aux_params=aux_params)
# test
for idx, _ in enumerate(image_names):
data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx,
provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]],
provide_label=[None])
output = predictor.predict(data_batch)
cls_offset = output[0]['rfcn_cls_offset_output'].asnumpy()
im = image_all[idx]
im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
boxes = gt_boxes_all[idx]
show_dpsroi_offset(im, boxes, cls_offset, gt_classes_all[idx])
Example #17
| Source File: deform_conv_demo.py From kaggle-rsna18 with MIT License | 4 votes |
|
def main():
# get symbol
pprint.pprint(config)
sym_instance = eval(config.symbol + '.' + config.symbol)()
sym = sym_instance.get_symbol(config, is_train=False)
# load demo data
image_names = ['000240.jpg', '000437.jpg', '004072.jpg', '007912.jpg']
image_all = []
data = []
for im_name in image_names:
assert os.path.exists(cur_path + '/../demo/deform_conv/' + im_name), \
('%s does not exist'.format('../demo/deform_conv/' + im_name))
im = cv2.imread(cur_path + '/../demo/deform_conv/' + im_name, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
image_all.append(im)
target_size = config.SCALES[0][0]
max_size = config.SCALES[0][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
im_info = np.array([[im_tensor.shape[2], im_tensor.shape[3], im_scale]], dtype=np.float32)
data.append({'data': im_tensor, 'im_info': im_info})
# get predictor
data_names = ['data', 'im_info']
label_names = []
data = [[mx.nd.array(data[i][name]) for name in data_names] for i in xrange(len(data))]
max_data_shape = [[('data', (1, 3, max([v[0] for v in config.SCALES]), max([v[1] for v in config.SCALES])))]]
provide_data = [[(k, v.shape) for k, v in zip(data_names, data[i])] for i in xrange(len(data))]
provide_label = [None for i in xrange(len(data))]
arg_params, aux_params = load_param(cur_path + '/../model/deform_conv', 0, process=True)
predictor = Predictor(sym, data_names, label_names,
context=[mx.gpu(0)], max_data_shapes=max_data_shape,
provide_data=provide_data, provide_label=provide_label,
arg_params=arg_params, aux_params=aux_params)
# test
for idx, _ in enumerate(image_names):
data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx,
provide_data=[[(k, v.shape) for k, v in zip(data_names, data[idx])]],
provide_label=[None])
output = predictor.predict(data_batch)
res5a_offset = output[0]['res5a_branch2b_offset_output'].asnumpy()
res5b_offset = output[0]['res5b_branch2b_offset_output'].asnumpy()
res5c_offset = output[0]['res5c_branch2b_offset_output'].asnumpy()
im = image_all[idx]
im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
show_dconv_offset(im, [res5c_offset, res5b_offset, res5a_offset])
Example #18
| Source File: eval.py From cvToolkit with MIT License | 4 votes |
|
def PreProcess(image, bboxs, scores, cfg, thred_score=0.1):
if type(image) == str:
data_numpy = cv2.imread(image, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
else:
data_numpy = image
inputs = []
centers = []
scales = []
score_num = np.sum(scores>thred_score)
max_box = min(100, score_num)
for bbox in bboxs[:max_box]:
x1,y1,x2,y2 = bbox
box = [x1, y1, x2-x1, y2-y1]
# 截取 box from image --> return center, scale
c, s = _box2cs(box, data_numpy.shape[0], data_numpy.shape[1])
centers.append(c)
scales.append(s)
r = 0
trans = get_affine_transform(c, s, r, cfg.MODEL.IMAGE_SIZE)
# 通过仿射变换截取人体图片
input = cv2.warpAffine(
data_numpy,
trans,
(int(cfg.MODEL.IMAGE_SIZE[0]), int(cfg.MODEL.IMAGE_SIZE[1])),
flags=cv2.INTER_LINEAR)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
input = transform(input).unsqueeze(0)
inputs.append(input)
inputs = torch.cat(inputs)
return inputs, data_numpy, centers, scales
###### Pose-process
Example #19
| Source File: MSCOCO.py From 3DMPPE_POSENET_RELEASE with MIT License | 4 votes |
|
def evaluate(self, preds, result_dir):
print('Evaluation start...')
gts = self.data
sample_num = len(preds)
joint_num = self.original_joint_num
pred_2d_save = {}
pred_3d_save = {}
for n in range(sample_num):
gt = gts[n]
f = gt['f']
c = gt['c']
bbox = gt['bbox']
gt_3d_root = gt['root_cam']
img_name = gt['img_path'].split('/')
img_name = 'coco_' + img_name[-1].split('.')[0] # e.g., coco_00000000
# restore coordinates to original space
pred_2d_kpt = preds[n].copy()
# only consider eval_joint
pred_2d_kpt = np.take(pred_2d_kpt, self.eval_joint, axis=0)
pred_2d_kpt[:,0] = pred_2d_kpt[:,0] / cfg.output_shape[1] * bbox[2] + bbox[0]
pred_2d_kpt[:,1] = pred_2d_kpt[:,1] / cfg.output_shape[0] * bbox[3] + bbox[1]
pred_2d_kpt[:,2] = (pred_2d_kpt[:,2] / cfg.depth_dim * 2 - 1) * (cfg.bbox_3d_shape[0]/2) + gt_3d_root[2]
# 2d kpt save
if img_name in pred_2d_save:
pred_2d_save[img_name].append(pred_2d_kpt[:,:2])
else:
pred_2d_save[img_name] = [pred_2d_kpt[:,:2]]
vis = False
if vis:
cvimg = cv2.imread(gt['img_path'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
filename = str(random.randrange(1,500))
tmpimg = cvimg.copy().astype(np.uint8)
tmpkps = np.zeros((3,joint_num))
tmpkps[0,:], tmpkps[1,:] = pred_2d_kpt[:,0], pred_2d_kpt[:,1]
tmpkps[2,:] = 1
tmpimg = vis_keypoints(tmpimg, tmpkps, self.skeleton)
cv2.imwrite(filename + '_output.jpg', tmpimg)
# back project to camera coordinate system
pred_3d_kpt = pixel2cam(pred_2d_kpt, f, c)
# 3d kpt save
if img_name in pred_3d_save:
pred_3d_save[img_name].append(pred_3d_kpt)
else:
pred_3d_save[img_name] = [pred_3d_kpt]
output_path = osp.join(result_dir,'preds_2d_kpt_coco.mat')
sio.savemat(output_path, pred_2d_save)
print("Testing result is saved at " + output_path)
output_path = osp.join(result_dir,'preds_3d_kpt_coco.mat')
sio.savemat(output_path, pred_3d_save)
print("Testing result is saved at " + output_path)
Example #20
| Source File: image.py From Sequence-Level-Semantics-Aggregation with Apache License 2.0 | 4 votes |
|
def get_pair_image(roidb, config):
"""
preprocess image and return processed roidb
:param roidb: a list of roidb
:return: list of img as in mxnet format
roidb add new item['im_info']
0 --- x (width, second dim of im)
|
y (height, first dim of im)
"""
num_images = len(roidb)
processed_ims = []
processed_ref_ims = []
processed_eq_flags = []
processed_roidb = []
for i in range(num_images):
roi_rec = roidb[i]
eq_flag = 0 # 0 for unequal, 1 for equal
assert os.path.exists(roi_rec['image']), '%s does not exist'.format(roi_rec['image'])
im = cv2.imread(roi_rec['image'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
if roi_rec.has_key('pattern'):
ref_id = min(
max(roi_rec['frame_seg_id'] + np.random.randint(config.TRAIN.MIN_OFFSET, config.TRAIN.MAX_OFFSET + 1),
0), roi_rec['frame_seg_len'] - 1)
ref_image = roi_rec['pattern'] % ref_id
assert os.path.exists(ref_image), '%s does not exist'.format(ref_image)
ref_im = cv2.imread(ref_image, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
if ref_id == roi_rec['frame_seg_id']:
eq_flag = 1
else:
ref_im = im.copy()
eq_flag = 1
if roidb[i]['flipped']:
im = im[:, ::-1, :]
ref_im = ref_im[:, ::-1, :]
new_rec = roi_rec.copy()
scale_ind = random.randrange(len(config.SCALES))
target_size = config.SCALES[scale_ind][0]
max_size = config.SCALES[scale_ind][1]
im, im_scale = resize(im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
ref_im, im_scale = resize(ref_im, target_size, max_size, stride=config.network.IMAGE_STRIDE)
im_tensor = transform(im, config.network.PIXEL_MEANS)
ref_im_tensor = transform(ref_im, config.network.PIXEL_MEANS)
processed_ims.append(im_tensor)
processed_ref_ims.append(ref_im_tensor)
processed_eq_flags.append(eq_flag)
im_info = [im_tensor.shape[2], im_tensor.shape[3], im_scale]
new_rec['boxes'] = roi_rec['boxes'].copy() * im_scale
new_rec['im_info'] = im_info
processed_roidb.append(new_rec)
return processed_ims, processed_ref_ims, processed_eq_flags, processed_roidb
Example #21
| Source File: utilitys.py From hrnet with MIT License | 4 votes |
|
def PreProcess(image, bboxs, scores, cfg, thred_score=0.1):
if type(image) == str:
data_numpy = cv2.imread(image, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
else:
data_numpy = image
data_numpy = cv2.cvtColor(data_numpy, cv2.COLOR_BGR2RGB)
inputs = []
centers = []
scales = []
score_num = np.sum(scores>thred_score)
max_box = min(100, score_num)
for bbox in bboxs[:max_box]:
x1,y1,x2,y2 = bbox
box = [x1, y1, x2-x1, y2-y1]
# 截取 box from image --> return center, scale
c, s = _box2cs(box, data_numpy.shape[0], data_numpy.shape[1])
centers.append(c)
scales.append(s)
r = 0
trans = get_affine_transform(c, s, r, cfg.MODEL.IMAGE_SIZE)
# 通过仿射变换截取人体图片
input = cv2.warpAffine(
data_numpy,
trans,
(int(cfg.MODEL.IMAGE_SIZE[0]), int(cfg.MODEL.IMAGE_SIZE[1])),
flags=cv2.INTER_LINEAR)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
input = transform(input).unsqueeze(0)
inputs.append(input)
inputs = torch.cat(inputs)
return inputs, data_numpy, centers, scales
Example #22
| Source File: pose_utils.py From hrnet with MIT License | 4 votes |
|
def PreProcess(image, bboxs, scores, cfg, thred_score=0.6):
if type(image) == str:
data_numpy = cv2.imread(image, cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
else:
data_numpy = image
inputs = []
centers = []
scales = []
score_num = np.sum(scores>thred_score)
max_box = min(100, score_num)
for bbox in bboxs[:max_box]:
x1,y1,x2,y2 = bbox
box = [x1, y1, x2-x1, y2-y1]
# 截取 box from image --> return center, scale
c, s = _box2cs(box, data_numpy.shape[0], data_numpy.shape[1])
centers.append(c)
scales.append(s)
r = 0
trans = get_affine_transform(c, s, r, cfg.MODEL.IMAGE_SIZE)
# 通过仿射变换截取人体图片
input = cv2.warpAffine(
data_numpy,
trans,
(int(cfg.MODEL.IMAGE_SIZE[0]), int(cfg.MODEL.IMAGE_SIZE[1])),
flags=cv2.INTER_LINEAR)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
input = transform(input).unsqueeze(0)
inputs.append(input)
inputs = torch.cat(inputs)
return inputs, data_numpy, centers, scales
# --------------------------FOR TRACKING ------------------------------------
Example #23
| Source File: panda3d.py From ImageAnalysis with MIT License | 4 votes |
|
def make_textures_opencv(src_dir, analysis_dir, image_list, resolution=512):
dst_dir = os.path.join(analysis_dir, 'models')
if not os.path.exists(dst_dir):
log("Notice: creating texture directory =", dst_dir)
os.makedirs(dst_dir)
for image in image_list:
src = image.image_file
dst = os.path.join(dst_dir, image.name + '.JPG')
log(src, '->', dst)
if not os.path.exists(dst):
src = cv2.imread(src, flags=cv2.IMREAD_ANYCOLOR|cv2.IMREAD_ANYDEPTH|cv2.IMREAD_IGNORE_ORIENTATION)
height, width = src.shape[:2]
# downscale image first
method = cv2.INTER_AREA # cv2.INTER_AREA
scale = cv2.resize(src, (0,0),
fx=resolution/float(width),
fy=resolution/float(height),
interpolation=method)
do_equalize = False
if do_equalize:
# convert to hsv color space
hsv = cv2.cvtColor(scale, cv2.COLOR_BGR2HSV)
hue,sat,val = cv2.split(hsv)
# adaptive histogram equalization on 'value' channel
clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
aeq = clahe.apply(val)
# recombine
hsv = cv2.merge((hue,sat,aeq))
# convert back to rgb
result = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
else:
result = scale
cv2.imwrite(dst, result)
qlog("Texture %dx%d %s" % (resolution, resolution, dst))
# make the dummy.jpg image from the first texture
#src = os.path.join(dst_dir, image_list[0].image_file)
src = image_list[0].image_file
dst = os.path.join(dst_dir, "dummy.jpg")
log("Dummy:", src, dst)
if not os.path.exists(dst):
src = cv2.imread(src, flags=cv2.IMREAD_ANYCOLOR|cv2.IMREAD_ANYDEPTH|cv2.IMREAD_IGNORE_ORIENTATION)
height, width = src.shape[:2]
# downscale image first
method = cv2.INTER_AREA # cv2.INTER_AREA
resolution = 64
dummy = cv2.resize(src, (0,0),
fx=resolution/float(width),
fy=resolution/float(height),
interpolation=method)
cv2.imwrite(dst, dummy)
qlog("Texture %dx%d %s" % (resolution, resolution, dst))
Example #24
| Source File: MuPoTS.py From 3DMPPE_POSENET_RELEASE with MIT License | 4 votes |
|
def evaluate(self, preds, result_dir):
print('Evaluation start...')
gts = self.data
sample_num = len(preds)
joint_num = self.original_joint_num
pred_2d_save = {}
pred_3d_save = {}
for n in range(sample_num):
gt = gts[n]
f = gt['f']
c = gt['c']
bbox = gt['bbox']
gt_3d_root = gt['root_cam']
img_name = gt['img_path'].split('/')
img_name = img_name[-2] + '_' + img_name[-1].split('.')[0] # e.g., TS1_img_0001
# restore coordinates to original space
pred_2d_kpt = preds[n].copy()
# only consider eval_joint
pred_2d_kpt = np.take(pred_2d_kpt, self.eval_joint, axis=0)
pred_2d_kpt[:,0] = pred_2d_kpt[:,0] / cfg.output_shape[1] * bbox[2] + bbox[0]
pred_2d_kpt[:,1] = pred_2d_kpt[:,1] / cfg.output_shape[0] * bbox[3] + bbox[1]
pred_2d_kpt[:,2] = (pred_2d_kpt[:,2] / cfg.depth_dim * 2 - 1) * (cfg.bbox_3d_shape[0]/2) + gt_3d_root[2]
# 2d kpt save
if img_name in pred_2d_save:
pred_2d_save[img_name].append(pred_2d_kpt[:,:2])
else:
pred_2d_save[img_name] = [pred_2d_kpt[:,:2]]
vis = False
if vis:
cvimg = cv2.imread(gt['img_path'], cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
filename = str(random.randrange(1,500))
tmpimg = cvimg.copy().astype(np.uint8)
tmpkps = np.zeros((3,joint_num))
tmpkps[0,:], tmpkps[1,:] = pred_2d_kpt[:,0], pred_2d_kpt[:,1]
tmpkps[2,:] = 1
tmpimg = vis_keypoints(tmpimg, tmpkps, self.skeleton)
cv2.imwrite(filename + '_output.jpg', tmpimg)
# back project to camera coordinate system
pred_3d_kpt = pixel2cam(pred_2d_kpt, f, c)
# 3d kpt save
if img_name in pred_3d_save:
pred_3d_save[img_name].append(pred_3d_kpt)
else:
pred_3d_save[img_name] = [pred_3d_kpt]
output_path = osp.join(result_dir,'preds_2d_kpt_mupots.mat')
sio.savemat(output_path, pred_2d_save)
print("Testing result is saved at " + output_path)
output_path = osp.join(result_dir,'preds_3d_kpt_mupots.mat')
sio.savemat(output_path, pred_3d_save)
print("Testing result is saved at " + output_path)
