add utils and support for visualizing Bezier curve

.gitignore

@@ -1,2 +1,3 @@
 .vscode
 .gradio
+**/__pycache__

app.py

@@ -8,123 +8,245 @@
 @Contact :   2909171338@qq.com
 """
 
-import argparse
+import os
 import gradio as gr
-from PIL import Image, ImageDraw
+from PIL import Image
 import io
+import logging
 import matplotlib.pyplot as plt
 import numpy as np
-from datasets import load_dataset
+from datasets import load_dataset, DatasetDict
+import utils.camera as cam
+import utils.bezier as bez
 
-ds = None
-DATASET_NAME = None
-LOCAL = False
-FAST = False
-SPLIT = "all"
 
+dataset_dict = dict()
+dataset = None
+default_split_selector_info = dict(
+    choices=["train", "test"],
+    label="Split",
+    value="train",
+    interactive=False,
+)
+default_index_slider_info = dict(
+    minimum=0,
+    maximum=1,
+    step=1,
+    label="Index",
+    value=0,
+    interactive=False,
+)
+default_order_slider_info = dict(
+    minimum=0,
+    maximum=6,
+    step=1,
+    label="Order",
+    value=0,
+    interactive=False,
+)
+sample_info = dict(
+    dataset=dataset,
+    split="train",
+    index=0,
+    order=0,
+    image1=None,
+    image2=None,
+)
 
-def get_dataset():
+
+def get_dataset(dataset_name):
     """
-    get dataset
+    Get dataset
 
     Args:
-        None
+        dataset_name (str): dataset name or path
 
     Returns:
-        ds (datasets.Dataset): dataset
+        dataset (datasets.Dataset): dataset
     """
-    global ds
-    if ds is None:
-        if LOCAL:
-            ds = load_dataset("imagefolder", data_dir=DATASET_NAME)
+    global dataset_dict
+    if dataset_name in dataset_dict:
+        dataset = dataset_dict[dataset_name]
+    else:
+        if os.path.exists(dataset_name):
+            dataset = load_dataset("imagefolder", data_dir=dataset_name)
         else:
-            ds = load_dataset(DATASET_NAME)
-    return ds
+            dataset = load_dataset(dataset_name)
+        dataset_dict[dataset_name] = dataset
+    return dataset
+
+
+def submit_callback(dataset_name, order):
+    """
+    Submit callback function
+
+    Args:
+        dataset_name (str): dataset name or path
+        order (int): order of the Bezier curve
+
+    Returns:
+        split_selector_info (dict): updated split selector info
+        index_slider_info (dict): updated index slider info
+        order_slider_info (dict): updated slider info
+        image1 (np.ndarray): updated image
+        image2 (np.ndarray): updated image
+    """
+    global dataset
+    try:
+        dataset = get_dataset(dataset_name)
+    except Exception as e:
+        dataset = None
+        logging.error(f"Load dataset failed: {e}")
+        split_selector_info = gr.update(**default_split_selector_info)
+        index_slider_info = gr.update(**default_index_slider_info)
+        order_slider_info = gr.update(**default_order_slider_info)
+        return split_selector_info, index_slider_info, order_slider_info, None, None
+
+    if not isinstance(dataset, DatasetDict):
+        dataset = {str(dataset.split): dataset}
+    splits = list(dataset.keys())
+    split = splits[0]
+    maximum = len(dataset[split]) - 1
+    index = 0
+    split_selector_info = gr.update(choices=splits, value=split, interactive=True)
+    index_slider_info = gr.update(minimum=0, maximum=maximum, value=index, interactive=True)
+    order_slider_info = gr.update(interactive=True)
+    image1, image2 = show_image(split=split, index=index, order=order)
+    return split_selector_info, index_slider_info, order_slider_info, image1, image2
 
 
-def selector_change_callback(value):
+def selector_change_callback(split, order):
     """
-    callback function for split selector
+    Selector change callback function
 
     Args:
-        value (str): selected split, value must be one of ["train", "test"]
+        split (str): selected split, value must be one of ["train", "test"]
+        order (int): order of the Bezier curve
 
     Returns:
-        slider_info (dict): updated slider info
-        image (np.ndarray): updated image
+        index_slider_info (dict): updated slider info
+        image1 (np.ndarray): updated image
+        image2 (np.ndarray): updated image
     """
-    ds = get_dataset()
-    maximum = len(ds[value]) - 1
-    slider_info = gr.update(minimum=0, maximum=maximum, value=0)
-    image = show_image(split=value, index=0)
-    return slider_info, image
+    global dataset
+    if dataset is None:
+        index_slider_info = gr.update(**default_index_slider_info)
+        return index_slider_info, None, None
 
+    maximum = len(dataset[split]) - 1
+    index = 0
+    index_slider_info = gr.update(minimum=0, maximum=maximum, value=index)
+    image1, image2 = show_image(split=split, index=0, order=order)
+    return index_slider_info, image1, image2
 
-def draw_lines(image, lines):
+
+def draw_lines(image, lines, camera_type="pinhole", camera_coeff=None, order=None):
     """
-    draw lines on image
+    Draw lines on image
 
     Args:
         image (np.ndarray): input image
         lines (np.ndarray): list of lines, with shape [N, 2, 2]
+        camera_type (str): camera type, value must be one of ["pinhole", "fisheye", "spherical"]
+        camera_coeff (dict | None): dict of camera coefficients
+        order (int | None): order of the Bezier curve
 
     Returns:
-        image (PIL.Image): drawn image
+        image (PIL.Image | None): drawn image
     """
-    if FAST:
-        image = Image.fromarray(image)
-        draw = ImageDraw.Draw(image)
-        for pts in lines:
-            pts = pts - 0.5
-            pts_list = [tuple(p) for p in pts]
-            draw.line(pts_list, fill="orange", width=2)
-            draw.circle(pts_list[0], 3, fill="#33FFFF")
-            draw.circle(pts_list[-1], 3, fill="#33FFFF")
+    if order == 0:  # Show original image
+        return image
+
+    assert camera_type in ["pinhole", "fisheye", "spherical"]
+    height, width = image.shape[:2]
+    if camera_type == "pinhole":
+        camera = cam.Pinhole(coeff=camera_coeff)
+    elif camera_type == "fisheye":
+        camera = cam.Fisheye(coeff=camera_coeff)
     else:
-        height, width = image.shape[:2]
-        fig = plt.figure()
-        fig.set_size_inches(width / height, 1, forward=False)
-        ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
-        ax.set_axis_off()
-        fig.add_axes(ax)
-        plt.xlim([-0.5, width - 0.5])
-        plt.ylim([height - 0.5, -0.5])
-        plt.imshow(image)
-        for pts in lines:
-            pts = pts - 0.5
-            plt.plot(pts[:, 0], pts[:, 1], color="orange", linewidth=0.5)
-            plt.scatter(pts[[0, -1], 0], pts[[0, -1], 1], color="#33FFFF", s=1.2, edgecolors="none", zorder=5)
-
-        buf = io.BytesIO()
-        fig.savefig(buf, format="png", dpi=height, bbox_inches=0)
-        buf.seek(0)
-        plt.close(fig)
-        image = Image.open(buf)
+        camera = cam.Spherical(image_size=(width, height), coeff=camera_coeff)
+
+    fig = plt.figure()
+    fig.set_size_inches(width / height, 1, forward=False)
+    ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
+    ax.set_axis_off()
+    fig.add_axes(ax)
+    plt.xlim([-0.5, width - 0.5])
+    plt.ylim([height - 0.5, -0.5])
+    plt.imshow(image)
+    lines = camera.truncate_line(lines)
+    pts_list = camera.interp_line(lines)
+    if order is not None:  # Draw Bezier curve
+        bezier = bez.Bezier(order=order)
+        lines, t_list = bezier.fit_line(pts_list)
+        pts_list = bezier.interp_line(lines, t_list)
+
+    for pts in pts_list:
+        pts = pts - 0.5
+        plt.plot(pts[:, 0], pts[:, 1], color="orange", linewidth=0.5)
+        plt.scatter(pts[[0, -1], 0], pts[[0, -1], 1], color="#33FFFF", s=1.2, edgecolors="none", zorder=5)
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", dpi=height, bbox_inches=0)
+    buf.seek(0)
+    plt.close(fig)
+    image = Image.open(buf)
     return image
 
 
-def show_image(split, index):
+def show_image(split, index, order):
     """
-    show image
+    Show image
 
     Args:
         split (str): split name, value must be one of ["train", "test"]
-        index (int): index of the example
+        index (int): index of the sample
+        order (int): order of the Bezier curve
 
     Returns:
-        image (PIL.Image): drawn image
+        image1 (PIL.Image): drawn image
+        image2 (PIL.Image): drawn image
     """
-    ds = get_dataset()
-    example = ds[split][index]
-    image = np.array(example["image"])
-    lines = np.array(example["lines"])
-    image = draw_lines(image, lines)
-    return image
+    global dataset
+    if dataset is None:
+        return None, None
+
+    global sample_info
+    old_sample_info = dict(
+        dataset=sample_info["dataset"],
+        split=sample_info["split"],
+        index=sample_info["index"],
+        order=sample_info["order"],
+    )
+    new_sample_info = dict(dataset=dataset, split=split, index=index, order=order)
+    if old_sample_info == new_sample_info:  # No need to update
+        logging.info("No need to update")
+        return sample_info["image1"], sample_info["image2"]
+
+    old_sample_info.pop("order")
+    new_sample_info.pop("order")
+    sample = dataset[split][index]
+    image = np.array(sample["image"])
+    lines = np.array(sample["lines"])
+    camera_type = sample.get("camera_type", "pinhole")
+    camera_coeff = sample.get("camera_coeff", None)
+    if old_sample_info == new_sample_info:  # No need to update origin label
+        image1 = sample_info["image1"]
+        logging.info("Only update Bezier curve")
+    else:
+        image1 = draw_lines(image, lines, camera_type, camera_coeff)
+    image2 = draw_lines(image, lines, camera_type, camera_coeff, order)
+    sample_info.update(new_sample_info)
+    sample_info["order"] = order
+    sample_info["image1"] = image1
+    sample_info["image2"] = image2
+    logging.info("Update")
+    return image1, image2
 
 
 def main():
     """
-    main
+    Main
 
     Args:
         None
@@ -133,30 +255,28 @@ def main():
         None
     """
     with gr.Blocks() as demo:
-        if SPLIT == "all":
-            choices = ["train", "test"]
-        else:
-            choices = [SPLIT]
-        split_selector = gr.Dropdown(choices, label="Split", value=choices[0])
-        index_slider = gr.Slider(0, 1, step=1, label="Index", value=0)
-        output = gr.Image()
-
-        split_selector.change(selector_change_callback, split_selector, [index_slider, output])
-        index_slider.change(show_image, [split_selector, index_slider], output)
-        demo.load(selector_change_callback, split_selector, [index_slider, output])
+        dataset_textbox = gr.Textbox(label="Dataset name or path")
+        split_selector = gr.Dropdown(**default_split_selector_info)
+        index_slider = gr.Slider(**default_index_slider_info)
+        order_slider = gr.Slider(**default_order_slider_info)
+        with gr.Row():
+            image1 = gr.Image(label="Original Label")
+            image2 = gr.Image(label="Bezier Curve")
+
+        dataset_textbox.submit(
+            submit_callback,
+            [dataset_textbox, order_slider],
+            [split_selector, index_slider, order_slider, image1, image2],
+        )
+        split_selector.change(selector_change_callback, [split_selector, order_slider], [index_slider, image1, image2])
+        index_slider.change(show_image, [split_selector, index_slider, order_slider], [image1, image2])
+        order_slider.change(show_image, [split_selector, index_slider, order_slider], [image1, image2])
         demo.launch(share=False)
 
 
 if __name__ == "__main__":
-    argparser = argparse.ArgumentParser()
-    argparser.add_argument("-n", "--dataset_name", type=str, help="dataset name", default="lh9171338/Wireframe")
-    argparser.add_argument("-l", "--local", type=bool, help="use local data or not", default=False)
-    argparser.add_argument("-f", "--fast", type=bool, help="whether to use fast drawing method", default=False)
-    argparser.add_argument("-s", "--split", type=str, help="split", default="all", choices=["all", "train", "test"])
-    args = argparser.parse_args()
-    print(args)
-    DATASET_NAME = args.dataset_name
-    LOCAL = args.local
-    FAST = args.fast
-    SPLIT = args.split
+    # set base logging config
+    fmt = "[%(asctime)s - %(levelname)s - %(filename)s:%(lineno)s] %(message)s"
+    logging.basicConfig(format=fmt, level=logging.INFO)
+
     main()

requirements.txt

@@ -1,4 +1,6 @@
 datasets
 matplotlib
-numpy
+numpy<2
+opencv-python
 pillow
+scipy

utils/bezier.py

@@ -0,0 +1,122 @@
+# -*- encoding: utf-8 -*-
+
+"""
+@File    :   bezier.py
+@Time    :   2025/9/3 15:25:00
+@Author  :   lh9171338
+@Version :   1.0
+@Contact :   2909171338@qq.com
+"""
+
+import numpy as np
+import cv2
+from scipy.special import comb
+
+
+class Bezier:
+    """
+    Bezier
+    """
+
+    def __init__(self, order=1, **kwargs):
+        self.set_order(order)
+
+    def set_order(self, order):
+        """
+        set order
+
+        Args:
+            order (int): order
+
+        Returns:
+            None
+        """
+        p = comb(order, np.arange(order + 1))
+        k = np.arange(0, order + 1)
+        t = np.linspace(0, 1, order + 1)[:, None]
+        coeff_matrix = p * (t**k) * ((1 - t) ** (order - k))
+        inv_coeff_matrix = np.linalg.inv(coeff_matrix)
+
+        self.order = order
+        self.p = p
+        self.k = k
+        self.inv_coeff_matrix = inv_coeff_matrix
+
+    def fit_line(self, pts_list):
+        """
+        Fit line
+
+        Args:
+            pts_list (list): list of pts
+
+        Returns:
+            lines (np.ndarray): lines, shape [N, O + 1, 2]
+            t_list (list): list of t
+        """
+        lines, t_list = [], []
+        t0 = np.linspace(0, 1, self.order + 1)
+        for pts in pts_list:
+            if len(pts) < 2:
+                continue
+            dists = np.linalg.norm(pts[1:] - pts[:-1], axis=-1)
+            dists = np.cumsum(dists)
+            t = np.concatenate((np.zeros(1), dists / dists[-1]))
+            indices = [np.argmin(abs(t - i)) for i in t0]
+            line = pts[indices]
+            lines.append(line)
+            t_list.append(t)
+
+        lines = np.asarray(lines)
+        return lines, t_list
+
+    def interp_line(self, lines, t_list=None, num=None, resolution=0.1):
+        """
+        Interpolate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, O + 1, 2]
+            t_list (list | Nonr): list of t
+            num (int | None): number of points to interpolate
+            resolution (float): resolution
+
+        Returns:
+            pts_list (list): list of interpolated points
+        """
+        assert lines.shape[1] == self.order + 1
+
+        if t_list is None:
+            t_list = []
+            for line in lines:
+                K = num or int(round(max(abs(line[-1] - line[0])) / resolution)) + 1
+                t = np.linspace(0, 1, K)
+                t_list.append(t)
+
+        pts_list = []
+        for line, t in zip(lines, t_list):
+            control_points = np.matmul(self.inv_coeff_matrix, line)
+            t = t[:, None]
+            coeff_matrix = self.p * (t**self.k) * ((1 - t) ** (self.order - self.k))
+            pts = np.matmul(coeff_matrix, control_points)
+            pts_list.append(pts)
+
+        return pts_list
+
+    def insert_line(self, image, lines, color, thickness=1):
+        """
+        Insert line
+
+        Args:
+            image (np.ndarray): image
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            color (tuple): color
+            thickness (int): thickness
+
+        Returns:
+            image (np.ndarray): image
+        """
+        pts_list = self.interp_line(lines)
+        for pts in pts_list:
+            pts = np.round(pts).astype(np.int32)
+            cv2.polylines(image, [pts], isClosed=False, color=color, thickness=thickness)
+
+        return image

utils/camera.py

@@ -0,0 +1,592 @@
+# -*- encoding: utf-8 -*-
+
+"""
+@File    :   camera.py
+@Time    :   2025/9/3 15:25:00
+@Author  :   lh9171338
+@Version :   1.0
+@Contact :   2909171338@qq.com
+"""
+
+import numpy as np
+import cv2
+
+
+class Camera:
+    """
+    Base Camera
+
+    Args:
+        coeff (dict | None): camera coefficients
+        **kwargs: keyword arguments
+    """
+
+    def __init__(self, coeff=None, **kwargs):
+        self.coeff = coeff
+        self.format_coeff()
+
+    def format_coeff(self):
+        """
+        Format coeff
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        if self.coeff:
+            self.coeff = {k: np.array(v) for k, v in self.coeff.items()}
+
+    def load_coeff(self, filename):
+        """
+        Load coeff
+
+        Args:
+            filename (str): filename
+
+        Returns:
+            None
+        """
+        fs = cv2.FileStorage(filename, cv2.FileStorage_READ)
+        K = fs.getNode("K").mat()
+        D = fs.getNode("D").mat()
+        fs.release()
+        self.coeff = {"K": K, "D": D}
+
+    def save_coeff(self, filename):
+        """
+        Save coeff
+
+        Args:
+            filename (str): filename
+
+        Returns:
+            None
+        """
+        fs = cv2.FileStorage(filename, cv2.FileStorage_WRITE)
+        fs.write("K", self.coeff["K"])
+        fs.write("D", self.coeff["D"])
+        fs.release()
+
+    def distort_point(self, undistorted):
+        """
+        Distort point
+
+        Args:
+            undistorted (np.ndarray): undistorted points, shape [N, 2]
+
+        Returns:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+        """
+        raise NotImplementedError
+
+    def undistort_point(self, distorted):
+        """
+        Undistort point
+
+        Args:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+
+        Returns:
+            undistorted (np.ndarray): undistorted points, shape [N, 2]
+        """
+        raise NotImplementedError
+
+    def distort_image(self, image, transform=None):
+        """
+        Distort image
+
+        Args:
+            image (np.ndarray): image
+            transform (list): transform, [tx, ty, sx, sy]
+
+        Returns:
+            image (np.ndarray): distorted image
+        """
+        if transform is None:
+            transform = [0.0, 0.0, 1.0, 1.0]
+        tx, ty, sx, sy = transform[0], transform[1], transform[2], transform[3]
+
+        height, width = image.shape[0], image.shape[1]
+
+        distorted = np.mgrid[0:width, 0:height].T.reshape(-1, 2).astype(np.float64)
+        undistorted = self.undistort_point(distorted)
+        undistorted = undistorted.reshape(height, width, 2)
+        map1 = (undistorted[:, :, 0].astype(np.float32) - tx) / sx
+        map2 = (undistorted[:, :, 1].astype(np.float32) - ty) / sy
+
+        image = cv2.remap(image, map1, map2, cv2.INTER_CUBIC)
+
+        return image
+
+    def undistort_image(self, image, transform=None):
+        """
+        Undistort image
+
+        Args:
+            image (np.ndarray): image
+            transform (list): transform, [tx, ty, sx, sy]
+
+        Returns:
+            image (np.ndarray): undistorted image
+        """
+        if transform is None:
+            transform = [0.0, 0.0, 1.0, 1.0]
+        tx, ty, sx, sy = transform[0], transform[1], transform[2], transform[3]
+
+        height, width = image.shape[0], image.shape[1]
+
+        undistorted = np.mgrid[0:width, 0:height].T.reshape(-1, 2).astype(np.float64)
+        undistorted[:, 0] = undistorted[:, 0] * sx + tx
+        undistorted[:, 1] = undistorted[:, 1] * sy + ty
+        distorted = self.distort_point(undistorted)
+        distorted = distorted.reshape(height, width, 2)
+        map1 = distorted[:, :, 0].astype(np.float32)
+        map2 = distorted[:, :, 1].astype(np.float32)
+        image = cv2.remap(image, map1, map2, cv2.INTER_CUBIC)
+
+        return image
+
+    def interp_line(self, lines, num=None, resolution=1.0):
+        """
+        Interpolate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            num (int | None): number of interpolated points per line
+            resolution (float): resolution of interpolation
+
+        Returns:
+            pts_list (list): list of interpolated points
+        """
+        raise NotImplementedError
+
+    def interp_arc(self, arcs, num=None, resolution=0.01):
+        """
+        Interpolate arc
+
+        Args:
+            arcs (np.ndarray): arcs, shape [N, 2, 2]
+            num (int | None): number of interpolated points per line
+            resolution (float): resolution of interpolation
+
+        Returns:
+            pts_list (list): list of interpolated points
+        """
+        resolution *= np.pi / 180.0
+
+        pts_list = []
+        for arc in arcs:
+            pt1, pt2 = arc[0], arc[1]
+            normal = np.cross(pt1, pt2)
+            normal /= np.linalg.norm(normal)
+            angle = np.arccos(normal[2])
+            axes = np.array([-normal[1], normal[0], 0])
+            axes /= max(np.linalg.norm(axes), np.finfo(np.float64).eps)
+            rotation_vector = angle * axes
+            rotation_matrix, _ = cv2.Rodrigues(rotation_vector)
+            pt1 = np.matmul(rotation_matrix.T, pt1[:, None]).flatten()
+            pt2 = np.matmul(rotation_matrix.T, pt2[:, None]).flatten()
+            min_angle = np.arctan2(pt1[1], pt1[0])
+            max_angle = np.arctan2(pt2[1], pt2[0])
+            if max_angle < min_angle:
+                max_angle += 2 * np.pi
+
+            K = int(round((max_angle - min_angle) / resolution) + 1) if num is None else num
+            angles = np.linspace(min_angle, max_angle, K)
+            pts = np.hstack((np.cos(angles)[:, None], np.sin(angles)[:, None], np.zeros((K, 1))))
+            pts = np.matmul(rotation_matrix, pts.T).T
+            pts_list.append(pts)
+
+        return pts_list
+
+    def insert_line(self, image, pts_list, color, thickness=1):
+        """
+        Insert line
+
+        Args:
+            image (np.ndarray): image
+            pts_list (list): list of points
+            color (tuple): color
+            thickness (int): thickness
+
+        Returns:
+            image (np.ndarray): image
+        """
+        for pts in pts_list:
+            pts = np.round(pts).astype(np.int32)
+            cv2.polylines(image, [pts], isClosed=False, color=color, thickness=thickness)
+
+        return image
+
+    def truncate_line(self, lines):
+        """
+        Truncate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            image_size (tuple): image size, [width, height]
+
+        Returns:
+            lines (np.ndarray): truncated lines, shape [M, 2, 2]
+        """
+        return lines
+
+
+class Pinhole(Camera):
+    """
+    Pinhole camera
+    """
+
+    def distort_point(self, undistorted):
+        """
+        Distort point
+
+        Args:
+            undistorted (np.ndarray): undistorted points, shape [N, 2]
+
+        Returns:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+        """
+        if self.coeff is not None:
+            K, D = self.coeff["K"], self.coeff["D"]
+            fx, fy = K[0, 0], K[1, 1]
+            cx, cy = K[0, 2], K[1, 2]
+
+            undistorted = undistorted.copy().astype(np.float64)
+            undistorted[:, 0] = (undistorted[:, 0] - cx) / fx
+            undistorted[:, 1] = (undistorted[:, 1] - cy) / fy
+            undistorted = np.hstack((undistorted, np.ones((undistorted.shape[0], 1), np.float64)))
+            distorted = cv2.projectPoints(undistorted.reshape(1, -1, 3), (0, 0, 0), (0, 0, 0), K, D)[0].reshape(-1, 2)
+        else:
+            distorted = undistorted
+
+        return distorted
+
+    def undistort_point(self, distorted):
+        """
+        Undistort point
+
+        Args:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+
+        Returns:
+            undistorted (np.ndarray): undistorted points, shape [N, 2]
+        """
+        if self.coeff is not None:
+            K, D = self.coeff["K"], self.coeff["D"]
+            distorted = distorted.copy().astype(np.float64)
+            undistorted = cv2.undistortPoints(distorted.reshape(1, -1, 2), K, D, R=None, P=K).reshape(-1, 2)
+        else:
+            undistorted = distorted
+
+        return undistorted
+
+    def interp_line(self, lines, num=None, resolution=0.1):
+        """
+        Interpolate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            num (int | None): number of interpolated points per line
+            resolution (float): resolution of interpolation
+
+        Returns:
+            pts_list (list): list of interpolated points
+        """
+        distorted = lines.reshape(-1, 2)
+        undistorted = self.undistort_point(distorted)
+        lines = undistorted.reshape(-1, 2, 2)
+
+        pts_list = []
+        for line in lines:
+            K = num or int(round(max(abs(line[1] - line[0])) / resolution)) + 1
+            lambda_ = np.linspace(0, 1, K)[:, None]
+            pts = line[1] * lambda_ + line[0] * (1 - lambda_)
+            pts = self.distort_point(pts)
+            pts_list.append(pts)
+
+        return pts_list
+
+    def insert_line(self, image, lines, color, thickness=1):
+        """
+        Insert line
+
+        Args:
+            image (np.ndarray): image
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            color (tuple): color
+            thickness (int): thickness
+
+        Returns:
+            image (np.ndarray): image
+        """
+        pts_list = self.interp_line(lines)
+        super().insert_line(image, pts_list, color, thickness)
+
+        return image
+
+
+class Fisheye(Camera):
+    """
+    Fisheye camera
+    """
+
+    def distort_point(self, undistorted):
+        """
+        Distort point
+
+        Args:
+            undistorted (np.ndarray): undistorted points, shape [N, 2]
+
+        Returns:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+        """
+        undistorted = undistorted.copy().astype(np.float64)
+
+        K, D = self.coeff["K"], self.coeff["D"]
+        fx, fy = K[0, 0], K[1, 1]
+        cx, cy = K[0, 2], K[1, 2]
+
+        undistorted[:, 0] = (undistorted[:, 0] - cx) / fx
+        undistorted[:, 1] = (undistorted[:, 1] - cy) / fy
+        distorted = cv2.fisheye.distortPoints(undistorted.reshape(1, -1, 2), K, D).reshape(-1, 2)
+
+        return distorted
+
+    def undistort_point(self, distorted):
+        """
+        Undistort point
+
+        Args:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+
+        Returns:
+            undistorted (np.ndarray): undistorted points, shape [N, 2]
+        """
+        distorted = distorted.copy().astype(np.float64)
+
+        K, D = self.coeff["K"], self.coeff["D"]
+        undistorted = cv2.fisheye.undistortPoints(distorted.reshape(1, -1, 2), K, D, P=K).reshape(-1, 2)
+
+        return undistorted
+
+    def interp_line(self, lines, num=None, resolution=0.1):
+        """
+        Interpolate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            num (int | None): number of interpolated points per line
+            resolution (float): resolution of interpolation
+
+        Returns:
+            pts_list (list): list of interpolated points
+        """
+        distorted = lines.reshape(-1, 2)
+        undistorted = self.undistort_point(distorted)
+        undistorted = np.hstack((undistorted, np.ones((undistorted.shape[0], 1), np.float64)))
+        undistorted = undistorted / np.linalg.norm(undistorted, axis=1, keepdims=True)
+
+        arcs = undistorted.reshape(-1, 2, 3)
+        undistorted_list = self.interp_arc(arcs, num, resolution)
+        distorted_list = []
+        for undistorted in undistorted_list:
+            undistorted = undistorted / (undistorted[:, 2:] + np.finfo(np.float64).eps)
+            undistorted = undistorted[:, :2]
+            distorted = self.distort_point(undistorted)
+            distorted_list.append(distorted)
+
+        return distorted_list
+
+    def insert_line(self, image, lines, color, thickness=1):
+        """
+        Insert line
+
+        Args:
+            image (np.ndarray): image
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            color (tuple): color
+            thickness (int): thickness
+
+        Returns:
+            image (np.ndarray): image
+        """
+        pts_list = self.interp_line(lines)
+        super().insert_line(image, pts_list, color, thickness)
+
+        return image
+
+
+class Spherical(Camera):
+    """
+    Spherical camera
+
+    Args:
+        image_size (tuple): image size, [width, height]
+        **kwargs: keyword arguments
+    """
+
+    def __init__(self, image_size, **kwargs):
+        super().__init__(**kwargs)
+
+        self.image_size = image_size
+
+    def distort_point(self, undistorted):
+        """
+        Distort point
+
+        Args:
+            undistorted (np.ndarray): undistorted points, shape [N, 3]
+
+        Returns:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+        """
+        undistorted = undistorted.copy().astype(np.float64)
+        width, height = self.image_size
+
+        if self.coeff is not None:
+            K, D = self.coeff["K"], self.coeff["D"]
+            cx = cy = (height - 1.0) / 2.0
+
+            mask = undistorted[:, 2] < 0
+            undistorted[mask, 0] = -undistorted[mask, 0]
+            undistorted[mask, 2] = -undistorted[mask, 2]
+            undistorted = undistorted / (undistorted[:, 2:] + np.finfo(np.float64).eps)
+            undistorted = undistorted[:, :2]
+            distorted = cv2.fisheye.distortPoints(undistorted.reshape(1, -1, 2), K, D).reshape(-1, 2)
+            x = (distorted[:, 0] - cx) / cx
+            y = (distorted[:, 1] - cy) / cy
+            theta = np.arctan2(y, x)
+            phi = np.sqrt(x**2 + y**2) * np.pi / 2.0
+            x = np.sin(phi) * np.cos(theta)
+            y = np.sin(phi) * np.sin(theta)
+            z = np.cos(phi)
+            undistorted = np.hstack((x[:, None], y[:, None], z[:, None]))
+            undistorted[mask, 0] = -undistorted[mask, 0]
+            undistorted[mask, 2] = -undistorted[mask, 2]
+
+        x, y, z = undistorted[:, 0], undistorted[:, 1], undistorted[:, 2]
+        lat = np.pi - np.arccos(y)
+        lon = np.pi - np.arctan2(z, x)
+        u = width * lon / (2 * np.pi)
+        v = height * lat / np.pi
+        u = np.mod(u, width)
+        v = np.mod(v, height)
+        distorted = np.stack([u, v], axis=-1)
+
+        return distorted
+
+    def undistort_point(self, distorted):
+        """
+        Undistort point
+
+        Args:
+            distorted (np.ndarray): distorted points, shape [N, 2]
+
+        Returns:
+            undistorted (np.ndarray): undistorted points, shape [N, 3]
+        """
+        distorted = distorted.copy().astype(np.float64)
+        width, height = self.image_size
+
+        u, v = distorted[:, 0], distorted[:, 1]
+        lon = np.pi - u / width * 2 * np.pi
+        lat = np.pi - v / height * np.pi
+        y = np.cos(lat)
+        x = np.sin(lat) * np.cos(lon)
+        z = np.sin(lat) * np.sin(lon)
+        undistorted = np.stack([x, y, z], axis=-1)
+
+        if self.coeff is not None:
+            K, D = self.coeff["K"], self.coeff["D"]
+            cx = cy = (height - 1.0) / 2.0
+
+            mask = undistorted[:, 2] < 0
+            undistorted[mask, 0] = -undistorted[mask, 0]
+            undistorted[mask, 2] = -undistorted[mask, 2]
+            x, y, z = undistorted[:, 0], undistorted[:, 1], undistorted[:, 2]
+            theta = np.arctan2(y, x)
+            phi = np.arccos(z)
+            r = phi * 2.0 / np.pi
+            x = r * np.cos(theta) * cx + cx
+            y = r * np.sin(theta) * cy + cy
+            distorted = np.hstack((x[:, None], y[:, None]))
+            undistorted = cv2.fisheye.undistortPoints(distorted.reshape(1, -1, 2), K, D).reshape(-1, 2)
+            undistorted = np.hstack((undistorted, np.ones((undistorted.shape[0], 1), np.float64)))
+            undistorted = undistorted / np.linalg.norm(undistorted, axis=1, keepdims=True)
+            undistorted[mask, 0] = -undistorted[mask, 0]
+            undistorted[mask, 2] = -undistorted[mask, 2]
+
+        return undistorted
+
+    def interp_line(self, lines, num=None, resolution=0.01):
+        """
+        Interpolate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            num (int | None): number of interpolated points per line
+            resolution (float): resolution of interpolation
+
+        Returns:
+            pts_list (list): list of interpolated points
+        """
+        distorted = lines.reshape(-1, 2)
+        undistorted = self.undistort_point(distorted)
+        arcs = undistorted.reshape(-1, 2, 3)
+        undistorted_list = self.interp_arc(arcs, num, resolution)
+        distorted_list = []
+        for undistorted in undistorted_list:
+            distorted = self.distort_point(undistorted)
+            distorted_list.append(distorted)
+
+        return distorted_list
+
+    def insert_line(self, image, lines, color, thickness=1):
+        """
+        Insert line
+
+        Args:
+            image (np.ndarray): image
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            color (tuple): color
+            thickness (int): thickness
+
+        Returns:
+            image (np.ndarray): image
+        """
+        pts_list = self.interp_line(lines)
+        super().insert_line(image, pts_list, color, thickness)
+
+        return image
+
+    def truncate_line(self, lines):
+        """
+        Truncate line
+
+        Args:
+            lines (np.ndarray): lines, shape [N, 2, 2]
+            image_size (tuple): image size, [width, height]
+
+        Returns:
+            lines (np.ndarray): truncated lines, shape [M, 2, 2]
+        """
+        width = self.image_size[0]
+        pts_list = self.interp_line(lines)
+        lines = []
+        for pts in pts_list:
+            dx = abs(pts[:-1, 0] - pts[1:, 0])
+            mask = dx > width / 2.0
+            s = sum(mask)
+            assert s <= 1
+            if s == 0:
+                lines.append([pts[0], pts[-1]])
+            else:
+                ind = np.where(mask)[0][0]
+                lines.append([pts[0], pts[ind]])
+                lines.append([pts[ind + 1], pts[-1]])
+        lines = np.asarray(lines)
+
+        return lines