Merge pull request #25 from Kwasniok/feature/advanced-renderer

adds meta data and filters

Author: Kwasniok

src/demo_0.py

@@ -141,7 +141,7 @@ def make_scene(canvas_dimension: int) -> Scene:
     return scene
 
 
-def render(
+def render(  # pylint: disable=R0913
     scene: Scene,
     geometry: Geometry,
     render_ray_depth: bool,

src/demo_1.py

@@ -141,7 +141,7 @@ def make_scene(canvas_dimension: int) -> Scene:
     return scene
 
 
-def render(
+def render(  # pylint: disable=R0913
     scene: Scene,
     geometry: Geometry,
     render_ray_depth: bool,

src/demo_2.py

@@ -110,7 +110,7 @@ def make_scene(canvas_dimension: int) -> Scene:
     return scene
 
 
-def render(
+def render(  # pylint: disable=R0913
     scene: Scene,
     geometry: Geometry,
     render_ray_depth: bool,
@@ -124,7 +124,6 @@ def render(
     """
 
     for projection_mode in ProjectionMode:
-        # for mode in (ImageRenderer.Mode.PERSPECTIVE,):
         print(f"rendering {projection_mode.name} projection ...")
         if render_ray_depth:
             image_renderer: ImageRenderer = ImageRayDepthRenderer(

src/demo_3.py

@@ -0,0 +1,210 @@
+"""
+Demonstartes the image filter renderer with an example scene in cylindrical
+coordinates an various filters.
+"""
+
+import os
+import math
+
+from nerte.values.coordinates import Coordinates3D
+from nerte.values.domain import Domain1D
+from nerte.values.linalg import AbstractVector
+from nerte.values.face import Face
+from nerte.values.manifolds.cylindrical import (
+    Plane as CarthesianPlaneInCylindric,
+)
+from nerte.world.object import Object
+from nerte.world.camera import Camera
+from nerte.world.scene import Scene
+from nerte.geometry.geometry import Geometry
+from nerte.geometry.cylindircal_swirl_geometry import (
+    SwirlCylindricRungeKuttaGeometry,
+)
+from nerte.render.projection import ProjectionMode
+from nerte.render.image_filter_renderer import (
+    ImageFilterRenderer,
+    Filter,
+    HitFilter,
+)
+from nerte.render.ray_depth_filter import RayDepthFilter
+from nerte.render.meta_info_filter import MetaInfoFilter
+from nerte.util.random_color_generator import RandomColorGenerator
+
+# pseudo-random color generator
+COLOR = RandomColorGenerator()
+
+
+def make_camera(canvas_dimension: int) -> Camera:
+    """Creates a camera with preset values."""
+
+    location = Coordinates3D((2.0, 0.0, 2.0))
+    manifold = CarthesianPlaneInCylindric(
+        b0=AbstractVector((0.0, -1.0, 0.0)),
+        b1=AbstractVector((-0.4, 0.0, 0.4)),
+        x0_domain=Domain1D(-1.0, +1.0),
+        x1_domain=Domain1D(-1.0, +1.0),
+        offset=AbstractVector((1.5, 0.0, 1.5)),
+    )
+    camera = Camera(
+        location=location,
+        detector_manifold=manifold,
+        canvas_dimensions=(canvas_dimension, canvas_dimension),
+    )
+    return camera
+
+
+def add_cylinder(scene: Scene, radius: float, height: float) -> None:
+    """Adds a cylinder at the center of the scene."""
+
+    # cylinder
+    # top 1
+    point0 = Coordinates3D((0.0, -math.pi, +height))
+    point1 = Coordinates3D((radius, -math.pi, +height))
+    point2 = Coordinates3D((radius, math.pi, +height))
+    tri = Face(point0, point1, point2)
+    obj = Object(color=next(COLOR))  # pseudo-random color
+    obj.add_face(tri)
+    scene.add_object(obj)
+    # top 2
+    point0 = Coordinates3D((0.0, -math.pi, +height))
+    point1 = Coordinates3D((0.0, +math.pi, +height))
+    point2 = Coordinates3D((radius, +math.pi, +height))
+    tri = Face(point0, point1, point2)
+    obj = Object(color=next(COLOR))  # pseudo-random color
+    obj.add_face(tri)
+    scene.add_object(obj)
+    # side 1
+    point0 = Coordinates3D((radius, -math.pi, -height))
+    point1 = Coordinates3D((radius, -math.pi, +height))
+    point2 = Coordinates3D((radius, +math.pi, +height))
+    tri = Face(point0, point1, point2)
+    obj = Object(color=next(COLOR))  # pseudo-random color
+    obj.add_face(tri)
+    scene.add_object(obj)
+    # side 2
+    point0 = Coordinates3D((radius, -math.pi, -height))
+    point1 = Coordinates3D((radius, +math.pi, -height))
+    point2 = Coordinates3D((radius, +math.pi, +height))
+    tri = Face(point0, point1, point2)
+    obj = Object(color=next(COLOR))  # pseudo-random color
+    obj.add_face(tri)
+    scene.add_object(obj)
+    # bottom 1
+    point0 = Coordinates3D((0.0, -math.pi, -height))
+    point1 = Coordinates3D((radius, -math.pi, -height))
+    point2 = Coordinates3D((radius, +math.pi, -height))
+    tri = Face(point0, point1, point2)
+    obj = Object(color=next(COLOR))  # pseudo-random color
+    obj.add_face(tri)
+    scene.add_object(obj)
+    # bottom 2
+    point0 = Coordinates3D((0.0, -math.pi, -height))
+    point1 = Coordinates3D((0.0, +math.pi, -height))
+    point2 = Coordinates3D((radius, +math.pi, -height))
+    tri = Face(point0, point1, point2)
+    obj = Object(color=next(COLOR))  # pseudo-random color
+    obj.add_face(tri)
+    scene.add_object(obj)
+
+
+def make_scene(canvas_dimension: int) -> Scene:
+    """
+    Creates a scene with a camera pointing towards an object.
+    """
+
+    camera = make_camera(canvas_dimension=canvas_dimension)
+    scene = Scene(camera=camera)
+    add_cylinder(scene, radius=1.0, height=1.0)
+
+    return scene
+
+
+def render(  # pylint: disable=R0913
+    scene: Scene,
+    geometry: Geometry,
+    filtr: Filter,
+    output_path: str,
+    file_prefix: str,
+    show: bool,
+) -> None:
+    """
+    Renders a preset scene with non-euclidean geometry in orthographic and
+    perspective projection.
+    """
+
+    projection_mode = ProjectionMode.PERSPECTIVE
+    print(
+        f"rendering {projection_mode.name} projection for filter type"
+        f" '{type(filtr).__name__}' ..."
+    )
+    renderer = ImageFilterRenderer(
+        projection_mode=projection_mode,
+        filtr=filtr,
+        print_warings=False,
+    )
+    renderer.render(scene=scene, geometry=geometry)
+    renderer.apply_filter()
+    os.makedirs(output_path, exist_ok=True)
+    image = renderer.last_image()
+    if image is not None:
+        image.save(f"{output_path}/{file_prefix}_{projection_mode.name}.png")
+        if show:
+            image.show()
+
+
+def main() -> None:
+    """Creates and renders the demo scene."""
+
+    # NOTE: Increase the canvas dimension to improve the image quality.
+    #       This will also increase rendering time!
+    scene = make_scene(canvas_dimension=100)
+    max_steps = 25
+    geo = SwirlCylindricRungeKuttaGeometry(
+        max_ray_depth=math.inf,
+        step_size=0.2,
+        max_steps=max_steps,
+        swirl_strength=0.25,
+    )
+
+    output_path = "../images"
+    file_prefix = "demo3"
+    show = True  # disable if images cannot be displayed
+
+    # hit filter
+    filtr: Filter = HitFilter()
+    render(
+        scene=scene,
+        geometry=geo,
+        filtr=filtr,
+        output_path=output_path,
+        file_prefix=file_prefix + "_hit_filter",
+        show=show,
+    )
+
+    # ray depth filter
+    filtr = RayDepthFilter()
+    render(
+        scene=scene,
+        geometry=geo,
+        filtr=filtr,
+        output_path=output_path,
+        file_prefix=file_prefix + "_ray_depth_filter",
+        show=show,
+    )
+
+    # meta info filter
+    filtr = MetaInfoFilter(
+        meta_data_key="steps", min_value=0, max_value=max_steps
+    )
+    render(
+        scene=scene,
+        geometry=geo,
+        filtr=filtr,
+        output_path=output_path,
+        file_prefix=file_prefix + "_meta_info_steps_filter",
+        show=show,
+    )
+
+
+if __name__ == "__main__":
+    main()

src/nerte/geometry/runge_kutta_geometry.py

@@ -21,6 +21,7 @@
     add_ray_segment_delta,
 )
 from nerte.values.intersection_info import IntersectionInfo, IntersectionInfos
+from nerte.values.extended_intersection_info import ExtendedIntersectionInfo
 from nerte.geometry.geometry import Geometry, intersection_ray_depth
 
 
@@ -165,7 +166,9 @@ def intersection_info(self, face: Face) -> IntersectionInfo:
                 )
                 if relative_segment_depth < math.inf:
                     total_ray_depth += relative_segment_depth * segment_length
-                    return IntersectionInfo(ray_depth=total_ray_depth)
+                    return ExtendedIntersectionInfo(
+                        ray_depth=total_ray_depth, meta_data={"steps": step + 1}
+                    )
 
                 step += 1
                 total_ray_depth += segment_length

src/nerte/geometry/runge_kutta_geometry_unittest.py

@@ -7,7 +7,7 @@
 
 import unittest
 
-from typing import Callable, Type, TypeVar
+from typing import Callable, Type, TypeVar, cast
 
 from itertools import permutations
 import math
@@ -20,6 +20,7 @@
 from nerte.values.ray_segment_delta import RaySegmentDelta
 from nerte.values.face import Face
 from nerte.values.intersection_info import IntersectionInfo
+from nerte.values.extended_intersection_info import ExtendedIntersectionInfo
 from nerte.values.util.convert import coordinates_as_vector
 from nerte.geometry.runge_kutta_geometry import RungeKuttaGeometry
 
@@ -387,6 +388,51 @@ def test_runge_kutta_geometry_intersects(self) -> None:
             )
 
 
+class RungeKuttaGeometryRayIntersectsMetaDataTest(GeometryTestCase):
+    def setUp(self) -> None:
+        p1 = Coordinates3D((1.0, 0.0, 0.0))
+        p2 = Coordinates3D((0.0, 1.0, 0.0))
+        p3 = Coordinates3D((0.0, 0.0, 1.0))
+        self.face = Face(p1, p2, p3)
+        # geometry (carthesian & euclidean)
+        DummyRungeKuttaGeometryGeo = _make_dummy_runge_kutta_geometry()
+        geos = (
+            DummyRungeKuttaGeometryGeo(
+                max_ray_depth=1000.0,
+                step_size=1,  # direct hit
+                max_steps=100,
+            ),
+            DummyRungeKuttaGeometryGeo(
+                max_ray_depth=1000.0,
+                step_size=0.1,  # 6 steps until hit (1/sqrt(3) ~ 0.577...)
+                max_steps=100,
+            ),
+        )
+        self.rays = tuple(
+            geo.ray_from_tangent(
+                start=Coordinates3D((0.0, 0.0, 0.0)),
+                direction=AbstractVector((1.0, 1.0, 1.0)),
+            )
+            for geo in geos
+        )
+        self.steps = (1, 6)
+
+    def test_runge_kutta_geometry_intersects_meta_data(self) -> None:
+        """
+        Tests if ray's meta data.
+        """
+        for ray, steps in zip(self.rays, self.steps):
+            info = ray.intersection_info(self.face)
+            self.assertIsInstance(info, ExtendedIntersectionInfo)
+            if isinstance(info, ExtendedIntersectionInfo):
+                info = cast(ExtendedIntersectionInfo, info)
+                meta_data = info.meta_data
+                self.assertIsNotNone(meta_data)
+                if meta_data is not None:
+                    self.assertTrue("steps" in meta_data)
+                    self.assertAlmostEqual(meta_data["steps"], steps)
+
+
 class DummyRungeKuttaGeometryRayFromTest(GeometryTestCase):
     def setUp(self) -> None:
         DummyRungeKuttaGeometryGeo = _make_dummy_runge_kutta_geometry()

src/nerte/geometry/segmented_ray_geometry.py

@@ -14,6 +14,7 @@
 from nerte.values.linalg import AbstractVector
 from nerte.values.ray_segment import RaySegment
 from nerte.values.intersection_info import IntersectionInfo, IntersectionInfos
+from nerte.values.extended_intersection_info import ExtendedIntersectionInfo
 from nerte.geometry.geometry import Geometry, intersection_ray_depth
 
 
@@ -113,7 +114,9 @@ def intersection_info(self, face: Face) -> IntersectionInfo:
                     total_ray_depth = (
                         step + relative_segment_ray_depth
                     ) * geometry.ray_segment_length()
-                    return IntersectionInfo(ray_depth=total_ray_depth)
+                    return ExtendedIntersectionInfo(
+                        ray_depth=total_ray_depth, meta_data={"steps": step + 1}
+                    )
 
             return IntersectionInfos.NO_INTERSECTION