Skip to content

Latest commit

 

History

History
149 lines (123 loc) · 5.81 KB

README.md

File metadata and controls

149 lines (123 loc) · 5.81 KB
Raw

py360convert

Features of this project:

  • Convertion between cubemap and equirectangular
  • Equirectangular to planar
  • Pure python implementation and depend only on numpy and scipy
  • Vectorization implementation (in most of the place)
    • c2e takes 300ms and e2c takes 160ms on 1.6 GHz Intel Core i5 CPU

Requirements

  • numpy
  • scipy
  • pillow (for example code to load/save image)

Install

pip install py360convert

Now at everywhere, you can import py360convert or use the command line tool convert360.

Command line examples

You can run command line tool to use the functionality. Please See convert360 -h for detailed. The python script is also an example code to see how to use this as a package in your code.

convert360 --convert e2c --i asset/example_input.png --o asset/example_e2c.png --w 200
Input Equirectangular Output Cubemap 
convert360 --convert c2e --i asset/example_e2c.png --o asset/example_c2e.png --w 800 --h 400
Input Cubemap Output Equirectangular

You can see the blurring artifacts in the polar region because the equirectangular in above figure are resampled twice (e2c then c2e).

convert360 --convert e2p --i asset/example_input.png --o asset/example_e2p.png --w 300 --h 300 --u_deg 120 --v_deg 23
Input Equirectangular Output Perspective

Doc

e2c(e_img, face_w=256, mode='bilinear', cube_format='dice')

Convert the given equirectangular to cubemap.
Parameters:

  • e_img: Numpy array with shape [H, W, C].
  • face_w: The width of each cube face.
  • mode: bilinear or nearest.
  • cube_format: See c2e explaination.

e2p(e_img, fov_deg, u_deg, v_deg, out_hw, in_rot_deg=0, mode='bilinear')

Take perspective image from given equirectangular. Parameters:

  • e_img: Numpy array with shape [H, W, C].
  • fov_deg: Field of view given in int or tuple (h_fov_deg, v_fov_deg).
  • u_deg: Horizontal viewing angle in range [-pi, pi]. (- Left / + Right).
  • v_deg: Vertical viewing angle in range [-pi/2, pi/2]. (- Down/ + Up).
  • out_hw: Output image (height, width) in tuple.
  • in_rot_deg: Inplane rotation.
  • mode: bilinear or nearest.

c2e(cubemap, h, w, cube_format='dice')

Convert the given cubemap to equirectangular.
Parameters:

  • cubemap: Numpy array or list/dict of numpy array (depend on cube_format).
  • h: Output equirectangular height.
  • w: Output equirectangular width.
  • cube_format: 'dice' (default) or 'horizon' or 'dict' or 'list'. Telling the format of the given cubemap.
    • Say that each face of the cube is in shape of 256 (width) x 256 (height)
    • 'dice': a numpy array in shape of 1024 x 768 like below example
    • 'horizon': a numpy array in shape of 1536 x 256 like below example
    • 'list': a list with 6 elements each of which is a numpy array in shape of 256 x 256. It's just converted from 'horizon' format with one line of code: np.split(cube_h, 6, axis=1).
    • 'dict': a dict with 6 elements with keys 'F', 'R', 'B', 'L', 'U', 'D' each of which is a numpy array in shape of 256 x 256.
    • Please refer to the source code if you still have question about the conversion between formats.

Example:

import numpy as np
from PIL import Image
import py360convert

cube_dice = np.array(Image.open('asset/demo_cube.png'))

# You can make convertion between supported cubemap format
cube_h = py360convert.cube_dice2h(cube_dice)  # the inverse is cube_h2dice
cube_dict = py360convert.cube_h2dict(cube_h)  # the inverse is cube_dict2h
cube_list = py360convert.cube_h2list(cube_h)  # the inverse is cube_list2h
print('cube_dice.shape:', cube_dice.shape)
print('cube_h.shape:', cube_h.shape)
print('cube_dict.keys():', cube_dict.keys())
print('cube_dict["F"].shape:', cube_dict["F"].shape)
print('len(cube_list):', len(cube_list))
print('cube_list[0].shape:', cube_list[0].shape)

Output:

cube_dice.shape: (768, 1024, 3)
cube_h.shape: (256, 1536, 3)
cube_dict.keys(): dict_keys(['F', 'R', 'B', 'L', 'U', 'D'])
cube_dict["F"].shape: (256, 256, 3)
len(cube_list): 6
cube_list[0].shape: (256, 256, 3)

My Additional Features

p2e(p_img, fov_deg, u_deg, v_deg, out_hw, in_rot_deg=0)

Convert the given perspective view to equirectangular.

  • p_img: Numpy array with shape [H, W, C].
  • fov_deg: Field of view given in scalar or tuple (h_fov_deg, v_fov_deg).
  • u_deg: Horizontal viewing angle in range [-180, 180]. (- Left / + Right).
  • v_deg: Vertical viewing angle in range [-90, 90]. (- Down/ + Up).
  • out_hw: Output equirectangular height & width.
  • in_rot_deg: Inplane rotation [0, 360].

I've referenced and modified the code from timy90022 - Perspective-and-Equirectangular.

import cv2
src = cv2.imread('./asset/example_e2p.png')
pers_img = py360convert.e2p(src, 60, 120, 23, (300, 300))
equi_img = py360convert.p2e(pers_img, 60, 120, 23, (400, 800))
cv2.imwrite("./asset/example_e2p.png", equi_img)
Idx Image
Input Perspective
Output Equirectangular
Original Equirectangular