Esempio n. 1
0
def job(fn, gpuid):
    #flow = flowlib.read_flow(fn)
    #newflow = F.interpolate(torch.tensor(flow).to('cuda:{0}'.format(gpuid)).permute(2,0,1).unsqueeze(0), scale_factor=224/min(flow.shape[:-1])).squeeze()
    newfn = fn.replace('scenes', 'scenes_small')
    #if os.path.exists(newfn): return 0
    img = Image.open(fn).convert('RGB')
    os.makedirs(os.path.dirname(newfn), exist_ok=True)
    img = Resize(224)(img)
    img.save(newfn)
    return 0
Esempio n. 2
0
def main():
    CUDA = torch.cuda.is_available()
    opts = opt()
    pose_model = model.poseprosalnet(mpii_dataset.KEYPOINT_NAMES,
                                     mpii_dataset.EDGES, opts.local_grid_size,
                                     opts.insize)
    pose_model.load_state_dict(torch.load(opts.checkpoint))

    pil_image = Image.open(opts.img)
    pil_image = Resize(opts.insize)(pil_image)
    img = ToTensor()(pil_image)
    img = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])(img)

    img = img.unsqueeze(0)

    pose_model.eval()
    print(mpii_dataset.KEYPOINT_NAMES)
    with torch.no_grad():
        if CUDA:
            pose_model.cuda()
            img = img.cuda()

        pre = pose_model(img)

        humans = utils.get_humans_by_feature(
            pre,
            opts.insize,
            pose_model.outsize,
            opts.local_grid_size,
        )
        # print(humans[0])
        # print(humans[1])
        pil_image = utils.draw_humans(mpii_dataset.KEYPOINT_NAMES,
                                      mpii_dataset.EDGES,
                                      pil_image,
                                      humans,
                                      visbbox=False)

        pil_image.save("result.png", "PNG")
Esempio n. 3
0
    args.weights = './model_zoo/espnetv2/espnetv2_s_2.0_imagenet_224x224.pth'

    from PIL import Image

    model = EESPNet(args)
    model.eval()

    weigth_dict = torch.load(args.weights)
    model.load_state_dict(weigth_dict)

    rgb_img = Image.open('../train_140_im/MP_0001.tiff.jpg').convert('RGB')
    from torchvision.transforms import CenterCrop, ToTensor, Normalize, Resize
    from data_loader.melanoma_classification import MEAN, STD

    crop_image = Resize(size=args.im_size)(rgb_img)
    crop_image.save('../temp/rgb.jpg')
    crop_image = ToTensor()(crop_image)
    crop_image_norm = Normalize(mean=MEAN, std=STD)(crop_image)

    crop_image_norm = crop_image_norm.unsqueeze(0)

    _, outputs = model(crop_image_norm)

    import matplotlib.pyplot as plt

    for i in range(len(outputs)):
        pred = outputs[i]
        pred = F.softmax(pred, dim=1).squeeze(0)
        pred = pred.max(0)[0]
        h, w = pred.size()
        pred = pred.cpu().detach().numpy()
Esempio n. 4
0
    rgb_paths = [
        root + 'train_rgb/' + d for d in os.listdir(root + 'train_rgb/')
    ]
    augmentation = Compose([RandomCrop((420, 560)), RandomCropRotate(10)])
    counter = 3
    while counter < 6:
        counter += 1
        c = 0
        for path in rgb_paths:
            c += 1
            print('%d %d/%d' % (counter, c, len(rgb_paths)))
            img = Image.open(path)
            depth = Image.open(path.replace('rgb', 'depth'))
            rgb, depth = np.array(img), np.array(depth)[:, :, None]
            rgb, depth = augmentation((rgb, depth))
            depth = depth.squeeze(-1)
            rgb, depth = Image.fromarray(rgb), Image.fromarray(depth)
            rgb, depth = Resize((420, 560))(rgb), Resize((420, 560))(depth)
            rgb = ColorJitter(brightness=0.2,
                              contrast=0.2,
                              saturation=0.2,
                              hue=0.1)(rgb)

            rgb.save(root + 'aug_rgb/' + path.split('/')[-1].split('.')[0] +
                     str(counter) + '.png')

            depth.save(
                root + 'aug_depth/' +
                path.replace('rgb', 'depth').split('/')[-1].split('.')[0] +
                str(counter) + '.png')