Refactor target management to use TargetsManager

Replaces direct vector usage of Target objects with the new TargetsManager container in LiDAR and RCS simulation modules. Updates Cython and C++ interface definitions to support TargetsManager, improving target handling and extensibility for radar simulations.

Author: rookiepeng

src/radarsimcpp

@@ -117,6 +117,36 @@ cdef extern from "target.hpp":
                const Vec3[T] & rotation_rate,
                const bool & skip_diffusion) except +
 
+#------------------------------------------------------------------------------
+# Targets Manager
+# Container for managing multiple 3D mesh targets in radar simulation
+#------------------------------------------------------------------------------
+cdef extern from "targets_manager.hpp":
+    cdef cppclass TargetsManager[T]:
+        TargetsManager() except +
+        # Add a new target
+        void AddTarget(const T * points,              # Vertex coordinates array
+               const int_t * cells,           # Cell connectivity array
+               const int_t & cell_size,       # Number of cells in mesh
+               const Vec3[T] & origin,        # Target reference origin
+               const vector[Vec3[T]] & location_array,    # Time-varying locations
+               const vector[Vec3[T]] & speed_array,       # Time-varying velocities
+               const vector[Vec3[T]] & rotation_array,    # Time-varying rotations
+               const vector[Vec3[T]] & rotation_rate_array,  # Time-varying rotation rates
+               const cpp_complex[T] & ep,     # Relative permittivity (material property)
+               const cpp_complex[T] & mu,     # Relative permeability (material property)
+               const bool & skip_diffusion) except +
+        
+        void AddTargetSimple(const T * points,
+               const int_t * cells,
+               const int_t & cell_size,
+               const Vec3[T] & origin,
+               const Vec3[T] & location,
+               const Vec3[T] & speed,
+               const Vec3[T] & rotation,
+               const Vec3[T] & rotation_rate,
+               const bool & skip_diffusion) except +
+
 #------------------------------------------------------------------------------
 # Ray Tracing Primitives
 # Ray representation for LiDAR and ray tracing operations
@@ -137,7 +167,7 @@ cdef extern from "simulator_rcs.hpp":
         RcsSimulator() except +
 
         # Calculate RCS for multiple targets and observation angles
-        vector[T] Run(vector[Target[float]] targets,           # Array of target objects
+        vector[T] Run(const shared_ptr[TargetsManager[float]] & targets_manager,    # Targets manager
                      vector[Vec3[T]] inc_dir_array,            # Incident wave directions
                      vector[Vec3[T]] obs_dir_array,            # Observation directions
                      Vec3[cpp_complex[T]] inc_polarization,    # Incident wave polarization
@@ -154,7 +184,7 @@ cdef extern from "simulator_lidar.hpp":
         LidarSimulator() except +
 
         # Generate point cloud by ray casting
-        void Run(vector[Target[T]] targets,
+        void Run(const shared_ptr[TargetsManager[T]] & targets_manager,  # Targets manager
                  const vector[T] & phi,      # Azimuth angles (radians)
                  const vector[T] & theta,    # Elevation angles (radians)
                  const Vec3[T] & position)   # LiDAR sensor position
@@ -285,24 +315,6 @@ cdef extern from "simulator_point.hpp":
         void Run(Radar[H, L] & radar,                            # Radar configuration
                  vector[Point[L]] & points)                      # Array of point targets
 
-# Targets Manager
-# Manager class for handling multiple mesh targets in simulations
-cdef extern from "targets_manager.hpp":
-    cdef cppclass TargetsManager[T]:
-        TargetsManager() except +
-        # Add a new target
-        void AddTarget(const T * points,              # Vertex coordinates array
-               const int_t * cells,           # Cell connectivity array
-               const int_t & cell_size,       # Number of cells in mesh
-               const Vec3[T] & origin,        # Target reference origin
-               const vector[Vec3[T]] & location_array,    # Time-varying locations
-               const vector[Vec3[T]] & speed_array,       # Time-varying velocities
-               const vector[Vec3[T]] & rotation_array,    # Time-varying rotations
-               const vector[Vec3[T]] & rotation_rate_array,  # Time-varying rotation rates
-               const cpp_complex[T] & ep,     # Relative permittivity (material property)
-               const cpp_complex[T] & mu,     # Relative permeability (material property)
-               const bool & skip_diffusion) except +
-
 # Mesh-based Ray Tracing Simulation
 # Physics-based 3D mesh target simulation using ray tracing and physical optics
 # Usage: For realistic simulation of complex targets with detailed geometry.
@@ -313,7 +325,7 @@ cdef extern from "simulator_mesh.hpp":
 
         # Run mesh simulation with configurable fidelity
         RadarSimErrorCode Run(Radar[H, L] & radar,               # Radar configuration
-                              const shared_ptr[TargetsManager[L]] & targets_manager,         # Array of mesh targets
+                              const shared_ptr[TargetsManager[L]] & targets_manager,         # Targets manager
                               int level,                         # Simulation level (0=LOW, 1=MEDIUM, 2=HIGH)
                               L density,                         # Ray density for physical optics
                               Vec2[int_t] ray_filter,            # Ray index filter [min, max]

src/radarsimpy/includes/radarsimc.pxd

@@ -61,7 +61,7 @@ cdef Target[float_t] cp_Target(radar, target, timestamp, mesh_module) except *
 # Create a Target object specifically optimized for RCS calculations
 # Simplified target object without full dynamic simulation requirements
 # Raises ValueError for invalid params, RuntimeError for mesh/FreeTier issues
-cdef Target[float_t] cp_RCS_Target(target, mesh_module) except *
+cdef void cp_RCS_Target(target, mesh_module, TargetsManager[float_t] * targets_manager) except *
 
 cdef void cp_AddTarget(radar,
                        target,

src/radarsimpy/lib/cp_radarsimc.pxd

@@ -1041,7 +1041,7 @@ cdef void cp_AddTarget(radar,
 @cython.cdivision(True)
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef Target[float_t] cp_RCS_Target(target, mesh_module):
+cdef void cp_RCS_Target(target, mesh_module, TargetsManager[float_t] * targets_manager):
     """
     cp_RCS_Target(target, mesh_module)
 
@@ -1115,7 +1115,7 @@ cdef Target[float_t] cp_RCS_Target(target, mesh_module):
         target["skip_diffusion"] = target["is_ground"]
         _warn_deprecated_parameter("is_ground", "skip_diffusion")
 
-    return Target[float_t](&points_mv[0, 0],
+    targets_manager[0].AddTarget(&points_mv[0, 0],
                            &cells_mv[0, 0],
                            <int_t> cells_mv.shape[0],
                            Vec3[float_t](&origin_mv[0]),

src/radarsimpy/lib/cp_radarsimc.pyx

@@ -22,13 +22,14 @@ This module provides tools for simulating a lidar system in complex 3D environme
 """
 
 # Core imports
+from libcpp.memory cimport shared_ptr, make_shared
 from libcpp cimport bool
 import numpy as np
 cimport numpy as np
 cimport cython
 
 # RadarSimX imports
-from radarsimpy.includes.radarsimc cimport Target, LidarSimulator
+from radarsimpy.includes.radarsimc cimport Target, LidarSimulator, TargetsManager
 from radarsimpy.includes.radarsimc cimport Mem_Copy
 from radarsimpy.includes.rsvector cimport Vec3
 from radarsimpy.includes.type_def cimport float_t, int_t, vector
@@ -98,7 +99,7 @@ cpdef sim_lidar(lidar, targets, frame_time=0):
     """
     cdef LidarSimulator[float_t] lidar_sim_c
 
-    cdef vector[Target[float_t]] targets_vt
+    cdef shared_ptr[TargetsManager[float_t]] targets_manager = make_shared[TargetsManager[float_t]]()
 
     # Memory view declarations
     cdef float_t[:, :] points_mv
@@ -134,16 +135,15 @@ cpdef sim_lidar(lidar, targets, frame_time=0):
             np.array(targets[idx_c].get("rotation_rate", (0, 0, 0)), dtype=np_float)
         )
 
-        # Add target to pointcloud
-        targets_vt.emplace_back(Target[float_t](&points_mv[0, 0],
-                                             &cells_mv[0, 0],
-                                             <int_t> cells_mv.shape[0],
-                                             Vec3[float_t](&origin_mv[0]),
-                                             Vec3[float_t](&location_mv[0]),
-                                             Vec3[float_t](&speed_mv[0]),
-                                             Vec3[float_t](&rotation_mv[0]),
-                                             Vec3[float_t](&rotation_rate_mv[0]),
-                                             <bool> targets[idx_c].get("skip_diffusion", False)))
+        targets_manager.get()[0].AddTargetSimple(&points_mv[0, 0],
+                                    &cells_mv[0, 0],
+                                    <int_t> cells_mv.shape[0],
+                                    Vec3[float_t](&origin_mv[0]),
+                                    Vec3[float_t](&location_mv[0]),
+                                    Vec3[float_t](&speed_mv[0]),
+                                    Vec3[float_t](&rotation_mv[0]),
+                                    Vec3[float_t](&rotation_rate_mv[0]),
+                                    <bool> targets[idx_c].get("skip_diffusion", False))
 
     # Lidar parameters
     cdef float_t[:] phi_mv = np.radians(np.array(lidar["phi"], dtype=np_float))
@@ -157,7 +157,7 @@ cpdef sim_lidar(lidar, targets, frame_time=0):
     Mem_Copy(&theta_mv[0], <int_t>(theta_mv.shape[0]), theta_vt)
 
     # Perform ray tracing
-    lidar_sim_c.Run(targets_vt,
+    lidar_sim_c.Run(targets_manager,
                     phi_vt,
                     theta_vt,
                     Vec3[float_t](&position_mv[0]))

src/radarsimpy/simulator_lidar.pyx

@@ -22,6 +22,7 @@ This module provides tools for simulating and calculating the Radar Cross Sectio
 
 """
 
+from libcpp.memory cimport shared_ptr, make_shared
 # Standard library imports
 import numpy as np
 
@@ -32,7 +33,7 @@ cimport numpy as np
 # Local imports
 from radarsimpy.includes.rsvector cimport Vec3
 from radarsimpy.includes.type_def cimport vector
-from radarsimpy.includes.radarsimc cimport Target, RcsSimulator, IsFreeTier
+from radarsimpy.includes.radarsimc cimport Target, RcsSimulator, IsFreeTier, TargetsManager
 from radarsimpy.lib.cp_radarsimc cimport cp_RCS_Target
 from libcpp.complex cimport complex as cpp_complex
 
@@ -128,7 +129,7 @@ cpdef sim_rcs(
                 .format(len(targets))
             )
 
-    cdef vector[Target[float]] targets_vt
+    cdef shared_ptr[TargetsManager[float]] targets_manager = make_shared[TargetsManager[float]]()
     cdef Vec3[cpp_complex[double]] inc_pol_cpp
     cdef Vec3[cpp_complex[double]] obs_pol_cpp
 
@@ -188,7 +189,7 @@ cpdef sim_rcs(
     # Process targets
     mesh_module = import_mesh_module()
     for idx_c in range(0, len(targets)):
-        targets_vt.push_back(cp_RCS_Target(targets[idx_c], mesh_module))
+       cp_RCS_Target(targets[idx_c], mesh_module, targets_manager.get())
 
     # Convert angles to radians
     inc_phi_rad = np.radians(inc_phi)
@@ -226,7 +227,7 @@ cpdef sim_rcs(
     cdef RcsSimulator[double] rcs_sim_c
 
     cdef vector[double] rcs_vect = rcs_sim_c.Run(
-        targets_vt,
+        targets_manager,
         inc_dir,
         obs_dir,
         inc_pol_cpp,