WIP: simplify index interpolation to rounding

Author: kohr-h

examples/tomo/checks/check_axes_cone2d_vec_fp.py

@@ -70,12 +70,13 @@
 proj_data = ray_trafo(phantom)
 
 # Axis in this image is x. This corresponds to 0 degrees or index 0.
-proj_data.show(indices=[0, None],
-               title='Projection at 0 degrees ~ Sum along y axis')
+proj_data.show(
+    indices=[0, None],
+    title='Projection at 0 degrees ~ Sum along y axis'
+)
 fig, ax = plt.subplots()
 ax.plot(sum_along_y)
-ax.set_xlabel('x')
-plt.title('Sum along y axis')
+ax.set(xlabel="x", title='Sum along y axis')
 plt.show()
 # Check axes in geometry
 axis_sum_y = geometry.det_axis(0)

odl/tomo/backends/astra_cpu.py

@@ -20,7 +20,8 @@
     astra_volume_geometry)
 from odl.tomo.backends.util import _add_default_complex_impl
 from odl.tomo.geometry import (
-    DivergentBeamGeometry, Geometry, ParallelBeamGeometry)
+    ConeVecGeometry, DivergentBeamGeometry, Geometry, ParallelBeamGeometry,
+    ParallelVecGeometry)
 from odl.util import writable_array
 
 try:
@@ -52,16 +53,24 @@ def default_astra_proj_type(geom):
 
         - `ParallelBeamGeometry`: ``'linear'``
         - `DivergentBeamGeometry`: ``'line_fanflat'``
+        - `ParallelVecGeometry`: ``'linear'``
+        - `ConeVecGeometry`: ``'line_fanflat'``
 
         In 3D:
 
         - `ParallelBeamGeometry`: ``'linear3d'``
         - `DivergentBeamGeometry`: ``'linearcone'``
+        - `ParallelVecGeometry`: ``'linear3d'``
+        - `ConeVecGeometry`: ``'linearcone'``
     """
     if isinstance(geom, ParallelBeamGeometry):
         return 'linear' if geom.ndim == 2 else 'linear3d'
     elif isinstance(geom, DivergentBeamGeometry):
         return 'line_fanflat' if geom.ndim == 2 else 'linearcone'
+    elif isinstance(geom, ParallelVecGeometry):
+        return 'linear' if geom.ndim == 2 else 'linear3d'
+    elif isinstance(geom, ConeVecGeometry):
+        return 'line_fanflat' if geom.ndim == 2 else 'linearcone'
     else:
         raise TypeError(
             'no default exists for {}, `astra_proj_type` must be given '

odl/tomo/backends/astra_setup.py

@@ -300,9 +300,11 @@ def astra_projection_geometry(geometry):
         raise ValueError('non-uniform detector sampling is not supported')
 
     # Parallel 2D
-    if (isinstance(geometry, ParallelBeamGeometry) and
-            isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector)) and
-            geometry.ndim == 2):
+    if (
+        isinstance(geometry, ParallelBeamGeometry)
+        and isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector))
+        and geometry.ndim == 2
+    ):
         det_count = geometry.detector.size
         if astra_supports('par2d_vec_geometry'):
             vecs = parallel_2d_geom_to_astra_vecs(geometry, coords='ASTRA')
@@ -327,9 +329,11 @@ def astra_projection_geometry(geometry):
         proj_geom = astra.create_proj_geom('parallel_vec', det_count, vecs)
 
     # Cone 2D (aka fan beam)
-    elif (isinstance(geometry, DivergentBeamGeometry) and
-          isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector)) and
-          geometry.ndim == 2):
+    elif (
+        isinstance(geometry, DivergentBeamGeometry)
+        and isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector))
+        and geometry.ndim == 2
+    ):
         det_count = geometry.detector.size
         vecs = cone_2d_geom_to_astra_vecs(geometry, coords='ASTRA')
         proj_geom = astra.create_proj_geom('fanflat_vec', det_count, vecs)
@@ -341,46 +345,55 @@ def astra_projection_geometry(geometry):
         proj_geom = astra.create_proj_geom('fanflat_vec', det_count, vecs)
 
     # Parallel 3D
-    elif (isinstance(geometry, ParallelBeamGeometry) and
-          isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector)) and
-          geometry.ndim == 3):
+    elif (
+        isinstance(geometry, ParallelBeamGeometry)
+        and isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector))
+        and geometry.ndim == 3
+    ):
         # Swap detector axes (see `parallel_3d_geom_to_astra_vecs`)
         det_row_count = geometry.det_partition.shape[0]
         det_col_count = geometry.det_partition.shape[1]
         vecs = parallel_3d_geom_to_astra_vecs(geometry, coords='ASTRA')
         proj_geom = astra.create_proj_geom(
-            'parallel3d_vec', det_row_count, det_col_count, vecs)
+            'parallel3d_vec', det_row_count, det_col_count, vecs
+        )
 
     # Parallel 3D vec
     elif isinstance(geometry, ParallelVecGeometry) and geometry.ndim == 3:
         det_row_count = geometry.det_partition.shape[1]
         det_col_count = geometry.det_partition.shape[0]
         vecs = vecs_odl_to_astra_coords(geometry.vectors)
-        proj_geom = astra.create_proj_geom('parallel3d_vec', det_row_count,
-                                           det_col_count, vecs)
+        proj_geom = astra.create_proj_geom(
+            'parallel3d_vec', det_row_count, det_col_count, vecs
+        )
 
     # Cone 3D
-    elif (isinstance(geometry, DivergentBeamGeometry) and
-          isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector)) and
-          geometry.ndim == 3):
+    elif (
+        isinstance(geometry, DivergentBeamGeometry)
+        and isinstance(geometry.detector, (Flat1dDetector, Flat2dDetector))
+        and geometry.ndim == 3
+    ):
         # Swap detector axes (see `conebeam_3d_geom_to_astra_vecs`)
         det_row_count = geometry.det_partition.shape[0]
         det_col_count = geometry.det_partition.shape[1]
         vecs = cone_3d_geom_to_astra_vecs(geometry, coords='ASTRA')
         proj_geom = astra.create_proj_geom(
-            'cone_vec', det_row_count, det_col_count, vecs)
+            'cone_vec', det_row_count, det_col_count, vecs
+        )
 
     # Cone 3D vec
     elif isinstance(geometry, ConeVecGeometry) and geometry.ndim == 3:
         det_row_count = geometry.det_partition.shape[1]
         det_col_count = geometry.det_partition.shape[0]
         vecs = vecs_odl_to_astra_coords(geometry.vectors)
-        proj_geom = astra.create_proj_geom('cone_vec', det_row_count,
-                                           det_col_count, vecs)
+        proj_geom = astra.create_proj_geom(
+            'cone_vec', det_row_count, det_col_count, vecs
+        )
 
     else:
-        raise NotImplementedError('unknown ASTRA geometry type {!r}'
-                                  ''.format(geometry))
+        raise NotImplementedError(
+            'unknown ASTRA geometry type {!r}'.format(geometry)
+        )
 
     if 'astra' not in geometry.implementation_cache:
         # Save computed value for later

odl/tomo/geometry/conebeam.py

@@ -32,7 +32,6 @@
 
 
 class FanBeamGeometry(DivergentBeamGeometry):
-
     """Fan beam (2d cone beam) geometry.
 
     The source moves on a circle with radius ``src_radius``, and the
@@ -41,7 +40,7 @@ class FanBeamGeometry(DivergentBeamGeometry):
     radii can be chosen as 0, which corresponds to a stationary source
     or detector, respectively.
 
-    The motion parameter is the 1d rotation angle parameterizing source
+    The motion parameter is the 1d rotation angle that parametrizes source
     and detector positions simultaneously.
 
     In the standard configuration, the detector is perpendicular to the
@@ -713,7 +712,6 @@ def __getitem__(self, indices):
 
 
 class ConeBeamGeometry(DivergentBeamGeometry, AxisOrientedGeometry):
-
     """Cone beam geometry with circular/helical source curve.
 
     The source moves along a spiral oriented along a fixed ``axis``, with
@@ -1212,7 +1210,7 @@ def det_axes(self, angle):
 
         Parameters
         ----------
-        angles : float or `array-like`
+        angle : float or `array-like`
             Angle(s) in radians describing the counter-clockwise rotation
             of the detector around `axis`.
 
@@ -1707,7 +1705,7 @@ def cone_beam_geometry(space, src_radius, det_radius, num_angles=None,
     # used here is (w/2)/(rs+rd) = rho/rs since both are equal to tan(alpha),
     # where alpha is the half fan angle.
     rs = float(src_radius)
-    if (rs <= rho):
+    if rs <= rho:
         raise ValueError('source too close to the object, resulting in '
                          'infinite detector for full coverage')
     rd = float(det_radius)
@@ -1749,6 +1747,10 @@ def cone_beam_geometry(space, src_radius, det_radius, num_angles=None,
         det_max_pt = [w / 2, h / 2]
         if det_shape is None:
             det_shape = [num_px_horiz, num_px_vert]
+    else:
+        raise ValueError(
+            '`space.ndim` must be 2 or 3, got {}'.format(space.ndim)
+        )
 
     fan_angle = 2 * np.arctan(rho / rs)
     if short_scan:
@@ -1877,7 +1879,7 @@ def helical_geometry(space, src_radius, det_radius, num_turns,
     # used here is (w/2)/(rs+rd) = rho/rs since both are equal to tan(alpha),
     # where alpha is the half fan angle.
     rs = float(src_radius)
-    if (rs <= rho):
+    if rs <= rho:
         raise ValueError('source too close to the object, resulting in '
                          'infinite detector for full coverage')
     rd = float(det_radius)
@@ -1925,7 +1927,6 @@ def helical_geometry(space, src_radius, det_radius, num_turns,
 
 
 class ConeVecGeometry(VecGeometry):
-
     """Cone beam 2D or 3D geometry defined by a collection of vectors.
 
     This geometry gives maximal flexibility for representing locations
@@ -1963,6 +1964,8 @@ class ConeVecGeometry(VecGeometry):
     linear paths.
     """
 
+    # `rotation_matrix` not implemented; reason: missing
+
     @property
     def _slice_src(self):
         """Slice for the source position part of `vectors`."""
@@ -2055,9 +2058,9 @@ def det_to_src(self, mparam, dparam, normalized=True):
 
         Parameters
         ----------
-        mpar : `motion_params` element
+        mparam : `motion_params` element
             Motion parameter at which to evaluate.
-        dpar : `det_params` element
+        dparam : `det_params` element
             Detector parameter at which to evaluate.
         normalized : bool, optional
             If ``True``, return a normalized (unit) vector.
@@ -2075,8 +2078,10 @@ def det_to_src(self, mparam, dparam, normalized=True):
                 raise ValueError('`dparam` {} not in the valid range {}'
                                  ''.format(dparam, self.det_params))
 
-        vec = (self.src_position(mparam) -
-               self.det_point_position(mparam, dparam))
+        vec = (
+            self.src_position(mparam)
+            - self.det_point_position(mparam, dparam)
+        )
 
         if normalized:
             # axis = -1 allows this to be vectorized