Add TargetsManager for mesh target simulation

Introduces the TargetsManager C++ class and integrates it into the mesh simulation workflow. Updates Cython and Python interfaces to use a shared_ptr to TargetsManager for managing multiple mesh targets, refactors target addition logic, and updates the mesh simulator to accept the new manager. This enables more flexible and efficient handling of mesh targets in radar simulations.

Author: rookiepeng

src/radarsimcpp

@@ -39,6 +39,7 @@ Template Parameters:
 from libcpp cimport bool
 from libcpp.complex cimport complex as cpp_complex
 from libcpp.string cimport string
+from libcpp.memory cimport shared_ptr
 
 #------------------------------------------------------------------------------
 # RadarSimPy Type Definitions
@@ -284,6 +285,24 @@ 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.
@@ -294,7 +313,7 @@ cdef extern from "simulator_mesh.hpp":
 
         # Run mesh simulation with configurable fidelity
         RadarSimErrorCode Run(Radar[H, L] & radar,               # Radar configuration
-                              vector[Target[L]] targets,         # Array of mesh targets
+                              const shared_ptr[TargetsManager[L]] & targets_manager,         # Array of mesh targets
                               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]
@@ -314,6 +333,7 @@ cdef extern from "simulator_interference.hpp":
         void Run(Radar[H, L] & radar,                            # Victim radar
                  Radar[H, L] & interf_radar)                     # Interfering radar
 
+
 #------------------------------------------------------------------------------
 # End of RadarSimPy C++ Interface Declarations
 #------------------------------------------------------------------------------

src/radarsimpy/includes/radarsimc.pxd

@@ -34,6 +34,7 @@ with support for both trial and full versions with appropriate limitations.
 from radarsimpy.includes.radarsimc cimport Radar
 from radarsimpy.includes.radarsimc cimport Target
 from radarsimpy.includes.radarsimc cimport Point
+from radarsimpy.includes.radarsimc cimport TargetsManager
 from radarsimpy.includes.type_def cimport float_t, int_t
 from libcpp.complex cimport complex as cpp_complex
 
@@ -62,6 +63,11 @@ cdef Target[float_t] cp_Target(radar, target, timestamp, mesh_module) except *
 # Raises ValueError for invalid params, RuntimeError for mesh/FreeTier issues
 cdef Target[float_t] cp_RCS_Target(target, mesh_module) except *
 
+cdef void cp_AddTarget(radar,
+                       target,
+                       timestamp,
+                       mesh_module,
+                       TargetsManager[float_t] * targets_manager) except *
 
 # ============================================================================
 # Helper Functions for Internal Use

src/radarsimpy/lib/cp_radarsimc.pxd

@@ -32,7 +32,7 @@ from libcpp cimport bool
 # Local imports
 from radarsimpy.includes.radarsimc cimport (
     Transmitter, Receiver, TxChannel, RxChannel, 
-    Radar, Target, Point, Mem_Copy, Mem_Copy_Vec3,
+    Radar, Target, Point, TargetsManager, Mem_Copy, Mem_Copy_Vec3,
     Mem_Copy_Complex, IsFreeTier
 )
 from radarsimpy.includes.rsvector cimport Vec3
@@ -859,6 +859,185 @@ cdef Target[float_t] cp_Target(radar,
                            mu_c,
                            <bool> target.get("skip_diffusion", False))
 
+
+@cython.cdivision(True)
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef void cp_AddTarget(radar,
+                  target,
+                  timestamp,
+                  mesh_module,
+                  TargetsManager[float_t] * targets_manager):
+    """
+    cp_Target((radar, target, ts_shape)
+
+    Creat Target object in Cython
+
+    :param Radar radar:
+        Radar object
+    :param dict target:
+        Target properties
+    :param tuple ts_shape:
+        Shape of the time matrix
+
+    :return: C++ object of a target
+    :rtype: Target
+    """
+    # vector of location, speed, rotation, rotation rate
+    cdef vector[Vec3[float_t]] loc_vt
+    cdef vector[Vec3[float_t]] spd_vt
+    cdef vector[Vec3[float_t]] rot_vt
+    cdef vector[Vec3[float_t]] rrt_vt
+
+    cdef float_t[:, :, :] locx_mv, locy_mv, locz_mv
+    cdef float_t[:, :, :] spdx_mv, spdy_mv, spdz_mv
+    cdef float_t[:, :, :] rotx_mv, roty_mv, rotz_mv
+    cdef float_t[:, :, :] rrtx_mv, rrty_mv, rrtz_mv
+
+    cdef cpp_complex[float_t] ep_c, mu_c
+
+    cdef int_t ch_idx, ps_idx, sp_idx
+    ts_shape = np.shape(timestamp)
+    cdef int_t bbsize_c = <int_t>(ts_shape[0]*ts_shape[1]*ts_shape[2])
+
+    cdef float_t scale
+    cdef float_t[:, :] points_mv
+    cdef int_t[:, :] cells_mv
+
+    # Enhanced mesh validation and loading with improved error messages
+    unit = target.get("unit", "m")
+    try:
+        scale = _safe_unit_conversion(unit)
+    except ValueError as e:
+        raise ValueError(f"Invalid unit in target configuration: {e}")
+
+    try:
+        mesh_data = load_mesh(target["model"], scale, mesh_module)
+        points_mv = mesh_data["points"].astype(np_float)
+        cells_mv = mesh_data["cells"].astype(np.int32)
+    except Exception as e:
+        raise RuntimeError(f"Failed to load mesh model '{target.get('model', 'unknown')}': {e}")
+    
+    # Enhanced FreeTier validation using helper function
+    _validate_mesh_for_free_tier(cells_mv.shape[0])
+
+    cdef float_t[:] origin_mv = np.array(target.get("origin", (0, 0, 0)), dtype=np_float)
+
+    location = list(target.get("location", [0, 0, 0]))
+    speed = list(target.get("speed", [0, 0, 0]))
+    rotation = list(target.get("rotation", [0, 0, 0]))
+    rotation_rate = list(target.get( "rotation_rate", [0, 0, 0]))
+
+    cdef float_t[:] location_mv, speed_mv, rotation_mv, rotation_rate_mv
+
+    permittivity = target.get("permittivity", 1e38)
+    permeability = target.get("permeability", 1)
+    if permittivity == "PEC":
+        ep_c = cpp_complex[float_t](<float_t>1e38, <float_t>0.0)
+        mu_c = cpp_complex[float_t](<float_t>1.0, <float_t>0.0)
+    else:
+        ep_c = cpp_complex[float_t](<float_t>np.real(permittivity), <float_t>np.imag(permittivity))
+        mu_c = cpp_complex[float_t](<float_t>np.real(permeability), <float_t>np.imag(permeability))
+
+    if any(np.size(var) > 1 for var in location + speed + rotation + rotation_rate):
+        if np.size(location[0]) > 1:
+            locx_mv = location[0].astype(np_float)
+        else:
+            locx_mv = (location[0] + speed[0]*timestamp).astype(np_float)
+
+        if np.size(location[1]) > 1:
+            locy_mv = location[1].astype(np_float)
+        else:
+            locy_mv = (location[1] + speed[1]*timestamp).astype(np_float)
+
+        if np.size(location[2]) > 1:
+            locz_mv = location[2].astype(np_float)
+        else:
+            locz_mv = (location[2] + speed[2]*timestamp).astype(np_float)
+
+        if np.size(speed[0]) > 1:
+            spdx_mv = speed[0].astype(np_float)
+        else:
+            spdx_mv = np.full(ts_shape, speed[0], dtype=np_float)
+
+        if np.size(speed[1]) > 1:
+            spdy_mv = speed[1].astype(np_float)
+        else:
+            spdy_mv = np.full(ts_shape, speed[1], dtype=np_float)
+
+        if np.size(speed[2]) > 1:
+            spdz_mv = speed[2].astype(np_float)
+        else:
+            spdz_mv = np.full(ts_shape, speed[2], dtype=np_float)
+
+        if np.size(rotation[0]) > 1:
+            rotx_mv = np.radians(rotation[0]).astype(np_float)
+        else:
+            rotx_mv = np.radians(
+                rotation[0] + rotation_rate[0]*timestamp).astype(np_float)
+
+        if np.size(rotation[1]) > 1:
+            roty_mv = np.radians(rotation[1]).astype(np_float)
+        else:
+            roty_mv = np.radians(
+                rotation[1] + rotation_rate[1]*timestamp).astype(np_float)
+
+        if np.size(rotation[2]) > 1:
+            rotz_mv = np.radians(rotation[2]).astype(np_float)
+        else:
+            rotz_mv = np.radians(
+                rotation[2] + rotation_rate[2]*timestamp).astype(np_float)
+
+        if np.size(rotation_rate[0]) > 1:
+            rrtx_mv = np.radians(rotation_rate[0]).astype(np_float)
+        else:
+            rrtx_mv = np.full(ts_shape, np.radians(rotation_rate[0]), dtype=np_float)
+
+        if np.size(rotation_rate[1]) > 1:
+            rrty_mv = np.radians(rotation_rate[1]).astype(np_float)
+        else:
+            rrty_mv = np.full(ts_shape, np.radians(rotation_rate[1]), dtype=np_float)
+
+        if np.size(rotation_rate[2]) > 1:
+            rrtz_mv = np.radians(rotation_rate[2]).astype(np_float)
+        else:
+            rrtz_mv = np.full(ts_shape, np.radians(rotation_rate[2]), dtype=np_float)
+
+        Mem_Copy_Vec3(&locx_mv[0,0,0], &locy_mv[0,0,0], &locz_mv[0,0,0], bbsize_c, loc_vt)
+        Mem_Copy_Vec3(&spdx_mv[0,0,0], &spdy_mv[0,0,0], &spdz_mv[0,0,0], bbsize_c, spd_vt)
+        Mem_Copy_Vec3(&rotx_mv[0,0,0], &roty_mv[0,0,0], &rotz_mv[0,0,0], bbsize_c, rot_vt)
+        Mem_Copy_Vec3(&rrtx_mv[0,0,0], &rrty_mv[0,0,0], &rrtz_mv[0,0,0], bbsize_c, rrt_vt)
+
+    else:
+        location_mv = np.array(location, dtype=np_float)
+        loc_vt.push_back(Vec3[float_t](&location_mv[0]))
+
+        speed_mv = np.array(speed, dtype=np_float)
+        spd_vt.push_back(Vec3[float_t](&speed_mv[0]))
+
+        rotation_mv = np.radians(np.array(rotation, dtype=np_float)).astype(np_float)
+        rot_vt.push_back(Vec3[float_t](&rotation_mv[0]))
+
+        rotation_rate_mv = np.radians(np.array(rotation_rate, dtype=np_float)).astype(np_float)
+        rrt_vt.push_back(Vec3[float_t](&rotation_rate_mv[0]))
+    
+    # Handle deprecated parameter with enhanced warning
+    if "is_ground" in target:
+        target["skip_diffusion"] = target["is_ground"]
+        _warn_deprecated_parameter("is_ground", "skip_diffusion")
+
+    targets_manager[0].AddTarget(&points_mv[0, 0],
+                           &cells_mv[0, 0],
+                           <int_t> cells_mv.shape[0],
+                           Vec3[float_t](&origin_mv[0]),
+                           loc_vt,
+                           spd_vt,
+                           rot_vt,
+                           rrt_vt,
+                           ep_c,
+                           mu_c,
+                           <bool> target.get("skip_diffusion", False))
+
 @cython.cdivision(True)
 @cython.boundscheck(False)
 @cython.wraparound(False)

src/radarsimpy/lib/cp_radarsimc.pyx

@@ -35,6 +35,7 @@ cimport cython
 
 # C++ type definitions
 from libcpp.string cimport string
+from libcpp.memory cimport shared_ptr, make_shared
 from radarsimpy.includes.type_def cimport (
     vector,
     float_t,
@@ -47,6 +48,7 @@ from radarsimpy.includes.radarsimc cimport (
     Radar,
     Point,
     Target,
+    TargetsManager,
     MeshSimulator,
     PointSimulator,
     InterferenceSimulator,
@@ -58,7 +60,8 @@ from radarsimpy.includes.radarsimc cimport (
 from radarsimpy.lib.cp_radarsimc cimport (
     cp_Radar,
     cp_Target,
-    cp_Point
+    cp_Point,
+    cp_AddTarget
 )
 
 from radarsimpy.mesh_kit import import_mesh_module
@@ -252,6 +255,8 @@ cpdef sim_radar(radar, targets, frame_time=None, density=1, level=None, interf=N
         vector[Point[float_t]] point_vt
         vector[Target[float_t]] target_vt
         Vec2[int_t] ray_filter_c
+        
+    cdef shared_ptr[TargetsManager[float_t]] targets_manager = make_shared[TargetsManager[float_t]]()
 
     # Simulator instances
     cdef:
@@ -330,6 +335,8 @@ cpdef sim_radar(radar, targets, frame_time=None, density=1, level=None, interf=N
             if mesh_module is None:
                 mesh_module = import_mesh_module()
             target_vt.emplace_back(cp_Target(radar, tgt, timestamp, mesh_module))
+
+            cp_AddTarget(radar, tgt, timestamp, mesh_module, targets_manager.get())
         else:
             # Extract point target parameters with defaults
             loc = tgt["location"]
@@ -386,7 +393,7 @@ cpdef sim_radar(radar, targets, frame_time=None, density=1, level=None, interf=N
         # Run scene simulation
         err = mesh_sim_c.Run(
             radar_c,
-            target_vt,
+            targets_manager,
             level_id,
             <float_t> density,
             ray_filter_c,