Initialize

Author: cobanov

README.md

@@ -1 +1,35 @@
-# depth2normal
+# Depth to Normal Map Converter
+
+This script converts a depth map image to a normal map image.
+
+</img><img src='assets/depth.png' width=200> </img><img src='assets/normal.png' width=200></img>
+
+## Requirements
+
+- Python 3.x
+- OpenCV (`pip install opencv-python`)
+- Numpy
+
+## Usage
+
+To run the script, use the following command:
+
+```bash
+python depth_to_normal_map.py --input /path/to/input_image --output /path/to/output_image --max_depth 255
+```
+
+The following arguments are available:
+
+- `--input` (`-i`): Path to the input depth map image.
+- `--output` (`-o`): Path to save the output normal map image.
+- `--max_depth` (`-m`): Maximum depth value of the input depth map image (default: 255).
+
+## Example
+
+```bash
+python depth_to_normal_map.py --input assets/depth.png --output normal_map.png --max_depth 255
+```
+
+## License
+
+This script is licensed under the [MIT License](https://opensource.org/licenses/MIT).

assets/depth.png

@@ -0,0 +1,81 @@
+import cv2
+import numpy as np
+import argparse
+
+
+class DepthToNormalMap:
+    """A class for converting a depth map image to a normal map image.
+
+
+    Attributes:
+        depth_map (ndarray): A numpy array representing the depth map image.
+        max_depth (int): The maximum depth value in the depth map image.
+    """
+
+    def __init__(self, depth_map_path: str, max_depth: int = 255) -> None:
+        """Constructs a DepthToNormalMap object.
+
+        Args:
+            depth_map_path (str): The path to the depth map image file.
+            max_depth (int, optional): The maximum depth value in the depth map image.
+                Defaults to 255.
+
+        Raises:
+            ValueError: If the depth map image file cannot be read.
+
+        """
+        self.depth_map = cv2.imread(depth_map_path, cv2.IMREAD_UNCHANGED)
+
+        if self.depth_map is None:
+            raise ValueError(
+                f"Could not read the depth map image file at {depth_map_path}"
+            )
+        self.max_depth = max_depth
+
+    def convert(self, output_path: str) -> None:
+        """Converts the depth map image to a normal map image.
+
+        Args:
+            output_path (str): The path to save the normal map image file.
+
+        """
+        rows, cols = self.depth_map.shape
+
+        x, y = np.meshgrid(np.arange(cols), np.arange(rows))
+        x = x.astype(np.float32)
+        y = y.astype(np.float32)
+
+        # Calculate the partial derivatives of depth with respect to x and y
+        dx = cv2.Sobel(self.depth_map, cv2.CV_32F, 1, 0)
+        dy = cv2.Sobel(self.depth_map, cv2.CV_32F, 0, 1)
+
+        # Compute the normal vector for each pixel
+        normal = np.dstack((-dx, -dy, np.ones((rows, cols))))
+        norm = np.sqrt(np.sum(normal**2, axis=2, keepdims=True))
+        normal = np.divide(normal, norm, out=np.zeros_like(normal), where=norm != 0)
+
+        # Map the normal vectors to the [0, 255] range and convert to uint8
+        normal = (normal + 1) * 127.5
+        normal = normal.clip(0, 255).astype(np.uint8)
+
+        # Save the normal map to a file
+        normal_bgr = cv2.cvtColor(normal, cv2.COLOR_RGB2BGR)
+        cv2.imwrite(output_path, normal_bgr)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Convert depth map to normal map")
+    parser.add_argument("--input", type=str, help="Path to depth map image")
+    parser.add_argument(
+        "--max_depth", type=int, default=255, help="Maximum depth value (default: 255)"
+    )
+    parser.add_argument(
+        "--output_path",
+        type=str,
+        default="normal_map.png",
+        help="Output path for normal map image (default: normal_map.png)",
+    )
+    args = parser.parse_args()
+
+    converter = DepthToNormalMap(args.input, max_depth=args.max_depth)
+    converter.convert(args.output_path)

assets/normal.png

@@ -0,0 +1,2 @@
+opencv-python
+numpy

depth_to_normal_map.py

@@ -0,0 +1,48 @@
+import unittest
+import cv2
+import numpy as np
+import os
+from depth_to_normal_map import DepthToNormalMap
+
+
+class TestDepthToNormalMap(unittest.TestCase):
+    def setUp(self):
+        self.depth_map_path = "test_depth_map.png"
+        self.normal_map_path = "test_normal_map.png"
+        self.max_depth = 255
+        self.expected_shape = (480, 640, 3)
+
+        # create a sample depth map image
+        self.depth_map = np.random.randint(
+            low=0, high=self.max_depth, size=self.expected_shape[:2], dtype=np.uint16
+        )
+        cv2.imwrite(self.depth_map_path, self.depth_map)
+
+    def test_converting_depth_map_to_normal_map(self):
+        # create an instance of DepthToNormalMap
+        converter = DepthToNormalMap(self.depth_map_path, max_depth=self.max_depth)
+
+        # convert the depth map to normal map
+        converter.convert(self.normal_map_path)
+
+        # assert the output file exists
+        self.assertTrue(os.path.isfile(self.normal_map_path))
+
+        # read the output normal map
+        normal_map = cv2.imread(self.normal_map_path)
+
+        # assert the shape and data type of the normal map
+        self.assertEqual(normal_map.shape, self.expected_shape)
+        self.assertEqual(normal_map.dtype, np.uint8)
+
+    def tearDown(self):
+        # remove the test depth and normal map images
+        if os.path.isfile(self.depth_map_path):
+            os.remove(self.depth_map_path)
+
+        if os.path.isfile(self.normal_map_path):
+            os.remove(self.normal_map_path)
+
+
+if __name__ == "__main__":
+    unittest.main()