diff --git a/core/include/detray/geometry/detail/surface_kernels.hpp b/core/include/detray/geometry/detail/surface_kernels.hpp
index 77ba8cb880..3dc36106a9 100644
--- a/core/include/detray/geometry/detail/surface_kernels.hpp
+++ b/core/include/detray/geometry/detail/surface_kernels.hpp
@@ -43,7 +43,7 @@ struct surface_kernels {
         DETRAY_HOST_DEVICE inline auto operator()(
             const mask_group_t& mask_group, const index_t& index) const {
 
-            return mask_group.at(index).volume_link();
+            return mask_group[index].volume_link();
         }
     };
 
@@ -64,7 +64,7 @@ struct surface_kernels {
         DETRAY_HOST_DEVICE inline point3 operator()(
             const mask_group_t& mask_group, const index_t& index,
             const transform3& trf3, const point2& bound) const {
-            // Get the concrete mask instance for this surface
+
             const auto& m = mask_group[index];
 
             return m.local_frame().normal(trf3, bound, m);
@@ -114,6 +114,7 @@ struct surface_kernels {
             const mask_group_t& mask_group, const index_t& index,
             const transform3& trf3, const point2& bound,
             const vector3& dir) const {
+
             const auto& m = mask_group[index];
 
             return mask_group[index].local_frame().bound_local_to_global(
@@ -138,10 +139,9 @@ struct surface_kernels {
         DETRAY_HOST_DEVICE inline bound_vector_type operator()(
             const mask_group_t& mask_group, const index_t& index,
             const transform3& trf3, const free_vector_type& free_vec) const {
-            // Get the concrete mask instance for this surface
-            const auto& m = mask_group[index];
-            // Call shape-specific behaviour on the mask
-            return m.local_frame().free_to_bound_vector(trf3, free_vec);
+
+            return mask_group[index].local_frame().free_to_bound_vector(
+                trf3, free_vec);
         }
     };
 
@@ -167,9 +167,8 @@ struct surface_kernels {
             const mask_group_t& mask_group, const index_t& index,
             const transform3& trf3, const free_vector_type& free_vec) const {
 
-            const auto& m = mask_group[index];
-
-            return m.local_frame().free_to_bound_jacobian(trf3, free_vec);
+            return mask_group[index].local_frame().free_to_bound_jacobian(
+                trf3, free_vec);
         }
     };
 
@@ -196,9 +195,8 @@ struct surface_kernels {
             const transform3& trf3, const vector3& pos, const vector3& dir,
             const vector3& dtds) const {
 
-            const auto& m = mask_group[index];
-
-            return m.local_frame().path_correction(pos, dir, dtds, trf3);
+            return mask_group[index].local_frame().path_correction(pos, dir,
+                                                                   dtds, trf3);
         }
     };
 
@@ -211,9 +209,19 @@ struct surface_kernels {
             const scalar_t env =
                 std::numeric_limits<scalar_t>::epsilon()) const {
 
-            const auto& m = mask_group[index];
+            return mask_group[index].local_min_bounds(env);
+        }
+    };
+
+    /// A functor to get the vertices in local coordinates.
+    struct local_vertices {
+
+        template <typename mask_group_t, typename index_t, typename scalar_t>
+        DETRAY_HOST_DEVICE inline auto operator()(
+            const mask_group_t& mask_group, const index_t& index,
+            const dindex lseg) const {
 
-            return m.local_min_bounds(env);
+            return mask_group[index].vertices(lseg);
         }
     };
 };
diff --git a/core/include/detray/geometry/surface.hpp b/core/include/detray/geometry/surface.hpp
index a3f66cdd0f..bd328845ec 100644
--- a/core/include/detray/geometry/surface.hpp
+++ b/core/include/detray/geometry/surface.hpp
@@ -237,17 +237,19 @@ class surface {
                                                              pos, dir, dtds);
     }
 
-    /// @returns the vertices in local frame
+    /// @returns the vertices in local frame with @param lseg the number of
+    /// segments used along acrs
     DETRAY_HOST
-    constexpr auto local_vertices() const {
-        return visit_mask<typename kernels::local_vertices>();
+    constexpr auto local_vertices(const dindex lseg) const {
+        return visit_mask<typename kernels::vertices>(lseg);
     }
 
-    /// @returns the vertices in global frame.
+    /// @returns the vertices in global frame with @param lseg the number of
+    /// segments used along acrs
     DETRAY_HOST
-    constexpr auto global_vertices(const context &ctx,
+    constexpr auto global_vertices(const context &ctx, const dindex lseg,
                                    const vector3 &dir) const {
-        auto vertices = local_vertices();
+        auto vertices = local_vertices(lseg);
         for (size_t i = 0; i < vertices.size(); i++) {
             vertices[i] = local_to_global(ctx, vertices[i], dir);
         }
@@ -269,7 +271,7 @@ class surface {
     /// @tparam functor_t the prescription to be applied to the mask
     /// @tparam Args      types of additional arguments to the functor
     template <typename functor_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr auto visit_mask(Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr auto visit_mask(Args &&...args) const {
         const auto &masks = m_detector.mask_store();
 
         return masks.template visit<functor_t>(m_desc.mask(),
@@ -281,7 +283,7 @@ class surface {
     /// @tparam functor_t the prescription to be applied to the mask
     /// @tparam Args      types of additional arguments to the functor
     template <typename functor_t, typename... Args>
-    DETRAY_HOST_DEVICE constexpr auto visit_material(Args &&... args) const {
+    DETRAY_HOST_DEVICE constexpr auto visit_material(Args &&...args) const {
         const auto &materials = m_detector.material_store();
 
         return materials.template visit<functor_t>(m_desc.material(),
@@ -370,10 +372,10 @@ class surface {
 
 template <typename detector_t, typename descr_t>
 DETRAY_HOST_DEVICE surface(const detector_t &, const descr_t &)
-    ->surface<detector_t>;
+    -> surface<detector_t>;
 
 template <typename detector_t>
 DETRAY_HOST_DEVICE surface(const detector_t &, const geometry::barcode)
-    ->surface<detector_t>;
+    -> surface<detector_t>;
 
 }  // namespace detray
diff --git a/core/include/detray/masks/annulus2D.hpp b/core/include/detray/masks/annulus2D.hpp
index 4bfab3dc47..8c5fbb1826 100644
--- a/core/include/detray/masks/annulus2D.hpp
+++ b/core/include/detray/masks/annulus2D.hpp
@@ -14,11 +14,11 @@
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/intersection/plane_intersector.hpp"
+#include "detray/masks/detail/vertexing.hpp"
 #include "detray/surface_finders/grid/detail/axis_binning.hpp"
 #include "detray/surface_finders/grid/detail/axis_bounds.hpp"
 
 // System include(s)
-#include <cmath>
 #include <limits>
 #include <ostream>
 #include <string>
@@ -93,24 +93,6 @@ class annulus2D {
         using binning = dtuple<binning_loc0<C, S>, binning_loc1<C, S>>;
     };
 
-    /// Given a local polar point given in the disc frame, @returns the
-    /// correponding point in the focal frame
-    /*DETRAY_HOST_DEVICE
-    template<typename scalar_t>
-    static inline constexpr loc_point_type<scalar_t> to_focal_frame(
-        const loc_point_type<scalar_t> & pc_mod_point) {
-        return {};
-    }
-
-    /// Given a local polar point given in the focal frame, @returns the
-    /// correponding point in the disc frame
-    DETRAY_HOST_DEVICE
-    template<typename scalar_t>
-    static inline constexpr loc_point_type<scalar_t> to_disc_frame(
-        const loc_point_type<scalar_t> & pc_strp_point) {
-        return {};
-    }*/
-
     /// @returns the stereo angle calculated from the mask @param bounds .
     template <template <typename, std::size_t> class bounds_t,
               typename scalar_t, std::size_t kDIM,
@@ -282,6 +264,90 @@ class annulus2D {
         return corner_pos;
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the stereo annulus
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(
+        const bounds_t<scalar_t, kDIM> &bounds, dindex lseg) const {
+
+        scalar_t min_r = bounds[e_min_r];
+        scalar_t max_r = bounds[e_max_r];
+        scalar_t min_phi_rel = bounds[e_min_phi_rel];
+        scalar_t max_phi_rel = bounds[e_max_phi_rel];
+        scalar_t origin_x = bounds[e_shift_x];
+        scalar_t origin_y = bounds[e_shift_y];
+
+        point2_t origin_m = {origin_x, origin_y};
+
+        /// Helper method: find inner outer radius at edges in STRIP PC
+        auto circIx = [](scalar_t O_x, scalar_t O_y, scalar_t r,
+                         scalar_t phi) -> point2_t {
+            //                      _____________________________________________
+            //                     /      2  2                    2    2  2    2
+            //     O_x + O_y*m - \/  - O_x *m  + 2*O_x*O_y*m - O_y  + m *r  + r
+            // x =
+            // --------------------------------------------------------------
+            //                                  2
+            //                                 m  + 1
+            //
+            // y = m*x
+            //
+            scalar_t m = std::tan(phi);
+            point2_t dir = {math_ns::cos(phi), std::sin(phi)};
+            scalar_t x1 = (O_x + O_y * m -
+                           std::sqrt(-std::pow(O_x, 2.f) * std::pow(m, 2.f) +
+                                     2.f * O_x * O_y * m - std::pow(O_y, 2.f) +
+                                     std::pow(m, 2.f) * std::pow(r, 2.f) +
+                                     std::pow(r, 2.f))) /
+                          (std::pow(m, 2.f) + 1.f);
+            scalar_t x2 = (O_x + O_y * m +
+                           std::sqrt(-std::pow(O_x, 2.f) * std::pow(m, 2.f) +
+                                     2.f * O_x * O_y * m - std::pow(O_y, 2.f) +
+                                     std::pow(m, 2.f) * std::pow(r, 2.f) +
+                                     std::pow(r, 2.f))) /
+                          (std::pow(m, 2.f) + 1.f);
+
+            point2_t v1 = {x1, m * x1};
+            if (vector::dot(v1, dir) > 0.f)
+                return v1;
+            return {x2, m * x2};
+        };
+
+        // calculate corners in STRIP XY
+        point2_t ul_xy = circIx(origin_x, origin_y, max_r, max_phi_rel);
+        point2_t ll_xy = circIx(origin_x, origin_y, min_r, max_phi_rel);
+        point2_t ur_xy = circIx(origin_x, origin_y, max_r, min_phi_rel);
+        point2_t lr_xy = circIx(origin_x, origin_y, min_r, min_phi_rel);
+
+        auto inner_phi = detail::phi_values(
+            getter::phi(ll_xy - origin_m), getter::phi(lr_xy - origin_m), lseg);
+        auto outer_phi = detail::phi_values(
+            getter::phi(ur_xy - origin_m), getter::phi(ul_xy - origin_m), lseg);
+
+        dvector<point3_t> annulus_vertices;
+        annulus_vertices.reserve(inner_phi.size() + outer_phi.size());
+        for (auto iphi : inner_phi) {
+            annulus_vertices.push_back(
+                point3_t{min_r * math_ns::cos(iphi) + origin_x,
+                         min_r * std::sin(iphi) + origin_y, 0.f});
+        }
+
+        for (auto ophi : outer_phi) {
+            annulus_vertices.push_back(
+                point3_t{max_r * math_ns::cos(ophi) + origin_x,
+                         max_r * std::sin(ophi) + origin_y, 0.f});
+        }
+
+        return annulus_vertices;
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/cuboid3D.hpp b/core/include/detray/masks/cuboid3D.hpp
index b042d9b6da..cfaad80dbe 100644
--- a/core/include/detray/masks/cuboid3D.hpp
+++ b/core/include/detray/masks/cuboid3D.hpp
@@ -128,6 +128,23 @@ class cuboid3D {
         return o_bounds;
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the cuboid
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(const bounds_t<scalar_t, kDIM> &,
+                                           dindex) const {
+        throw std::runtime_error(
+            "Vertex generation for cuboids is not implemented");
+        return {};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/cylinder2D.hpp b/core/include/detray/masks/cylinder2D.hpp
index bf2986c6d8..16ff189350 100644
--- a/core/include/detray/masks/cylinder2D.hpp
+++ b/core/include/detray/masks/cylinder2D.hpp
@@ -131,6 +131,23 @@ class cylinder2D {
                 xy_bound,  xy_bound,  bounds[e_p_half_z] + env};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the cylinder
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(const bounds_t<scalar_t, kDIM> &,
+                                           dindex) const {
+        throw std::runtime_error(
+            "Vertex generation for cylinders is not implemented");
+        return {};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/cylinder3D.hpp b/core/include/detray/masks/cylinder3D.hpp
index 17fef91cc5..6432b495c9 100644
--- a/core/include/detray/masks/cylinder3D.hpp
+++ b/core/include/detray/masks/cylinder3D.hpp
@@ -124,6 +124,23 @@ class cylinder3D {
                 r_bound,  r_bound,  bounds[e_max_z] + env};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the cylinder
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(const bounds_t<scalar_t, kDIM> &,
+                                           dindex) const {
+        throw std::runtime_error(
+            "Vertex generation for 3D cylinders is not implemented");
+        return {};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/line.hpp b/core/include/detray/masks/line.hpp
index 28bd5f7654..a3ea21f63e 100644
--- a/core/include/detray/masks/line.hpp
+++ b/core/include/detray/masks/line.hpp
@@ -151,6 +151,25 @@ class line {
         return {-xy_bound, -xy_bound, -z_bound, xy_bound, xy_bound, z_bound};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the line
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(
+        const bounds_t<scalar_t, kDIM> &bounds, dindex /*ignored*/) const {
+
+        point3_t lc = {0.f, 0.f, -bounds[e_half_z]};
+        point3_t rc = {0.f, 0.f, bounds[e_half_z]};
+
+        return {lc, rc};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index 778cc07f0b..dd5e6d50d7 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -220,6 +220,18 @@ class mask {
         return trf.point_to_global(center);
     }
 
+    /// @brief Vertices of the mask in local cartesian coordinates.
+    ///
+    /// Computes vertices along the mask boundary.
+    ///
+    /// @param lseg the number of segments in for arcs
+    ///
+    /// @returns a vector of vertices.
+    DETRAY_HOST
+    auto vertices(const dindex lseg) const -> dvector<point3_t> {
+        return _shape.template vertices<point2_t, point3_t>(_values, lseg);
+    }
+
     /// @returns true if the mask boundary values are consistent
     DETRAY_HOST
     constexpr bool self_check(std::ostream& os) const {
diff --git a/core/include/detray/masks/rectangle2D.hpp b/core/include/detray/masks/rectangle2D.hpp
index 6120eebcae..9352bac6ca 100644
--- a/core/include/detray/masks/rectangle2D.hpp
+++ b/core/include/detray/masks/rectangle2D.hpp
@@ -116,6 +116,30 @@ class rectangle2D {
         return {-x_bound, -y_bound, -env, x_bound, y_bound, env};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the stereo annulus
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(
+        const bounds_t<scalar_t, kDIM> &bounds, dindex /*ignored*/) const {
+        // left hand lower corner
+        point3_t lh_lc{-bounds[e_half_x], -bounds[e_half_y], 0.f};
+        // right hand lower corner
+        point3_t rh_lc{bounds[e_half_x], -bounds[e_half_y], 0.f};
+        // right hand upper corner
+        point3_t rh_uc{bounds[e_half_x], bounds[e_half_y], 0.f};
+        // left hand upper corner
+        point3_t lh_uc{-bounds[e_half_x], bounds[e_half_y], 0.f};
+        // Return the confining vertices
+        return {lh_lc, rh_lc, rh_uc, lh_uc};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/ring2D.hpp b/core/include/detray/masks/ring2D.hpp
index 46a2072cba..75248cd8db 100644
--- a/core/include/detray/masks/ring2D.hpp
+++ b/core/include/detray/masks/ring2D.hpp
@@ -117,6 +117,23 @@ class ring2D {
         return {-r_bound, -r_bound, -env, r_bound, r_bound, env};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the stereo annulus
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(const bounds_t<scalar_t, kDIM> &,
+                                           dindex) const {
+        throw std::runtime_error(
+            "Vertex generation for rings is not implemented");
+        return {};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/single3D.hpp b/core/include/detray/masks/single3D.hpp
index 1d0651cdaa..1df98db200 100644
--- a/core/include/detray/masks/single3D.hpp
+++ b/core/include/detray/masks/single3D.hpp
@@ -117,6 +117,23 @@ class single3D {
         return o_bounds;
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the single value
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(const bounds_t<scalar_t, kDIM> &,
+                                           dindex) const {
+        throw std::runtime_error(
+            "Vertex generation for single value shapes is not implemented");
+        return {};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/trapezoid2D.hpp b/core/include/detray/masks/trapezoid2D.hpp
index c85ef2aecd..eea97d7632 100644
--- a/core/include/detray/masks/trapezoid2D.hpp
+++ b/core/include/detray/masks/trapezoid2D.hpp
@@ -130,6 +130,30 @@ class trapezoid2D {
         return {-x_bound, -y_bound, -env, x_bound, y_bound, env};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the trapezoid
+    /// @param ls is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(
+        const bounds_t<scalar_t, kDIM> &bounds, dindex /*ignored*/) const {
+        // left hand lower corner
+        point3_t lh_lc{-bounds[e_half_length_0], -bounds[e_half_length_2], 0.f};
+        // right hand lower corner
+        point3_t rh_lc{bounds[e_half_length_0], -bounds[e_half_length_2], 0.f};
+        // right hand upper corner
+        point3_t rh_uc{bounds[e_half_length_1], bounds[e_half_length_2], 0.f};
+        // left hand upper corner
+        point3_t lh_uc{-bounds[e_half_length_1], bounds[e_half_length_2], 0.f};
+        // Return the confining vertices
+        return {lh_lc, rh_lc, rh_uc, lh_uc};
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/unbounded.hpp b/core/include/detray/masks/unbounded.hpp
index 115c67337c..6315a8ddc6 100644
--- a/core/include/detray/masks/unbounded.hpp
+++ b/core/include/detray/masks/unbounded.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s)
 #include "detray/definitions/containers.hpp"
+#include "detray/definitions/indexing.hpp"
 #include "detray/definitions/qualifiers.hpp"
 
 // System include(s)
@@ -78,6 +79,22 @@ class unbounded {
         return shape{}.template local_min_bounds<algebra_t>(bounds, env);
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values for the underlying shape
+    /// @param ls is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <
+        typename point2_t, typename point3_t,
+        template <typename, std::size_t> class bounds_t, typename scalar_t,
+        std::size_t kDIM,
+        typename std::enable_if_t<kDIM == boundaries::e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(
+        const bounds_t<scalar_t, kDIM>& bounds, dindex lseg) const {
+        return shape{}.template vertices<point2_t, point3_t>(bounds, lseg);
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/masks/unmasked.hpp b/core/include/detray/masks/unmasked.hpp
index 4349ce6048..eda5bbca5a 100644
--- a/core/include/detray/masks/unmasked.hpp
+++ b/core/include/detray/masks/unmasked.hpp
@@ -94,6 +94,21 @@ class unmasked {
         return {-inf, -inf, -inf, inf, inf, inf};
     }
 
+    /// Generate vertices in local cartesian frame
+    ///
+    /// @param bounds the boundary values
+    /// @param lseg is the number of line segments
+    ///
+    /// @return a generated list of vertices
+    template <typename point2_t, typename point3_t,
+              template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST dvector<point3_t> vertices(
+        const bounds_t<scalar_t, kDIM>& bounds, dindex) const {
+        return local_min_bounds(bounds);
+    }
+
     /// @brief Check consistency of boundary values.
     ///
     /// @param bounds the boundary values for this shape
diff --git a/core/include/detray/tools/bin_association.hpp b/core/include/detray/tools/bin_association.hpp
index c6f81b40a6..687cd47dd4 100644
--- a/core/include/detray/tools/bin_association.hpp
+++ b/core/include/detray/tools/bin_association.hpp
@@ -9,9 +9,11 @@
 #pragma once
 
 // Project include(s)
+#include "detray/coordinates/cylindrical2.hpp"
+#include "detray/coordinates/polar2.hpp"
 #include "detray/definitions/units.hpp"
+#include "detray/masks/detail/vertexing.hpp"
 #include "detray/tools/associator.hpp"
-#include "detray/tools/generators.hpp"
 #include "detray/utils/ranges.hpp"
 
 // System include(s)
@@ -74,7 +76,7 @@ static inline void bin_association(const context_t & /*context*/,
 
                 // Create a contour for the bin
                 std::vector<point2_t> bin_contour =
-                    r_phi_polygon<scalar, point2_t>(
+                    detail::r_phi_polygon<scalar, point2_t>(
                         r_borders[0] - r_add, r_borders[1] + r_add,
                         phi_borders[0] - phi_add, phi_borders[1] + phi_add);
 
@@ -89,10 +91,8 @@ static inline void bin_association(const context_t & /*context*/,
                     // Unroll the mask container and generate vertices
                     const auto &transform = transforms[sf.transform()];
 
-                    auto vertices_per_masks =
-                        surface_masks
-                            .template visit<vertexer<point2_t, point3_t>>(
-                                sf.mask());
+                    auto vertices_per_masks = surface_masks.template visit<
+                        detail::vertexer<point2_t, point3_t>>(sf.mask());
 
                     // Usually one mask per surface, but design allows - a
                     // single association  is sufficient though
@@ -162,10 +162,8 @@ static inline void bin_association(const context_t & /*context*/,
                     // Unroll the mask container and generate vertices
                     const auto &transform = transforms[sf.transform()];
 
-                    auto vertices_per_masks =
-                        surface_masks
-                            .template visit<vertexer<point2_t, point3_t>>(
-                                sf.mask());
+                    auto vertices_per_masks = surface_masks.template visit<
+                        detail::vertexer<point2_t, point3_t>>(sf.mask());
 
                     for (auto &vertices : vertices_per_masks) {
 
diff --git a/core/include/detray/tools/generators.hpp b/core/include/detray/tools/generators.hpp
deleted file mode 100644
index dfd97c2d36..0000000000
--- a/core/include/detray/tools/generators.hpp
+++ /dev/null
@@ -1,292 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2021-2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-#include "detray/definitions/math.hpp"
-#include "detray/masks/masks.hpp"
-#include "detray/utils/ranges.hpp"
-
-namespace detray {
-
-/** Generate phi values
- *
- * @param start_phi is the start for the arc generation
- * @param end_phi is the end of the arc generation
- * @param lseg is the number of segments used to gnerate the arc
- *
- * @return a vector of phi values for the arc
- */
-template <typename scalar_t>
-static inline dvector<scalar_t> phi_values(scalar_t start_phi, scalar_t end_phi,
-                                           dindex lseg) {
-    dvector<scalar_t> values;
-    values.reserve(lseg + 1u);
-    scalar_t step_phi = (end_phi - start_phi) / static_cast<scalar_t>(lseg);
-    for (unsigned int istep = 0u; istep <= lseg; ++istep) {
-        values.push_back(start_phi + static_cast<scalar_t>(istep) * step_phi);
-    }
-    return values;
-}
-
-/** Generate vertices, specialized for masks: annulus2
- *
- * @note template types are simply forwarded to mask
- *
- * @param sf is the surface that generates vertices
- * @param ls is the number of line segments if
- *
- * @return a generated list of vertices
- */
-template <typename point2_t, typename point3_t, typename links_t,
-          typename transform3_t>
-dvector<point3_t> vertices(
-    const mask<annulus2D<>, links_t, transform3_t> &annulus_mask, dindex lseg) {
-    using scalar_t = typename transform3_t::scalar_type;
-
-    const auto &m_values = annulus_mask.values();
-
-    scalar_t min_r = m_values[0];
-    scalar_t max_r = m_values[1];
-    scalar_t min_phi_rel = m_values[2];
-    scalar_t max_phi_rel = m_values[3];
-    // scalar_t avg_phi = m_values[4];
-    scalar_t origin_x = m_values[5];
-    scalar_t origin_y = m_values[6];
-
-    point2_t origin_m = {origin_x, origin_y};
-
-    /// Helper method: find inner outer radius at edges in STRIP PC
-    auto circIx = [](scalar_t O_x, scalar_t O_y, scalar_t r,
-                     scalar_t phi) -> point2_t {
-        //                      _____________________________________________
-        //                     /      2  2                    2    2  2    2
-        //     O_x + O_y*m - \/  - O_x *m  + 2*O_x*O_y*m - O_y  + m *r  + r
-        // x = --------------------------------------------------------------
-        //                                  2
-        //                                 m  + 1
-        //
-        // y = m*x
-        //
-        scalar_t m = std::tan(phi);
-        point2_t dir = {math_ns::cos(phi), std::sin(phi)};
-        scalar_t x1 = (O_x + O_y * m -
-                       std::sqrt(-std::pow(O_x, 2.f) * std::pow(m, 2.f) +
-                                 2.f * O_x * O_y * m - std::pow(O_y, 2.f) +
-                                 std::pow(m, 2.f) * std::pow(r, 2.f) +
-                                 std::pow(r, 2.f))) /
-                      (std::pow(m, 2.f) + 1.f);
-        scalar_t x2 = (O_x + O_y * m +
-                       std::sqrt(-std::pow(O_x, 2.f) * std::pow(m, 2.f) +
-                                 2.f * O_x * O_y * m - std::pow(O_y, 2.f) +
-                                 std::pow(m, 2.f) * std::pow(r, 2.f) +
-                                 std::pow(r, 2.f))) /
-                      (std::pow(m, 2.f) + 1.f);
-
-        point2_t v1 = {x1, m * x1};
-        if (vector::dot(v1, dir) > 0.f)
-            return v1;
-        return {x2, m * x2};
-    };
-
-    // calculate corners in STRIP XY, keep them we need them for minDistance()
-    point2_t ul_xy = circIx(origin_x, origin_y, max_r, max_phi_rel);
-    point2_t ll_xy = circIx(origin_x, origin_y, min_r, max_phi_rel);
-    point2_t ur_xy = circIx(origin_x, origin_y, max_r, min_phi_rel);
-    point2_t lr_xy = circIx(origin_x, origin_y, min_r, min_phi_rel);
-
-    auto inner_phi = phi_values(getter::phi(ll_xy - origin_m),
-                                getter::phi(lr_xy - origin_m), lseg);
-    auto outer_phi = phi_values(getter::phi(ur_xy - origin_m),
-                                getter::phi(ul_xy - origin_m), lseg);
-
-    dvector<point3_t> annulus_vertices;
-    annulus_vertices.reserve(inner_phi.size() + outer_phi.size());
-    for (auto iphi : inner_phi) {
-        annulus_vertices.push_back(
-            point3_t{min_r * math_ns::cos(iphi) + origin_x,
-                     min_r * std::sin(iphi) + origin_y, 0.f});
-    }
-
-    for (auto ophi : outer_phi) {
-        annulus_vertices.push_back(
-            point3_t{max_r * math_ns::cos(ophi) + origin_x,
-                     max_r * std::sin(ophi) + origin_y, 0.f});
-    }
-
-    return annulus_vertices;
-}
-
-/** Generate vertices, spacialized for masks: cylinder3
- *
- * @note template types are simply forwarded to mask
- *
- * @param sf is the surface that generates vertices
- * @param ls is the number of line segments if
- *
- * @return a generated list of vertices
- */
-template <typename point2_t, typename point3_t, bool kRadialCheck,
-          template <class> typename intersector_t, typename links_t,
-          typename transform3_t>
-dvector<point3_t> vertices(
-    const mask<cylinder2D<kRadialCheck, intersector_t>, links_t, transform3_t>
-        & /*cylinder_mask*/,
-    unsigned int /*lseg*/) {
-
-    return {};
-}
-
-/** Generate vertices, specialized for masks: rectangle2
- *
- * @note template types are simply forwarded to mask
- *
- * @param sf is the surface that generates vertices
- * @param ls is the number of line segments (ignored for rectangles)
- *
- * @return a generated list of vertices
- */
-template <typename point2_t, typename point3_t, typename links_t,
-          typename transform3_t>
-dvector<point3_t> vertices(
-    const mask<rectangle2D<>, links_t, transform3_t> &rectangle_mask,
-    unsigned int /*ignored*/) {
-    const auto &m_values = rectangle_mask.values();
-    // left hand lower corner
-    point3_t lh_lc = {-m_values[0], -m_values[1], 0.f};
-    // right hand lower corner
-    point3_t rh_lc = {m_values[0], -m_values[1], 0.f};
-    // right hand upper corner
-    point3_t rh_uc = {m_values[0], m_values[1], 0.f};
-    // left hand upper corner
-    point3_t lh_uc = {-m_values[0], m_values[1], 0.f};
-    return {lh_lc, rh_lc, rh_uc, lh_uc};
-    // Return the confining vertices
-}
-
-/** Generate vertices, specialized for masks: ring2
- *
- * @note template types are simply forwarded to mask
- *
- * @param sf is the surface that generates vertices
- * @param ls is the number of line segments if
- *
- * @return a generated list of vertices
- */
-template <typename point2_t, typename point3_t, typename links_t,
-          typename transform3_t>
-dvector<point3_t> vertices(
-    const mask<ring2D<>, links_t, transform3_t> & /*ring_mask*/,
-    unsigned int /*lseg*/) {
-    return {};
-}
-
-/** Generate vertices, specialized for masks: trapezoid2
- *
- * @note template types are simply forwarded to mask
- *
- * @param sf is the surface that generates vertices
- * @param ls is the number of line segments if, ignored
- *
- * @return a generated list of vertices
- */
-template <typename point2_t, typename point3_t, typename links_t,
-          typename transform3_t>
-dvector<point3_t> vertices(
-    const mask<trapezoid2D<>, links_t, transform3_t> &trapezoid_mask,
-    unsigned int /* ignored */) {
-
-    const auto &m_values = trapezoid_mask.values();
-    // left hand lower corner
-    point3_t lh_lc = {-m_values[0], -m_values[2], 0.f};
-    // right hand lower corner
-    point3_t rh_lc = {m_values[0], -m_values[2], 0.f};
-    // right hand upper corner
-    point3_t rh_uc = {m_values[1], m_values[2], 0.f};
-    // left hand upper corner
-    point3_t lh_uc = {-m_values[1], m_values[2], 0.f};
-    // Return the confining vertices
-    return {lh_lc, rh_lc, rh_uc, lh_uc};
-}
-
-/** Generate vertices, specialized for masks: line
- *
- * @note template types are simply forwarded to mask
- *
- * @param sf is the surface that generates vertices
- * @param ls is the number of line segments if
- *
- * @return a generated list of vertices
- */
-template <typename point2_t, typename point3_t, bool cross_section,
-          template <class> typename intersector_t, typename links_t,
-          typename transform3_t>
-dvector<point3_t> vertices(const mask<line<cross_section, intersector_t>,
-                                      links_t, transform3_t> & /*line_mask*/,
-                           unsigned int /*lseg*/) {
-    return {};
-}
-
-/// Functor to produce vertices on a mask collection in a mask tuple container.
-template <typename point2_t, typename point3_t>
-struct vertexer {
-
-    /// Specialized method to generate vertices per maks group
-    ///
-    /// @tparam mask_group_t is the type of the mask collection in a mask cont.
-    /// @tparam mask_range_t is the type of the according mask range object
-    ///
-    /// @param masks is the associated (and split out) mask group
-    /// @param range is the range list of masks to be processed
-    ///
-    /// @return a jagged vector of points of the mask vertices (one per maks)
-    template <typename mask_group_t, typename mask_range_t>
-    dvector<dvector<point3_t>> operator()(const mask_group_t &masks,
-                                          const mask_range_t &range,
-                                          unsigned int n_segments = 1) {
-        dvector<dvector<point3_t>> mask_vertices = {};
-        for (auto i : detray::views::iota(range)) {
-            const auto &mask = masks[i];
-            mask_vertices.push_back(
-                vertices<point2_t, point3_t>(mask, n_segments));
-        }
-        return mask_vertices;
-    }
-};
-
-/** Create a r-phi polygon from principle parameters
- *
- * @param rmin minum r parameter
- * @param rmax maximum r parameter
- * @param phimin minimum phi parameter
- * @param phimax maximum phi parameters
- *
- * @return a polygon representation of the bin
- **/
-template <typename scalar_t, typename point2_t>
-std::vector<point2_t> r_phi_polygon(scalar_t rmin, scalar_t rmax,
-                                    scalar_t phimin, scalar_t phimax,
-                                    unsigned int nsegments = 1u) {
-
-    std::vector<point2_t> r_phi_poly;
-    r_phi_poly.reserve(2u * nsegments + 2u);
-
-    scalar_t cos_min_phi = math_ns::cos(phimin);
-    scalar_t sin_min_phi = std::sin(phimin);
-    scalar_t cos_max_phi = math_ns::cos(phimax);
-    scalar_t sin_max_phi = std::sin(phimax);
-
-    // @TODO add phi generators
-    r_phi_poly.push_back({rmin * cos_min_phi, rmin * sin_min_phi});
-    r_phi_poly.push_back({rmin * cos_max_phi, rmin * sin_max_phi});
-    r_phi_poly.push_back({rmax * cos_max_phi, rmax * sin_max_phi});
-    r_phi_poly.push_back({rmax * cos_min_phi, rmax * sin_min_phi});
-
-    return r_phi_poly;
-}
-
-}  // namespace detray
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
index bd7e52e7ac..a6a87b26d4 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
@@ -10,7 +10,6 @@
 // Project include(s)
 #include "detray/geometry/surface.hpp"
 #include "detray/plugins/svgtools/conversion/point.hpp"
-#include "detray/plugins/svgtools/utils/mask_utils.hpp"
 
 // Actsvg include(s)
 #include "actsvg/proto/surface.hpp"
@@ -37,9 +36,16 @@ inline void set_measures(actsvg::proto::surface<point3_container_t>& p_surface,
 /// @brief Sets the vertices of the proto surface to be the same as the mask.
 template <typename point3_container_t, typename transform_t, typename mask_t>
 inline void set_vertices(actsvg::proto::surface<point3_container_t>& p_surface,
-                         const transform_t& transform, const mask_t& m) {
+                         const transform_t& trf, const mask_t& m) {
+
     using point3_t = typename point3_container_t::value_type;
-    const auto vertices = svgtools::utils::global_vertices(transform, m);
+
+    // Approximate any acrs in the mask shape with ten line segments
+    auto vertices = m.vertices(10u);
+    for (std::size_t i = 0; i < vertices.size(); i++) {
+        vertices[i] = m.template to_global_frame<transform_t>(trf, vertices[i]);
+    }
+
     std::transform(
         vertices.cbegin(), vertices.cend(),
         std::back_inserter(p_surface._vertices),
@@ -83,11 +89,12 @@ auto inline surface(const transform_t& transform,
     const auto r = static_cast<scalar_t>(m[shape_t::e_r]);
     const auto nhz = static_cast<scalar_t>(m[shape_t::e_n_half_z]);
     const auto phz = static_cast<scalar_t>(m[shape_t::e_p_half_z]);
-    const auto hz =
-        (phz - nhz) / 2 + static_cast<scalar_t>(transform.translation()[2]);
+    const auto center =
+        svgtools::conversion::point<point3_t>(transform.translation());
+    const auto hz = (phz - nhz) / 2 + center[2];
 
     p_surface._type = p_surface_t::type::e_cylinder;
-    p_surface._radii = {static_cast<scalar_t>(0), r};
+    p_surface._radii = {0.f, r};
     p_surface._zparameters = {nhz + hz, hz};
     set_measures(p_surface, m);
 
@@ -116,7 +123,7 @@ auto surface(const transform_t& transform, const mask<ring2D<>>& m) {
 
     p_surface._type = p_surface_t::type::e_disc;
     p_surface._radii = {ri, ro};
-    p_surface._zparameters = {center[2], static_cast<scalar_t>(0)};
+    p_surface._zparameters = {center[2], 0.f};
     set_measures(p_surface, m);
 
     return p_surface;
@@ -144,13 +151,51 @@ auto inline surface(const transform_t& transform, const mask<annulus2D<>>& m) {
 
     p_surface._type = p_surface_t::type::e_annulus;
     p_surface._radii = {ri, ro};
-    p_surface._zparameters = {center[2], static_cast<scalar_t>(0)};
+    p_surface._zparameters = {center[2], 0.f};
     set_measures(p_surface, m);
     set_vertices(p_surface, transform, m);
 
     return p_surface;
 }
 
+/// @brief Returns the proto surface for 2D rings.
+template <typename point3_container_t, typename transform_t,
+          bool kSquareCrossSect, template <typename> class intersector_t>
+auto surface(const transform_t& transform,
+             const mask<line<kSquareCrossSect, intersector_t>>& m) {
+    // Rotation is currently not supported.
+    // Furthermore, only translation on z axis is supported.
+
+    using mask_t = mask<line<kSquareCrossSect, intersector_t>>;
+    using shape_t = typename mask_t::shape;
+
+    using point3_t = typename point3_container_t::value_type;
+    using scalar_t = typename point3_t::value_type;
+    using p_surface_t = actsvg::proto::surface<point3_container_t>;
+
+    p_surface_t p_surface;
+
+    // All straws are drawn as a circle in xy-view
+    scalar_t r{};
+    if constexpr (kSquareCrossSect) {
+        const auto l = static_cast<scalar_t>(m[shape_t::e_cross_section]);
+        r = 0.5f * detray::constant<scalar_t>::sqrt2 * l;
+    } else {
+        r = static_cast<scalar_t>(m[shape_t::e_cross_section]);
+    }
+    const auto hz = static_cast<scalar_t>(m[shape_t::e_half_z]);
+    const auto center =
+        svgtools::conversion::point<point3_t>(transform.translation());
+
+    p_surface._type = p_surface_t::type::e_straw;
+    p_surface._radii = {1.f, r};
+    p_surface._zparameters = {center[2], 2.f * hz};
+    p_surface._transform._tr = center;
+    set_measures(p_surface, m);
+
+    return p_surface;
+}
+
 /// @brief Returns the proto surface for a shape.
 /// @note For lines, the thickness is fixed and not determined by the cross
 /// section.
@@ -165,7 +210,7 @@ namespace {
 /// @brief A functor to set the proto surfaces type and bounds to be equivalent
 /// to the mask.
 template <typename point3_container_t>
-struct surface_getter {
+struct surface_converter {
     template <typename mask_group_t, typename index_t, typename transform_t>
     DETRAY_HOST inline auto operator()(const mask_group_t& mask_group,
                                        const index_t& index,
@@ -188,7 +233,7 @@ struct surface_getter {
 template <typename point3_container_t, typename detector_t>
 auto surface(const typename detector_t::geometry_context& context,
              const detray::surface<detector_t>& d_surface) {
-    return d_surface.template visit_mask<surface_getter<point3_container_t>>(
+    return d_surface.template visit_mask<surface_converter<point3_container_t>>(
         d_surface.transform(context));
 }
 
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
deleted file mode 100644
index b6c9b47dfc..0000000000
--- a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/masks/line.hpp"
-#include "detray/tools/generators.hpp"
-
-// System include(s)
-#include <cmath>
-
-namespace detray::svgtools::utils {
-
-template <typename mask_t>
-inline auto local_vertices(const mask_t& mask) {
-    return vertices<typename mask_t::point2_t, typename mask_t::point3_t>(mask,
-                                                                          10u);
-}
-
-inline auto local_vertices(const mask<line<>>& m) {
-    using point3_t = typename mask<line<>>::point3_t;
-    const auto hz = m[line<>::e_half_z];
-    point3_t p1{0.f, 0.f, -hz};
-    point3_t p2{0.f, 0.f, hz};
-    return dvector<point3_t>{p1, p2};
-}
-
-/// @return The global vertices of the mask.
-template <typename transform_t, typename mask_t>
-inline auto global_vertices(const transform_t& transform, const mask_t& mask) {
-    auto ret = local_vertices(mask);
-    for (std::size_t i = 0; i < ret.size(); i++) {
-        ret[i] = transform.point_to_global(ret[i]);
-    }
-    return ret;
-}
-
-}  // namespace detray::svgtools::utils