def load_timg(file_name): """Loads the image with OpenCV and converts to torch.Tensor.""" assert os.path.isfile(file_name), f"Invalid file {file_name}" # nosec # load image with OpenCV img = cv2.imread(file_name, cv2.IMREAD_COLOR) # convert image to torch tensor tensor = K.image_to_tensor(img, None).float() / 255. return K.color.bgr_to_rgb(tensor)
def my_app(args): # select the device device = torch.device('cpu') if args.cuda and torch.cuda.is_available(): device = torch.device('cuda:0') # load the image and scale img_raw = cv2.imread(args.image_file, cv2.IMREAD_COLOR) img_raw = scale_image(img_raw, args.image_size) # preprocess img = K.image_to_tensor(img_raw, keepdim=False).to(device) img = K.color.bgr_to_rgb(img.float()) # create the detector and find the faces ! face_detection = FaceDetector().to(device) with torch.no_grad(): dets = face_detection(img) dets = [FaceDetectorResult(o) for o in dets] # show image img_vis = img_raw.copy() for b in dets: if b.score < args.vis_threshold: continue # draw face bounding box img_vis = cv2.rectangle(img_vis, b.top_left.int().tolist(), b.bottom_right.int().tolist(), (0, 255, 0), 4) if args.blur_faces: apply_blur_face(img, img_vis, b) if args.vis_keypoints: # draw facial keypoints img_vis = draw_keypoint(img_vis, b, FaceKeypoint.EYE_LEFT) img_vis = draw_keypoint(img_vis, b, FaceKeypoint.EYE_RIGHT) img_vis = draw_keypoint(img_vis, b, FaceKeypoint.NOSE) img_vis = draw_keypoint(img_vis, b, FaceKeypoint.MOUTH_LEFT) img_vis = draw_keypoint(img_vis, b, FaceKeypoint.MOUTH_RIGHT) # draw the text score cx = int(b.xmin) cy = int(b.ymin + 12) img_vis = cv2.putText(img_vis, f"{b.score:.2f}", (cx, cy), cv2.FONT_HERSHEY_DUPLEX, 0.5, (255, 255, 255)) # save and show image cv2.imwrite(args.image_out, img_vis) cv2.namedWindow('face_detection', cv2.WINDOW_NORMAL) cv2.imshow('face_detection', img_vis) cv2.waitKey(0)
def generate_patch(self, size=(300, 400)): """ Generate a random patch as a starting point for optimization. """ # adv_patch_cpu = (mu + sigma * torch.randn(3, size[0], size[1])).clamp(0,255) adv_patch_cpu = cv2.resize(cv2.imread('data/patchnew0.jpg'), (size[1], size[0])) # W, H adv_patch_cpu = kornia.image_to_tensor(patch).to(torch.float) return adv_patch_cpu
def _process_img(self, image): # resized_image = cv2.resize(image, (self.m.width, self.m.height)) img = kornia.image_to_tensor(image).to(self.device).type(self.dtype) img = kornia.bgr_to_rgb(img) img = img.div(255.0).unsqueeze(0) resized_image = F.interpolate(img, size=(self.m.width, self.m.height), mode='nearest') return resized_image
def __getitem__(self, idx): # Horizontal flip (Until Kornia will handle videos hflip = random.random() < 0.5 if self.opt.hflip else False images = self.generate_image(self.opt.scale_idx) images = K.image_to_tensor(images).float() images = images / 255 # Set range [0, 1] images_transformed = self._get_transformed_images(images, hflip) # Extract o-level index if self.opt.scale_idx > 0: images_zero_scale = self.generate_image(0) images_zero_scale = K.image_to_tensor(images_zero_scale).float() images_zero_scale = images_zero_scale / 255 images_zero_scale_transformed = self._get_transformed_images(images_zero_scale, hflip) return [images_transformed, images_zero_scale_transformed] return images_transformed
def load_data_to_gpu(batch_dict): for key, val in batch_dict.items(): if not isinstance(val, np.ndarray): continue if key in ['frame_id', 'metadata', 'calib']: continue if key in ['images']: batch_dict[key] = kornia.image_to_tensor(val).float().cuda() elif key in ['image_shape']: batch_dict[key] = torch.from_numpy(val).int().cuda() else: batch_dict[key] = torch.from_numpy(val).float().cuda()
def test_rgb_to_hls(self, device): data = torch.rand(3, 5, 5).to(device) # OpenCV data_cv = kornia.tensor_to_image(data.clone()) expected = cv2.cvtColor(data_cv, cv2.COLOR_RGB2HLS) expected = kornia.image_to_tensor(expected, True).to(device) expected[0] = 2 * math.pi * expected[0] / 360. f = kornia.color.RgbToHls() assert_allclose(f(data), expected)
def tracker_init(im, target_pos, target_sz, model, device='cpu'): state = dict() state['im_h'] = im.shape[0] state['im_w'] = im.shape[1] # initialize the exemplar model.template(kornia.image_to_tensor(im).to(device).float(), torch.from_numpy(target_pos).to(device), torch.from_numpy(target_sz).to(device) ) state['target_pos'] = target_pos state['target_sz'] = target_sz return state
def gen_xcrop(self): # state = self.state # im_pert_template = state['im_pert_template'] # pert_sz_ratio = state['pert_sz_ratio'] # p = state['p'] # im_shape = state['im'].shape[0:2] # bbox_pert_xcrop = scale_bbox(state['gts'][state['n_frame']], pert_sz_ratio) # mask_xcrop = get_bbox_mask(shape=im_shape, bbox=bbox_pert_xcrop, mode='tensor').to(state['device']) # bbox_pert_temp = scale_bbox(state['gts'][0], pert_sz_ratio) # bbox_pert_xcrop = scale_bbox(state['gts'][state['n_frame']], pert_sz_ratio) # im_pert_warped = warp(im_pert_template, bbox_pert_temp, bbox_pert_xcrop) # im_xcrop = kornia.image_to_tensor(state['im']).to(state['device']) # im_pert_xcrop = im_xcrop * (1-mask_xcrop) + im_pert_warped * mask_xcrop # x_crop = test.get_subwindow_tracking_(im_pert_xcrop, state['target_pos'], p.instance_size, round(self.s_x), 0) state = self.state pert = state['pert'] pert_sz_ratio = state['pert_sz_ratio'] p = state['p'] device = state['device'] im_shape = state['im'].shape[0:2] bbox_pert_xcrop = scale_bbox(state['gts'][state['n_frame']], pert_sz_ratio) mask_xcrop = get_bbox_mask(shape=im_shape, bbox=bbox_pert_xcrop, mode='tensor').to(device) bbox_pert_xcrop = torch.tensor(bbox_pert_xcrop).unsqueeze( dim=0).to(device) im_xcrop = kornia.image_to_tensor(state['im']).to( torch.float).unsqueeze(dim=0).to(device) patch_warped_search = warp_patch(pert, im_xcrop, bbox_pert_xcrop) patch_search = torch.where(mask_xcrop == 1, patch_warped_search, im_xcrop) x_crop = test.get_subwindow_tracking_(patch_search, state['target_pos'], p.instance_size, round(self.s_x), 0) cv2.imshow('template', kornia.tensor_to_image(state['pert_template'].byte())) cv2.imshow('x_crop', kornia.tensor_to_image(x_crop.byte())) cv2.waitKey(1) return state['pert_template'], x_crop
def get_local_descriptors(img, cv2_sift_kpts, kornia_descriptor, aff): #We will not train anything, so let's save time and memory by no_grad() with torch.no_grad(): timg = K.color.rgb_to_grayscale(K.image_to_tensor(img, False)) / 255. timg = timg.cuda() lafs = laf_from_opencv_SIFT_kpts(cv2_sift_kpts).cuda() angles = KF.laf.get_laf_orientation(lafs) # We will estimate affine shape of the feature and re-orient the keypoints with the OriNet lafs_new = aff(lafs, timg) patches = KF.extract_patches_from_pyramid(timg, lafs_new, 32) B, N, CH, H, W = patches.size() # Descriptor accepts standard tensor [B, CH, H, W], while patches are [B, N, CH, H, W] shape # So we need to reshape a bit :) descs = kornia_descriptor(patches.view(B * N, CH, H, W)).view(B * N, -1) return descs.detach().cpu().numpy()
def test_batch_rgb_to_hls(self, device): data = torch.rand(3, 5, 5).to(device) # OpenCV data_cv = kornia.tensor_to_image(data.clone()) expected = cv2.cvtColor(data_cv, cv2.COLOR_RGB2HLS) expected = kornia.image_to_tensor(expected, False).to(device) expected[:, 0] = 2 * math.pi * expected[:, 0] / 360. # Kornia f = kornia.color.RgbToHls() data = data.repeat(2, 1, 1, 1) # 2x3x5x5 expected = expected.repeat(2, 1, 1, 1) # 2x3x5x5 assert_allclose(f(data), expected)
def main(): try: img_bgr: np.ndarray = cv2.imread('model8.png', cv2.IMREAD_COLOR) x_bgr: torch.Tensor = kornia.image_to_tensor(img_bgr) x_rgb: torch.Tensor = kornia.bgr_to_rgb(x_bgr) x_rgb = x_rgb.expand(2, -1, -1, -1) x_rgb = x_rgb.float() / 255. imshow(x_rgb) # Box Blur x_blur: torch.Tensor = kornia.box_blur(x_rgb, (9, 9)) imshow(x_blur) # Median Blur x_blur: torch.Tensor = kornia.median_blur(x_rgb, (5, 5)) imshow(x_blur) # Gaussian Blur x_blur: torch.Tensor = kornia.gaussian_blur2d(x_rgb, (11, 11), (11., 11.)) imshow(x_blur) except: print("Error found")
def extract_features(self, im): kpts = self.det.detect(im, None) # We will not train anything, so let's save time and memory by no_grad() with torch.no_grad(): timg = K.image_to_tensor(im, False).float() / 255. timg = timg.to(self.device) if timg.shape[1] == 3: timg_gray = K.rgb_to_grayscale(timg) else: timg_gray = timg # kornia expects keypoints in the local affine frame format. # Luckily, kornia_moons has a conversion function lafs = laf_from_opencv_SIFT_kpts(kpts, device=self.device) lafs_new = self.aff(lafs, timg_gray) patches = KF.extract_patches_from_pyramid(timg_gray, lafs_new, 32) B, N, CH, H, W = patches.size() # Descriptor accepts standard tensor [B, CH, H, W], while patches are [B, N, CH, H, W] shape # So we need to reshape a bit :) descs = self.desc(patches.view(B * N, CH, H, W)).view(B * N, -1).detach().cpu().numpy() kpts = np.array([[kp.pt[0], kp.pt[1]] for kp in kpts]) return kpts, descs
def test_rgb_to_hsv(self, device): data = torch.rand(3, 5, 5).to(device) # OpenCV data_cv = kornia.tensor_to_image(data.clone()) expected = cv2.cvtColor(data_cv, cv2.COLOR_RGB2HSV) expected = kornia.image_to_tensor(expected, True).to(device) h_expected = 2 * math.pi * expected[0] / 360. s_expected = expected[1] v_expected = expected[2] f = kornia.color.RgbToHsv() result = f(data) h = result[0, :, :] s = result[1, :, :] v = result[2, :, :] assert_allclose(h, h_expected) assert_allclose(s, s_expected) assert_allclose(v, v_expected)
def tracker_track(state, im, model, device='cpu', debug=False): target_pos = state['target_pos'] target_sz = state['target_sz'] p = model.p wc_x = target_sz[1] + p.context_amount * sum(target_sz) hc_x = target_sz[0] + p.context_amount * sum(target_sz) s_x = np.sqrt(wc_x * hc_x) scale_x = p.exemplar_size / s_x pscore, delta, pscore_size = model.track(kornia.image_to_tensor(im).unsqueeze(dim=0).to(device).float(), torch.from_numpy(target_pos).unsqueeze(dim=0).to(device), torch.from_numpy(target_sz).unsqueeze(dim=0).to(device)) best_pscore_id = np.argmax(pscore.squeeze().detach().cpu().numpy()) pred_in_crop = delta.squeeze().detach().cpu().numpy()[:, best_pscore_id] / scale_x lr = pscore_size.squeeze().detach().cpu().numpy()[best_pscore_id] * p.lr # lr for OTB res_x = pred_in_crop[0] + target_pos[0] res_y = pred_in_crop[1] + target_pos[1] res_w = target_sz[0] * (1 - lr) + pred_in_crop[2] * lr res_h = target_sz[1] * (1 - lr) + pred_in_crop[3] * lr target_pos = np.array([res_x, res_y]) target_sz = np.array([res_w, res_h]) target_pos[0] = max(0, min(state['im_w'], target_pos[0])) target_pos[1] = max(0, min(state['im_h'], target_pos[1])) target_sz[0] = max(10, min(state['im_w'], target_sz[0])) target_sz[1] = max(10, min(state['im_h'], target_sz[1])) state['target_pos'] = target_pos state['target_sz'] = target_sz return state
def crop_chw_torch(image, bbox, out_sz, device='cpu'): a = (out_sz - 1) / (bbox[2] - bbox[0]) b = (out_sz - 1) / (bbox[3] - bbox[1]) c = -a * bbox[0] d = -b * bbox[1] mapping = torch.tensor([[a, 0, c], [0, b, d]], device=device).unsqueeze(0) return kornia.warp_affine(image, mapping, dsize=(out_sz, out_sz), ) if __name__ == '__main__': bbox = np.array([250, 250, 300, 300]) out_size = 125 x = np.random.randn(600, 600, 3) y: torch.tensor = kornia.image_to_tensor(x, keepdim=False) # .to('cuda') # BxCxHxW # a = crop_chw(x, bbox, out_size) # b = crop_chw_torch(x, bbox, out_size) # print(a.shape) # print(b.shape) import torch.utils.benchmark as benchmark t0 = benchmark.Timer( stmt='crop_chw(x, box, 125)', setup='from __main__ import crop_chw', globals={'x': x, 'box':np.array([250, 250, 300, 300])}) t1 = benchmark.Timer(
import torch import kornia import cv2 import numpy as np import torchvision import matplotlib.pyplot as plt # read the image with OpenCV img: np.ndarray = cv2.imread('./download.png') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # convert to torch tensor data: torch.tensor = kornia.image_to_tensor(img, keepdim=False) # BxCxHxW # create the operator gauss = kornia.filters.GaussianBlur2d((11, 11), (10.5, 10.5)) # blur the image x_blur: torch.tensor = gauss(data.float()) # convert back to numpy img_blur: np.ndarray = kornia.tensor_to_image(x_blur.byte()) # Create the plot fig, axs = plt.subplots(1, 2, figsize=(16, 10)) axs = axs.ravel() axs[0].axis('off') axs[0].set_title('image source') axs[0].imshow(img)
def gen_template(self): num_iters = 500 adam_lr = 10 mu, sigma = 127, 5 label_thr_iou = 0.2 pert_sz_ratio = (0.6, 0.3) # Load state state = self.state device = state['device'] p = state['p'] s_z = state['s_z'] # Get imgs and mask tensor im_shape = state['im'].shape[0:2] bbox_pert_temp = scale_bbox(state['gts'][0], pert_sz_ratio) bbox_pert_xcrop = scale_bbox(state['gts'][state['n_frame']], pert_sz_ratio) mask_template = get_bbox_mask(shape=im_shape, bbox=bbox_pert_temp, mode='tensor').to(device) mask_xcrop = get_bbox_mask(shape=im_shape, bbox=bbox_pert_xcrop, mode='tensor').to(device) im_template = kornia.image_to_tensor(state['first_im']).to(device) im_xcrop = kornia.image_to_tensor(state['im']).to(device) # Get Label track_res, score_res, pscore_res = self.get_tracking_result( state['template'], self.x_crop) labels = self.get_label(track_res, thr_iou=label_thr_iou, need_iou=True) im_template = im_template.unsqueeze(dim=0).to(torch.float) im_xcrop = im_xcrop.unsqueeze(dim=0).to(torch.float) bbox_pert_temp = torch.tensor(bbox_pert_temp).unsqueeze( dim=0).to(device) bbox_pert_xcrop = torch.tensor(bbox_pert_xcrop).unsqueeze( dim=0).to(device) pert_sz = (100, 75) # pert = (mu + sigma * torch.randn(3, pert_sz[0], pert_sz[1])).clamp(0,255) pert = cv2.resize(cv2.imread('data/patchnew0.jpg'), (pert_sz[1], pert_sz[0])) # W, H pert = kornia.image_to_tensor(pert).to(torch.float) pert = pert.clone().detach().to(device).requires_grad_(True).to( im_template.device) # (3, H, W) optimizer = torch.optim.Adam([pert], lr=adam_lr) for i in range(num_iters): patch_warped_template = warp_patch(pert, im_template, bbox_pert_temp) patch_warped_search = warp_patch(pert, im_xcrop, bbox_pert_xcrop) patch_template = torch.where(mask_template == 1, patch_warped_template, im_template) patch_search = torch.where(mask_xcrop == 1, patch_warped_search, im_xcrop) template = test.get_subwindow_tracking_(patch_template, state['pos_z'], p.exemplar_size, round(state['s_z']), 0) x_crop = test.get_subwindow_tracking_(patch_search, state['target_pos'], p.instance_size, round(self.s_x), 0) score, delta = self.model.track(x_crop, template) ################### Show Loss and Delta Change ###################### # if i%10==0: # score_data = F.softmax(score.view(score.shape[0], 2, -1), dim=1)[:,1] # delta_data = delta.view(delta.shape[0], 4, -1).data # res_cx, res_cy, res_w, res_h = track_res # track_res_data = (res_cx-res_w/2, res_cy-res_h/2, res_w, res_h) # self.show_pscore_delta(score_data, delta_data, track_res_data) # self.show_attacking(track_res, score_res, pscore_res, template, x_crop) loss = self.loss2(score, delta, pscore_res, labels) optimizer.zero_grad() loss.backward() optimizer.step() pert.data = (pert.data).clamp(0, 255) # fig, ax = plt.subplots(1,2,num='x_crop & template') # ax[0].set_title('template') # ax[0].imshow(kornia.tensor_to_image(template.byte())) # ax[1].set_title('x_crop') # ax[1].imshow(kornia.tensor_to_image(x_crop.byte())) # plt.pause(0.01) state['pert'] = pert.detach() state['pert_template'] = template.detach() state['pert_sz_ratio'] = pert_sz_ratio # self.show_label(labels, track_res) # self.show_attacking(track_res, score_res, pscore_res, template, x_crop) plt.show() return template, x_crop
bbox = [[200, 200, 207, 395], [310, 157, 220, 250]] cv2.namedWindow('img', cv2.WND_PROP_FULLSCREEN) x, y, w, h = bbox[0] cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4) cv2.imshow('img', img) cv2.namedWindow('img2', cv2.WND_PROP_FULLSCREEN) x, y, w, h = bbox[1] cv2.rectangle(img2, (x, y), (x + w, y + h), (0, 255, 0), 4) cv2.imshow('img2', img2) cv2.imshow('patch1', patch1) cv2.imshow('patch2', patch2) img_tensor = kornia.image_to_tensor(img).unsqueeze(0).to(torch.float32) img_tensor2 = kornia.image_to_tensor(img2).unsqueeze(0).to(torch.float32) patch_tensor1 = kornia.image_to_tensor(patch1).to(torch.float32) patch_tensor2 = kornia.image_to_tensor(patch2).to(torch.float32) bbox = torch.tensor(bbox) bbox_dest = scale_bbox(bbox, (0.6, 0.3)) mask = get_bbox_mask_tv(img_tensor.shape[-2:], bbox) cv2.namedWindow('mask1', cv2.WND_PROP_FULLSCREEN) cv2.namedWindow('mask2', cv2.WND_PROP_FULLSCREEN) cv2.imshow('mask1', kornia.tensor_to_image(mask[0])) cv2.imshow('mask2', kornia.tensor_to_image(mask[1])) res_img = warp_patch(torch.stack([patch_tensor1, patch_tensor2], 0), torch.cat([img_tensor, img_tensor2], 0), bbox_dest)
def temporal_bev_image_callback(self, msg): # print("temporal_bev_image_callback") cv_temporal_bev_image = self.bridge.imgmsg_to_cv2(msg, desired_encoding='passthrough') tensor_bev_image = kornia.image_to_tensor(cv_temporal_bev_image, keepdim=True).float() self.temporal_bev_map = tensor_bev_image self.temporal_bev_image_callback_flag = True
import cv2 import numpy as np import torch import torchvision from matplotlib import pyplot as plt import kornia ############################# # We use OpenCV to load an image to memory represented in a numpy.ndarray img_bgr: np.ndarray = cv2.imread('./data/simba.png', cv2.IMREAD_COLOR) ############################# # Convert the numpy array to torch x_bgr: torch.Tensor = kornia.image_to_tensor(img_bgr, keepdim=False) ############################# # Using `kornia` we easily perform color transformation in batch mode. def hflip(input: torch.Tensor) -> torch.Tensor: return torch.flip(input, [-1]) def vflip(input: torch.Tensor) -> torch.Tensor: return torch.flip(input, [-2]) def rot180(input: torch.Tensor) -> torch.Tensor: return torch.flip(input, [-2, -1])
import torch from torch import nn if __name__ == '__main__': import cv2 import kornia from matplotlib import pyplot as plt patch = cv2.imread('data/patchnew0.jpg') patch = kornia.image_to_tensor(patch).to(torch.float) #.unsqueeze(dim=0) # ColorJitter # trans = kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1) # fig, axes = plt.subplots(1,2,num=type(trans).__name__) # for i in range(100): # res = trans(patch/255.0) # ax = axes[0] # ax.set_title('patch') # ax.imshow(kornia.tensor_to_image(patch.byte())) # ax = axes[1] # ax.set_title('res') # ax.imshow(kornia.tensor_to_image(res)) # plt.pause(0.001) # RandomAffine trans = kornia.augmentation.RandomAffine(degrees=5, translate=[0.1, 0.1], scale=[0.9, 1.1], shear=[-5, 5]) for i in range(100): res = trans(patch)
""" import torch import kornia import cv2 import numpy as np import matplotlib.pyplot as plt # read the image with OpenCV img: np.ndarray = cv2.imread('./data/bennett_aden.png') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # convert to torch tensor data: torch.tensor = kornia.image_to_tensor(img) # BxCxHxW # create transformation (rotation) alpha: float = 45.0 # in degrees angle: torch.tensor = torch.ones(1) * alpha # define the rotation center center: torch.tensor = torch.ones(1, 2) center[..., 0] = data.shape[3] / 2 # x center[..., 1] = data.shape[2] / 2 # y # define the scale factor scale: torch.tensor = torch.ones(1) # compute the transformation matrix M: torch.tensor = kornia.get_rotation_matrix2d(center, angle, scale)
def load_img(path): img1 = cv2.imread(path) timg1 = kornia.image_to_tensor(img1, False) timg1 = kornia.color.bgr_to_rgb(timg1) return timg1
def __getitem__(self, item): img = cv2.imread(self.arg.dataset_route[self.dataset] + self.list[item][-1]) img = image_to_tensor(img) img = bgr_to_rgb(img) return img
def test_image_to_tensor_keep_dtype(input_dtype, expected_dtype): image = np.ones((1, 3, 4, 5), dtype=input_dtype) tensor = kornia.image_to_tensor(image) assert tensor.dtype == expected_dtype
def forward(self, x: Tensor) -> Tensor: x = image_to_tensor(np.array(x)).float() / 255. assert len(x.shape) == 3, x.shape out = self.preprocess(x) return out[0]
from matplotlib import pyplot as plt import cv2 import numpy as np import torch import kornia import torchvision ############################# # We use OpenCV to load an image to memory represented in a numpy.ndarray img_bgr: np.ndarray = cv2.imread('./data/ninja_turtles.jpg', cv2.IMREAD_COLOR) ############################# # Convert the numpy array to torch x_bgr: torch.Tensor = kornia.image_to_tensor(img_bgr) x_rgb: torch.Tensor = kornia.bgr_to_rgb(x_bgr) ############################# # Create batch and normalize x_rgb = x_rgb.expand(4, -1, -1, -1) # 4xCxHxW x_rgb = x_rgb.float() / 255. def imshow(input: torch.Tensor): out: torch.Tensor = torchvision.utils.make_grid(input, nrow=2, padding=5) out_np: np.ndarray = kornia.tensor_to_image(out) plt.imshow(out_np) plt.axis('off') plt.show()
def create_image_tensor(image, num, device, dtype): return kornia.image_to_tensor(image, keepdim=False).repeat( num, 1, 1, 1).to(device=get_device_by_string(device), dtype=get_device_by_dtype(dtype))
""" import cv2 import matplotlib.pyplot as plt import numpy as np import torch import kornia ############################# # We use OpenCV to load an image to memory represented in a numpy.ndarray img_bgr: np.ndarray = cv2.imread('./data/arturito.jpeg') # HxWxC ############################# # The image is convert to a 4D torch tensor x_bgr: torch.tensor = kornia.image_to_tensor(img_bgr) # 1xCxHxW ############################# # Once with a torch tensor we can use any Kornia operator x_rgb: torch.tensor = kornia.bgr_to_rgb(x_bgr) # 1xCxHxW ############################# # Convert back to numpy to visualize img_rgb: np.ndarray = kornia.tensor_to_image(x_rgb.byte()) # HxWxC ############################# # We use Matplotlib to visualize de results fig, axs = plt.subplots(1, 2, figsize=(32, 16)) axs = axs.ravel() axs[0].axis('off')