RadarRotatingBearingRange(ndim_state=6,
position_mapping=(0, 2),
noise_covar=np.diag([np.radians(1.2)**2, 8**2]),
dwell_center=State(StateVector([0])),
rpm=20,
max_range=60000,
fov_angle=np.radians(360)),
]
platforms = []
# Create a platform for each stationary sensor and add to list of platforms
for sensor, platformLocation in zip(stationarySensors, (heathrow, manchester)):
platformState = State([[platformLocation[0]], [0], [platformLocation[1]],
[0], [0], [0]])
platform = FixedPlatform(platformState, (0, 2, 4), sensors=[sensor])
platforms.append(platform)
# Create moving platform
movingPlatformInitialLocation = utm.from_latlon(52.25, -0.9, utm_zone)
movingPlatformState = State([[movingPlatformInitialLocation[0]], [0],
[movingPlatformInitialLocation[1]], [250], [0],
[0]])
movingPlatforms = [
MultiTransitionMovingPlatform(movingPlatformState,
position_mapping=(0, 2),
transition_models=transition_models,
transition_times=transition_times,
sensors=movingPlatformSensors)
]
#
# Because the platform is static we only need to define :math:`(x, y, z)`, any internal interaction with the platform
# which requires knowledge of platform velocity :math:`(\dot{x}, \dot{y}, \dot{z})` will be returned :math:`(0, 0, 0)`.
# First import the fixed platform
from stonesoup.platform.base import FixedPlatform
# Define the initial platform position, in this case the origin
platform_state_vector = StateVector([[0], [0], [0]])
position_mapping = (0, 1, 2)
# Create the initial state (position, time), notice it is set to the simulation start time defined earlier
platform_state = State(platform_state_vector, start_time)
# create our fixed platform
platform = FixedPlatform(states=platform_state,
position_mapping=position_mapping)
# %%
# We have now created a platform within Stone Soup and located it at the origin of our state space. As previously stated
# the platform will have a velocity :math:`(\dot{x}, \dot{y}, \dot{z})` of :math:`(0, 0, 0)` which we can check:
platform.velocity
# %%
# We can also query the platform orientation:
platform.orientation
# %%
# Create a Sensor
# ---------------
# Now that we have a platform the next step is to create a sensor which can be added to the platform. In this example a
# Radar will be created which is capable of measuring the range, bearing and elevation of the target relative to the
# ------------------------------------
# The sensor converts the Cartesian coordinates into range, bearing and elevation.
# The sensor is then mounted onto a platform (stationary in this case)
from stonesoup.platform.base import FixedPlatform
from stonesoup.sensor.radar.radar import RadarElevationBearingRange
from stonesoup.simulator.platform import PlatformDetectionSimulator
from stonesoup.types.state import State
sensor = RadarElevationBearingRange(
[0, 2, 4],
meas_covar,
6,
)
platform = FixedPlatform(
State([0, 0, 0, 0, 0, 0]), # Sensor at reference point, zero velocity
[0, 2, 4],
sensors=[sensor])
# Create the detector and initialize it.
detector = PlatformDetectionSimulator(ground_truth_reader, [platform])
# %%
# Setup Initiator class for the Tracker
# ---------------------------------------
# This is just an heuristic initiation:
# Assume most of the deviation is caused by the Bearing measurement error.
# This is then converted into x, y components using the target bearing. For the
# deviation in z,
# we simply use :math:`R\times\sigma_{elev}` (ignore any bearing and range
# deviation components). Velocity covariances are simply based on the expected
# velocity range of the targets.