neurvps のインストールと動作確認（消失点推定）（Python，PyTorch を使用）（Windows 上）

#!/usr/bin/env python3
"""Compute vanishing points using corase-to-fine method 
Usage:
    eval.py [options]  

Arguments:
                    Path to the yaml hyper-parameter file
                     Path to the checkpoint
"""

import os
import sys
import math
import shlex
import pprint
import random
import os.path as osp
import threading
import subprocess

import numpy as np
import torch
from torchvision import transforms
import matplotlib as mpl
import skimage.io
from PIL import Image
import numpy.linalg as LA
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d
from tqdm import tqdm
from docopt import docopt

import neurvps
import neurvps.models.vanishing_net as vn
from neurvps.config import C, M
from neurvps.datasets import Tmm17Dataset, ScanNetDataset, WireframeDataset

IMAGENAME="sample.png"

def AA(x, y, threshold):
    index = np.searchsorted(x, threshold)
    x = np.concatenate([x[:index], [threshold]])
    y = np.concatenate([y[:index], [threshold]])
    return ((x[1:] - x[:-1]) * y[:-1]).sum() / threshold

transform = transforms.Compose(
    [
        transforms.ToTensor(),
    ]
)

def main():
    args = docopt(__doc__)
    config_file = args[""]
    C.update(C.from_yaml(filename=config_file))
    C.model.im2col_step = 32  # override im2col_step for evaluation
    M.update(C.model)
    pprint.pprint(C, indent=4)

    random.seed(0)
    np.random.seed(0)
    torch.manual_seed(0)

    device_name = "cpu"
    os.environ["CUDA_VISIBLE_DEVICES"] = args["--devices"]
    if torch.cuda.is_available():
        device_name = "cuda"
        torch.backends.cudnn.deterministic = True
        torch.cuda.manual_seed(0)
        print("Let's use", torch.cuda.device_count(), "GPU(s)!")
    else:
        print("CUDA is not available")
    device = torch.device(device_name)

    if M.backbone == "stacked_hourglass":
        model = neurvps.models.hg(
            planes=64, depth=M.depth, num_stacks=M.num_stacks, num_blocks=M.num_blocks
        )
    else:
        raise NotImplementedError

    checkpoint = torch.load(args[""])
    model = neurvps.models.VanishingNet(
        model, C.model.output_stride, C.model.upsample_scale
    )
    model = model.to(device)
    model = torch.nn.DataParallel(
        model, device_ids=list(range(args["--devices"].count(",") + 1))
    )
    model.load_state_dict(checkpoint["model_state_dict"])
#    model.eval()

    if C.io.dataset.upper() == "WIREFRAME":
        Dataset = WireframeDataset
    elif C.io.dataset.upper() == "TMM17":
        Dataset = Tmm17Dataset
    elif C.io.dataset.upper() == "SCANNET":
        Dataset = ScanNetDataset
    else:
        raise NotImplementedError

    loader = torch.utils.data.DataLoader(
        Dataset(C.io.datadir, split="valid"),
        batch_size=1,
        shuffle=False,
        num_workers=C.io.num_workers if os.name != "nt" else 0,
        pin_memory=True,
    )

    if args["--dump"] is not None:
        os.makedirs(args["--dump"], exist_ok=True)

    err = []
    n = C.io.num_vpts
    im = Image.open(IMAGENAME).resize((512,512))
    image = transform(im).unsqueeze(0).to(device)
    input_dict = {"image": image, "test": True}

    vpts = sample_sphere(np.array([0, 0, 1]), np.pi / 2, 64)
    input_dict["vpts"] = vpts
    with torch.no_grad():
        score = model(input_dict)[:, -1].cpu().numpy()
    index = np.argsort(-score)
    candidate = [index[0]]
    for i in index[1:]:
        if len(candidate) == n:
            break
        dst = np.min(np.arccos(np.abs(vpts[candidate] @ vpts[i])))
        if dst < np.pi / n:
            continue
        candidate.append(i)

    vpts_pd = vpts[candidate]

    for res in range(1, len(M.multires)):
        vpts = [sample_sphere(vpts_pd[vp], M.multires[-res], 64) for vp in range(n)]
        input_dict["vpts"] = np.vstack(vpts)
        with torch.no_grad():
            score = model(input_dict)[:, -res - 1].cpu().numpy().reshape(n, -1)
        for i, s in enumerate(score):
            vpts_pd[i] = vpts[i][np.argmax(s)]

    plt.imshow(im)
    cc = ["blue", "cyan", "orange"]
    for c, w in zip(cc, vpts_pd):
        x = w[0] / w[2] * C.io.focal_length * 256 + 256
        y = -w[1] / w[2] * C.io.focal_length * 256 + 256
        print(x,y)
        plt.scatter(x, y, color=c)
        for xy in np.linspace(0, 512, 10):
            plt.plot(
                [x, xy, x, xy, x, 0, x, 511],
                [y, 0, y, 511, y, xy, y, xy],
                color=c,
            )
    plt.show()

    err = np.sort(np.array(err))
    np.savez(args["--output"], err=err)
    y = (1 + np.arange(len(err))) / len(loader) / n


def sample_sphere(v, alpha, num_pts):
    v1 = orth(v)
    v2 = np.cross(v, v1)
    v, v1, v2 = v[:, None], v1[:, None], v2[:, None]
    indices = np.linspace(1, num_pts, num_pts)
    phi = np.arccos(1 + (math.cos(alpha) - 1) * indices / num_pts)
    theta = np.pi * (1 + 5 ** 0.5) * indices
    r = np.sin(phi)
    return (v * np.cos(phi) + r * (v1 * np.cos(theta) + v2 * np.sin(theta))).T


def orth(v):
    x, y, z = v
    o = np.array([0.0, -z, y] if abs(x) < abs(y) else [-z, 0.0, x])
    o /= LA.norm(o)
    return o


if __name__ == "__main__":
    main()

neurvps のインストールと動作確認（消失点推定）（Python，PyTorch を使用）（Windows 上）

前準備

Git のインストール（Windows 上）

Python のインストール（Windows 上）

Build Tools for Visual Studio 2022，NVIDIA ドライバ，NVIDIA CUDA ツールキット 11.8，NVIDIA cuDNN 8.6 のインストール（Windows 上）

PyTorch のインストール（Windows 上）

FFmpeg のインストール（Windows 上）

neurvps のインストールと動作確認（Windows 上）

7-Zip 22.01 のインストール（Windows 上）

neurvps のインストール（Windows 上）

消失点推定を実行してみる