diff --git a/notebooks/render.ipynb b/notebooks/render.ipynb index 0c2e56d..26ed367 100644 --- a/notebooks/render.ipynb +++ b/notebooks/render.ipynb @@ -179,9 +179,268 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing 0\n", + "Processing 1\n", + "Processing 2\n", + "Processing 3\n", + "Processing 4\n", + "Processing 5\n", + "Processing 6\n", + "Processing 7\n", + "Processing 8\n", + "Processing 9\n", + "Processing 10\n", + "Processing 11\n", + "Processing 12\n", + "Processing 13\n", + "Processing 14\n", + "Processing 15\n", + "Processing 16\n", + "Processing 17\n", + "Processing 18\n", + "Processing 19\n", + "Processing 20\n", + "Processing 21\n", + "Processing 22\n", + "Processing 23\n", + "Processing 24\n", + "Processing 25\n", + "Processing 26\n", + "Processing 27\n", + "Processing 28\n", + "Processing 29\n", + "Processing 30\n", + "Processing 31\n", + "Processing 32\n", + "Processing 33\n", + "Processing 34\n", + "Processing 35\n", + "Processing 36\n", + "Processing 37\n", + "Processing 38\n", + "Processing 39\n", + "Processing 40\n", + "Processing 41\n", + "Processing 42\n", + "Processing 43\n", + "Processing 44\n", + "Processing 45\n", + "Processing 46\n", + "Processing 47\n", + "Processing 48\n", + "Processing 49\n", + "Processing 50\n", + "Processing 51\n", + "Processing 52\n", + "Processing 53\n", + "Processing 54\n", + "Processing 55\n", + "Processing 56\n", + "Processing 57\n", + "Processing 58\n", + "Processing 59\n", + "Processing 60\n", + "Processing 61\n", + "Processing 62\n", + "Processing 63\n", + "Processing 64\n", + "Processing 65\n", + "Processing 66\n", + "Processing 67\n", + "Processing 68\n", + "Processing 69\n", + "Processing 70\n", + "Processing 71\n", + "Processing 72\n", + "Processing 73\n", + "Processing 74\n", + "Processing 75\n", + "Processing 76\n", + "Processing 77\n", + "Processing 78\n", + "Processing 79\n", + "Processing 80\n", + "Processing 81\n", + "Processing 82\n", + "Processing 83\n", + "Processing 84\n", + "Processing 85\n", + "Processing 86\n", + "Processing 87\n", + "Processing 88\n", + "Processing 89\n", + "Processing 90\n", + "Processing 91\n", + "Processing 92\n", + "Processing 93\n", + "Processing 94\n", + "Processing 95\n", + "Processing 96\n", + "Processing 97\n", + "Processing 98\n", + "Processing 99\n", + "Processing 100\n", + "Processing 101\n", + "Processing 102\n", + "Processing 103\n", + "Processing 104\n", + "Processing 105\n", + "Processing 106\n", + "Processing 107\n", + "Processing 108\n", + "Processing 109\n", + "Processing 110\n", + "Processing 111\n", + "Processing 112\n", + "Processing 113\n", + "Processing 114\n", + "Processing 115\n", + "Processing 116\n", + "Processing 117\n", + "Processing 118\n", + "Processing 119\n", + "Processing 120\n", + "Processing 121\n", + "Processing 122\n", + "Processing 123\n", + "Processing 124\n", + "Processing 125\n", + "Processing 126\n", + "Processing 127\n", + "Processing 128\n", + "Processing 129\n", + "Processing 130\n", + "Processing 131\n", + "Processing 132\n", + "Processing 133\n", + "Processing 134\n", + "Processing 135\n", + "Processing 136\n", + "Processing 137\n", + "Processing 138\n", + "Processing 139\n", + "Processing 140\n", + "Processing 141\n", + "Processing 142\n", + "Processing 143\n", + "Processing 144\n", + "Processing 145\n", + "Processing 146\n", + "Processing 147\n", + "Processing 148\n", + "Processing 149\n", + "Processing 150\n", + "Processing 151\n", + "Processing 152\n", + "Processing 153\n", + "Processing 154\n", + "Processing 155\n", + "Processing 156\n", + "Processing 157\n", + "Processing 158\n", + "Processing 159\n", + "Processing 160\n", + "Processing 161\n", + "Processing 162\n", + "Processing 163\n", + "Processing 164\n", + "Processing 165\n", + "Processing 166\n", + "Processing 167\n", + "Processing 168\n", + "Processing 169\n", + "Processing 170\n", + "Processing 171\n", + "Processing 172\n", + "Processing 173\n", + "Processing 174\n", + "Processing 175\n", + "Processing 176\n", + "Processing 177\n", + "Processing 178\n", + "Processing 179\n", + "Processing 180\n", + "Processing 181\n", + "Processing 182\n", + "Processing 183\n", + "Processing 184\n", + "Processing 185\n", + "Processing 186\n", + "Processing 187\n", + "Processing 188\n", + "Processing 189\n", + "Processing 190\n", + "Processing 191\n", + "Processing 192\n", + "Processing 193\n", + "Processing 194\n", + "Processing 195\n", + "Processing 196\n", + "Processing 197\n", + "Processing 198\n", + "Processing 199\n", + "Processing 200\n", + "Processing 201\n", + "Processing 202\n", + "Processing 203\n", + "Processing 204\n", + "Processing 205\n", + "Processing 206\n", + "Processing 207\n", + "Processing 208\n", + "Processing 209\n", + "Processing 210\n", + "Processing 211\n", + "Processing 212\n", + "Processing 213\n", + "Processing 214\n", + "Processing 215\n", + "Processing 216\n", + "Processing 217\n", + "Processing 218\n", + "Processing 219\n", + "Processing 220\n", + "Processing 221\n", + "Processing 222\n", + "Processing 223\n", + "Processing 224\n", + "Processing 225\n", + "Processing 226\n", + "Processing 227\n", + "Processing 228\n", + "Processing 229\n", + "Processing 230\n", + "Processing 231\n", + "Processing 232\n", + "Processing 233\n", + "Processing 234\n", + "Processing 235\n", + "Processing 236\n", + "Processing 237\n", + "Processing 238\n", + "Processing 239\n", + "Processing 240\n", + "Processing 241\n", + "Processing 242\n", + "Processing 243\n", + "Processing 244\n", + "Processing 245\n", + "Processing 246\n", + "Processing 247\n", + "Processing 248\n", + "Processing 249\n", + "Processing 250\n", + "Processing 251\n" + ] + } + ], "source": [ "import os\n", "from pathlib import Path\n", @@ -192,6 +451,8 @@ "from reni.utils.colourspace import linear_to_sRGB\n", "from matplotlib import pyplot as plt\n", "import imageio\n", + "import pyexr\n", + "import numpy as np\n", "\n", "# setup config\n", "test_mode = 'val'\n", @@ -215,12 +476,12 @@ " image = data['image']\n", " # save image in /workspace/data/RENI_HDR/3d_models/image as idx.png with 3 trailing zeros\n", " # save as an exr using imageio.v2.imwrite\n", - " imageio.v2.imwrite(f'/workspace/data/RENI_HDR/3d_models/image/{idx:03d}.exr', image)" + " pyexr.write(f'/workspace/data/RENI_HDR/3d_models/image/{idx:03d}.exr', image.numpy().astype(np.float32))" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -308,6 +569,162 @@ "rgb = linear_to_sRGB(rgb, use_quantile=True)\n", "plt.imshow(rgb.cpu().detach().numpy())" ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import imageio\n", + "import torch\n", + "from pathlib import Path\n", + "import numpy as np\n", + "from reni.utils.colourspace import linear_to_sRGB\n", + "import pyexr\n", + "\n", + "image_path = Path('/workspace/data/RENI_HDR/3d_models/image/')\n", + "image_filenames = sorted(image_path.glob('*.exr'))\n", + "\n", + "# load each using imageio.v2.imread and check if any nan values or inf values\n", + "nan_containing_images = []\n", + "for image_filename in image_filenames:\n", + " image = pyexr.read(str(image_filename))\n", + " image = torch.tensor(image).float()\n", + " if torch.isnan(image).any() or torch.isinf(image).any():\n", + " print(f'{image_filename} has nan or inf values')\n", + " nan_containing_images.append(image_filename)\n", + "\n", + "\n", + "from matplotlib import pyplot as plt\n", + "# plot all nan containing images\n", + "for image_filename in nan_containing_images:\n", + " # Load the image\n", + " image = pyexr.read(image_filename)\n", + "\n", + " # Assume the image is grayscale. If not, convert it to grayscale for mask creation\n", + " if len(image.shape) == 3:\n", + " gray_image = np.mean(image, axis=-1)\n", + " else:\n", + " gray_image = image\n", + "\n", + " # Create a mask where the image contains NaN or Inf values\n", + " mask = np.isnan(gray_image) | np.isinf(gray_image)\n", + "\n", + " # Initialize an RGB image from the mask\n", + " mask_rgb = np.zeros((mask.shape[0], mask.shape[1], 3), dtype=np.uint8)\n", + "\n", + " # Assign red color where the mask is True\n", + " mask_rgb[mask, 0] = 255 # Red channel\n", + " mask_rgb[mask, 1] = 0 # Green channel\n", + " mask_rgb[mask, 2] = 0 # Blue channel\n", + "\n", + " # Create the composite image by mixing the original image and the mask\n", + " composite = image.copy()\n", + " composite[mask] = [255, 0, 0]\n", + "\n", + " # Plot the original image and the composite\n", + " plt.figure()\n", + " plt.subplot(1, 2, 1)\n", + " plt.title(\"Original\")\n", + " plt.imshow(linear_to_sRGB(torch.tensor(image), True), cmap='gray')\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " plt.title(\"Composite with NaN/Inf in Red\")\n", + " plt.imshow(composite)\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing 80\n", + "tensor(0.) tensor(107452.7734)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "from reni.data.dataparsers.reni_inverse_dataparser import RENIInverseDataParserConfig\n", + "from reni.data.datasets.reni_inverse_dataset import RENIInverseDataset\n", + "from reni.utils.utils import find_nerfstudio_project_root\n", + "from reni.utils.colourspace import linear_to_sRGB\n", + "from matplotlib import pyplot as plt\n", + "import imageio\n", + "import torch \n", + "\n", + "# setup config\n", + "test_mode = 'val'\n", + "world_size = 1\n", + "local_rank = 0\n", + "device = 'cuda:0'\n", + "\n", + "project_root = find_nerfstudio_project_root(Path(os.getcwd()))\n", + "# set current working directory to nerfstudio project root\n", + "os.chdir(project_root)\n", + "\n", + "config = RENIInverseDataParserConfig()\n", + "dataparser = config.setup()\n", + "dataparser_outputs = dataparser.get_dataparser_outputs(split=\"val\")\n", + "\n", + "dataset = RENIInverseDataset(dataparser_outputs=dataparser_outputs, scale_factor=1.0, split='val')\n", + "\n", + "idx = 80\n", + "print(f'Processing {idx}')\n", + "data = dataset[idx]\n", + "image = data['image']\n", + "# save image in /workspace/data/RENI_HDR/3d_models/image as idx.png with 3 trailing zeros\n", + "# save as an exr using imageio.v2.imwrite\n", + "if torch.isnan(image).any() or torch.isinf(image).any():\n", + " print(f'has nan or inf values')\n", + "\n", + "import OpenEXR\n", + "import numpy as np\n", + "import pyexr\n", + "\n", + "print(image.min(), image.max())\n", + "pyexr.write(f'/workspace/{idx:03d}.exr', image.numpy().astype(np.float32))\n", + "\n", + "# load image\n", + "image_path = f'/workspace/{idx:03d}.exr'\n", + "image = pyexr.read(image_path)\n", + "image = torch.tensor(image).float()\n", + "# check if image has nan or inf values\n", + "if torch.isnan(image).any() or torch.isinf(image).any():\n", + " print(f'has nan or inf values after saving and loading')\n", + "\n", + "# plot image\n", + "plt.imshow(linear_to_sRGB(image, use_quantile=True))" + ] } ], "metadata": { diff --git a/reni/configs/reni_inverse_config.py b/reni/configs/reni_inverse_config.py index cd96adb..d7e3dc9 100644 --- a/reni/configs/reni_inverse_config.py +++ b/reni/configs/reni_inverse_config.py @@ -26,7 +26,9 @@ mixed_precision=False, pipeline=RENIInvesePipelineConfig( datamanager=RENIInverseDataManagerConfig( - dataparser=RENIInverseDataParserConfig(), + dataparser=RENIInverseDataParserConfig( + shininess=500.0, + ), images_on_gpu=True, masks_on_gpu=True, normals_on_gpu=True, diff --git a/reni/data/datasets/reni_inverse_dataset.py b/reni/data/datasets/reni_inverse_dataset.py index 0d0ffd6..125f0d6 100644 --- a/reni/data/datasets/reni_inverse_dataset.py +++ b/reni/data/datasets/reni_inverse_dataset.py @@ -26,6 +26,7 @@ from torch import Tensor import scipy import torch.nn.functional as F +import pyexr from typing import Type, Union, Tuple, Dict, List @@ -76,12 +77,18 @@ def __init__( # load all the environment maps self.metadata["environment_maps"] = [] for environment_map_path in self.metadata["environment_maps_filenames"]: - environment_map = imageio.v2.imread(environment_map_path) + # environment_map = imageio.v2.imread(environment_map_path) + environment_map = imageio.imread(environment_map_path).astype("float32") + # make any inf values equal to max non inf + environment_map[environment_map == np.inf] = np.nanmax(environment_map[environment_map != np.inf]) + # make any values less than zero equal to min non negative + environment_map[environment_map <= 0] = np.nanmin(environment_map[environment_map > 0]) environment_map = torch.tensor(environment_map).float() self.metadata["environment_maps"].append(environment_map) camera_rays = dataparser_outputs.cameras.generate_rays(0) # TODO currently same for all images, this might not be the case self.view_directions = camera_rays.directions.reshape(-1, 3) # N x 3 + self.view_directions = self.view_directions / torch.norm(self.view_directions, dim=-1, keepdim=True) ray_sampler_config = EquirectangularSamplerConfig(width=self.metadata["env_width"], apply_random_rotation=False, remove_lower_hemisphere=False) ray_sampler = ray_sampler_config.setup() @@ -130,14 +137,14 @@ def get_data(self, image_idx: int) -> Dict: specular = torch.ones_like(normals) * specular_term # N x 3 albedo = 1 - specular # N x 3 - shiniess = torch.ones_like(normals[:, 0]).squeeze() * self.metadata['shininess'] # N + shininess = torch.ones_like(normals[:, 0]).squeeze() * self.metadata['shininess'] # N albedo[~mask] = 0 specular[~mask] = 0 - shiniess[~mask] = 0 + shininess[~mask] = 0 if len(self.metadata["render_filenames"]) > 0: rendered_image_path = self.metadata["render_filenames"][image_idx] - rendered_image = imageio.v2.imread(rendered_image_path) + rendered_image = pyexr.read(str(rendered_image_path)) rendered_image = torch.tensor(rendered_image).float() # only use rgb not rgba rendered_image = rendered_image[:, :, :3] @@ -150,18 +157,24 @@ def get_data(self, image_idx: int) -> Dict: light_directions=self.light_directions, light_colors=light_colours, specular=specular, - shininess=shiniess, + shininess=shininess, view_directions=self.view_directions, detach_normals=True) rendered_image = rendered_image.reshape(self.image_dim, self.image_dim, 3) + # rendered_image = np.array(rendered_image) + # rendered_image[rendered_image == np.inf] = np.nanmax(rendered_image[rendered_image != np.inf]) + # # make any values less than zero equal to min non negative + # rendered_image[rendered_image <= 0] = np.nanmin(rendered_image[rendered_image > 0]) + # rendered_image = torch.tensor(rendered_image).float() + data['image_idx'] = image_idx data['image'] = rendered_image data['normal'] = normals.reshape(self.image_dim, self.image_dim, 3) data['mask'] = (mask.reshape(self.image_dim, self.image_dim, 1)) data['albedo'] = albedo.reshape(self.image_dim, self.image_dim, 3) data['specular'] = specular.reshape(self.image_dim, self.image_dim, 3) - data['shininess'] = shiniess.reshape(self.image_dim, self.image_dim) + data['shininess'] = shininess.reshape(self.image_dim, self.image_dim) return data \ No newline at end of file