build_pyramid.py

import os
os.environ["OPENCV_IO_ENABLE_OPENEXR"]="1"
 
import math
import numpy as np
import cv2
 
 
 
output_dir = "Q:\\Foo\\pyramid_1k";
#output_dir = "Q:\\360\\4k\\pyramid";
 
#assert base_size & (base_size-1) == 0, "Base size must be a power of two"
 
if not os.path.exists(output_dir):
        os.makedirs(output_dir)
 
def handle_cube_face_level(conf, path, l, x, y, w, source_img):
 
        cropped = source_img[y:y+w, x:x+w]
        rescaled = cv2.resize(cropped, [conf.base_size]*2, cv2.INTER_NEAREST if conf.is_distance else cv2.INTER_LANCZOS4)
 
 
        if conf.is_distance:
                #output_path = os.path.join(output_dir, "{}{}.png".format(conf.prefix, path, ".png"))
                #cv2.imwrite(output_path, np.round(65535 * rescaled[:,:]).astype('uint16'))
                output_path = os.path.join(output_dir, "{}{}.u16".format(conf.prefix, path))
                np.round(65535 * rescaled[:,:]).astype('uint16').tofile(output_path)
 
 
        elif conf.is_color:
                output_path = os.path.join(output_dir, "{}{}.png".format(conf.prefix, path, ".png"))
 
                # convert from [0,1] linear to srgb
                rescaled = np.power(rescaled, 1.0/2.4)
 
                # convert to bytes
                rescaled = np.clip(np.round(255 * rescaled), 0, 255).astype('uint8')
                cv2.imwrite(output_path, rescaled)
 
        if conf.is_color and w <= conf.base_size:
                rescaled = cv2.rectangle(rescaled, (0,0), (conf.base_size - 1, conf.base_size - 1), (1, 0.5, 1))
 
        print("Wrote {}".format(output_path))
 
        if l + 1 == conf.tree_depth:
                assert w == conf.base_size
                return
 
        l = l + 1;
        w = w >> 1
        for k in range(4):
                xx = x + w*(k & 1)
                yy = y + w*((k >> 1) & 1)
                handle_cube_face_level(conf, path + str(k), l, xx, yy, w, source_img)
 
def handle_cube_faces(conf, base_images):
 
        base_image_size = conf.base_size << (conf.tree_depth-1)
 
        assert(len(base_images) == 6)
        for i in range(6):
                source_img = cv2.imread(base_images[i], cv2.IMREAD_UNCHANGED);
                print(base_images[i])
 
                assert source_img.shape[0] == source_img.shape[1], "not square"
 
                if source_img.shape[0] != base_image_size:
                        source_img = cv2.resize(source_img, [base_image_size]*2, cv2.INTER_NEAREST)
 
                assert source_img.shape[0] == base_image_size, "base image has unexpected size"
 
                # convert source image to [0,1] float
                if source_img.dtype == 'float32':
                        pass
                if source_img.dtype == 'uint8':
                        source_img = source_img.astype('float32')/255.0
                elif source_img.dtype == 'uint16':
                        source_img = source_img.astype('float32')/65535.0
                else:
                        assert False, "unsupported dtype"
 
                if conf.is_distance:
 
                        assert len(source_img.shape) == 2, "Distance image is not single channel"
 
                        if conf.distance_from_depth:
                                # convert distnance along z to actual distance from eye
                                w = source_img.shape[0]
                                unit = (1.0/w)*(0.5+np.arange(w))
                                theta = np.pi * 0.5 * (unit - 0.5)
                                cos = np.cos(theta)
                                factor = 1.0/cos
                                factor2d = np.outer(factor, factor)
                                source_img = np.clip(factor2d * source_img, 0.0, 1.0)
 
 
                if conf.is_color:
                        print(source_img.shape)
                        assert len(source_img.shape) == 3, "Color image has not three axises"
 
                        # convert from srgb to linear
                        source_img = np.power(source_img, 2.4)
 
                handle_cube_face_level(conf, str(i), 0, 0, 0, base_image_size, source_img)
 
 
if __name__ == "__main__":
        from collections import namedtuple 
 
        Conf = namedtuple('Conf', ['base_size', 'tree_depth', 'prefix', 'is_color', 'is_distance', 'distance_from_depth'])
 
 
        if True:
                conf_color =Conf(base_size=256,
                                                  tree_depth=7,
                                                  is_color=True,
                                                  prefix='color',
                                                  is_distance=False,
                                                  distance_from_depth=False)
 
                color_base_images = [
                        "Q:\\Foo\\16k\\color_east.png",
                        "Q:\\Foo\\16k\\color_west.png",
                        "Q:\\Foo\\16k\\color_down.png",
                        "Q:\\Foo\\16k\\color_up.png",
                        "Q:\\Foo\\16k\\color_north.png",
                        "Q:\\Foo\\16k\\color_south.png",
                ]
                handle_cube_faces(conf_color, color_base_images)
 
        if True:
                conf_depth = Conf(base_size=256,
                                                  tree_depth=7,
                                                  is_color=False,
                                                  prefix='depth',
                                                  is_distance=True,
                                                  distance_from_depth=True)
                depth_base_images = [
                        "Q:\\Foo\\16k\\depth_east.png",
                        "Q:\\Foo\\16k\\depth_west.png",
                        "Q:\\Foo\\16k\\depth_down.png",
                        "Q:\\Foo\\16k\\depth_up.png",
                        "Q:\\Foo\\16k\\depth_north.png",
                        "Q:\\Foo\\16k\\depth_south.png",
                ]
                handle_cube_faces(conf_depth, depth_base_images)
        print("Done")