ros-kinetic-ainstein-radar-filters (3.0.1-1xenial) xenial; urgency=high

  * Minor, add missing dependency
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Tue, 11 Feb 2020 06:00:00 -0000

ros-kinetic-ainstein-radar-filters (3.0.0-1xenial) xenial; urgency=high

  * Add Cartesian tracking filter tracked pose output
    Added publishing of tracked object poses as geometry_msgs/PoseArray msg
    populated from tracked Cartesian position and using Cartesian velocity
    to determine pose. Forward direction (+x) is defined by tracked 3d
    velocity direction, with other axes determined by completing a right
    handed frame with +z up. Unfortunately, velocities cannot be published
    themselves without defining a custom TwistArray message, but nothing
    similar is supported natively in eg RViz.
  * Update Cartesian tracking filter, fix bugs and tune
    Updated the Cartesian tracking filter to use the measured position
    instead of measured unit direction, since we can measure range with
    most radars. Fixed other bugs in implementation and got working.
    Tuned resulting filter parameters to get decent tracking, now working
    similarly to old tracking filter (in spherical coordinates). Still need
    to add full Pose and Twist output; currently converting to RadarTarget
    for backwards-compatibility with other radar filters.
  * Minor, remove outdated filter config
  * Add Cartesian tracking filter, needs debugging
    Added a Cartesian coordinates tracking filter for radar data which
    stores object state as Cartesian position and velocity rather than
    spherical coordinate range/angles/speed. The advantage is that we can
    track the full Cartesian velocity by using information from the radar
    speed measurement (which is a projection onto the radian direction) and
    consecutive range/angle measurements. This unfortunately makes the KF
    into an EKF because the measurements are now nonlinear in Cartesian
    space.
    The filter compiles and runs but never outputs tracked targets in its
    current state, and thus needs debugging. Since the RadarTarget datatype
    is not capable of storing full 3d velocity anyway, we need to output
    eg Pose and Twist types instead. Since the filter stores uncertainty,
    we can use PoseWithCovarianceStamped and TwistWithCovarianceStamped.
  * Add support for point cloud input to radar tracking
    Added the ability for the radar tracking filter to subscribe to either
    a RadarTargetArray or PointCloud2 message. Internally, subscribing to
    a point cloud message converts to radar message type and then calls the
    original radar callback. This was added for portability since radar and
    point cloud messages are used with radar sensors often interchangeably.
  * Minor, explicitly copy header in conversion
  * Minor, remove outdated nodelet plugin
  * Merge branch 'master' of https://github.com/AinsteinAI/ainstein_radar
  * Update combine filter example launch and fix bug
    Updated the radar combine filter example launch file in the
    ainstein_radar_filters package to show how to launch three K79 radars
    and run the combine filter.
    Also fixed a bug in which the dynamic configuration was set for all
    possible numbers of radars which caused runtime errors because only one
    of the time sync objects was valid. Now checking the number of topics
    and only setting that object.
  * Fix race condition in KF-based tracking filter
    Fixed a race condition in which the KF update loop and the radar data
    callback were in a race condition, with the number of KFs possibly
    changing during processing of new incoming data. Added a mutex to
    synchronize these functions, however the downside is potentially
    slower processing speed due to blocking waits for mutex unlocks in
    the data callback. Should be fine for small numbers of KFs.
  * Fix broken radar to point cloud conversion node
  * Minor, change passthrough filter default field
  * Add example launch for radar combine filter usage
    Added a launch file example for using the radar combine filter to sync
    three RadarTargetArray topics. Note that the topic names must be set
    as an arg and passed in through rosparam due to the parameter being a
    list of strings. Also note that the "slop" factor in message syncing
    has its default set in the cfg/ file and can be loaded using the usual
    dynamic reconfigure loader.
  * Add up to 8 synchronized topics in combine filter
    Added the ability to synchronize up to 8 RadarTargetArray topics in the
    combine filter. In theory the approximate time synchronizer in ROS can
    support 9 topics, HOWEVER boost::bind (which is used to register the
    callback) only supports 9 total arguments, the first of which in this
    case must be the "this" pointer because we bind a class member function
    here (see https://www.boost.org/doc/libs/1_45_0/libs/bind/bind.html#NumberOfArguments)
    The ability to synchronize radar topics beyond 3 has not been tested
    with data (only checked for compilation).
  * Merge branch 'master' of https://github.com/AinsteinAI/ainstein_radar
  * Minor, add dynconfig update to combine filter
  * Minor, needed to negate speed for K79-3D using new SNR firmware
  * Refactor to clean up combine filter callbacks
    Refactored the combine filter's callbacks to use one central callback
    which works for any number of topics. This cleans up the overloaded
    callbacks a bit before adding the callbacks for >3 topics (to come
    next).
  * Minor, refactor combine topic names for consistency
  * Refactor combine filter for 2 or 3 topics via param
    Refactored the radar combine filter to approximately sync 2 or 3 topics
    by reading in a list of topic names and calling appropriate templated
    functions for setting up the time synchronizer and registering callback
    functions for each. This is not very clear but since the time sync
    variables are templated on the exact number of topics, the use of pre-
    defined templated variables for each number of topics seems unavoidable
    unfortunately.
    Tested by using rosbag_tools to change the frame ID of sample K79 data
    in different output bagfiles, playing back those bag files, remapping
    the topic name to something unique and defining static tf publishers to
    translate the data around before combining.
    Next, need to consolidate the actual combination callback code and add
    templated variables/functions for all other topic numbers (4-9, since
    ROS in C++ supports syncing up to 9 topics. Under the hood, this also
    uses messy templated code!)
  * Fix radar passthrough filter output transform
    Fixed the output radar passthrough filter cloud to transform the data
    properly in all cases.
  * Pull out coordinate transform utility functions
    Pulled utility functions for spherical<->Cartesian coordinate
    transforms and made message converstion depend on them.
  * Minor, add passthrough output tf to original frame
  * Fix radar passthrough filter output frame missing
    The output message published by the passthrough filter needs to be set
    explicitly, since the pcl conversions and passthrough doesn't preserve
    the frame ID (this should be debugged as it's desired for the frame to
    be set at each step). Thus, we explicitly set the output frame before
    publishing.
  * Add input/output frame params to radar passthrough
    Added the ability to specify input and output frames for the radar
    passthrough filter which function in the same manner as those in
    the pcl_ros package.
    The input_frame parameter specifies the frame in which the filtering
    should be performed, ie the input message is first converted to this
    frame before filtering. Note that this converts to a PointCloud2 and
    uses doTransform, so at the moment it *does not transform the radar
    fields (range, angles)* and is meant to be used for xyz filtering like
    the pcl_ros version. By default, the input frame is used and no
    transform is performed.
    The output_frame specifies the frame to publish the filtered data in
    after filtering. This is the original frame of the message by default
    but can be anything, including the input_frame.
    This functionality needs testing with hardware to confirm, and may be
    refactored to use a radar-specific doTransform soon.
  * Add PointCloud2 conversion to RadarTargetArray
    Added a ROS cloud to radar array conversion using the PCL to radar
    converter as an intermediate step.
  * Finish combine filter for two radar topics, tested
    Finished writing and testing the radar combine filter to approximately
    sync two RadarTargetArray topics and combine them via PointCloud2
    combine functionality.
    This was tested with a single radar and the relay node from topic_tools
    package; next test with multiple radars.
  * Comment out radar transform function, add later
    Commented out the radar transform function because the pointcloud
    transform function from pcl_ros does not support tf2 in any way, so
    the best way to do this is probably convert to a PointCloud2 message
    and use tf2::doTransform. This function itself is templated on the data
    type and should be specialized to RadarTargetArray to do native tf2
    transforming - add this later.
  * Fix pcl to radar conversion, add convert to degrees
  * Fix pcl to radar target conversion
    Fixed the pcl point to radar target conversion to calculate the new
    spherical coordinates instead of copying from the extra fiels in the
    PCL struct. This is necessary in case the point has been transformed
    before being converted back to a radar target.
  * Add combine filter for two radar topics, needs test
    Added a filter to combine two radar topics using an approximate time
    synchronizer, however this assumes the original messages are both in
    the same frame ID. Next, need to add conversion to the specified output
    frame ID.
    Compiles but needs testing.
  * Add changes to fix previous commit
  * Modify laser scan conversion to add nodelet
    Added a laser scan conversion nodelet after modifying the laser scan
    conversion class.  Needs testing.
  * Minor, add missing nodelet to install
  * Remove range filter, deprecated by passthrough
    Removed the old radardata range filter because the new passthrough
    filter based on the PCL library passthrough filter functionally
    deprecates the range filter (passthrough is more general, as it
    applies to any field including range).
  * Refactor tracking and nearest target filter naming
    Refactored the tracking filter and nearest target filter to rename them
    according to a new convention for filters, removing the word radar
    since this is evident from the namespace ainstein_radar_filters scope.
  * Major refactor, add conversion header and nodelets
    Refactored the conversion utilities to live within a namespace instead
    of the radar to pointcloud class, changed their usage in all dependent
    files.
    Added nodelets for the passthrough and radar to pointcloud filters,
    tested on K79 data. Removed old nodelets which weren't being built
    properly.
  * Add generic passthrough filter for radar data
    Added a generic radar target array passthrough filter which functions
    exactly the same as those provided by pcl_ros. Uses dynamic reconfigure
    to allow changing the filter field and limits as well. Tested and works
    as expected. Next, will add a nodelet version.
  * Add conversions from point cloud back to radar data
    Added new conversions for PCL point/point cloud types to radar ROS
    message types (opposite of what previously existed).
  * Refactor radar to ROS point cloud conversion node
    Refactored the raadr to point cloud conversion node to separate the
    class (which only has static functions that should be moved to a
    utilities library at some point instead) from the node itself so that
    other classs/nodes can use the conversion functionality.
  * Minor fixes to radar+camera fusion launch and node
    Fixed the radar+camera fusion launch file to use the updated topic
    names for radar and camera data. Also fixed the fusion class itself to
    prevent crashing when empty bounding box arrays are processed. This
    node is still intended for use with the tracking filter.
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Thu, 06 Feb 2020 06:00:00 -0000

ros-kinetic-ainstein-radar-filters (2.0.2-1xenial) xenial; urgency=high

  * Minor, fix header exports breaking bloom build
  * Rename input/output radar topics
    Renamed all instances of radardata_in and radardata_out to radar_in and
    radar_out to conform with other packages.
  * Fix laser scan converter params, remove deprecated
    Fixed the min/max range for the laserscan converted to be 0.0 and 100.0
    respectively by default so that the filtering by range doesn't affect
    most radars by default. These paremeters are required by the laserscan
    message and should instead be set from the RadarInfo message, to be
    done soon. Also removed some deprecated code.
  * Remove deprecated file and code from pcl converter
    Removed an old file for testing the pointcloud (pcl) converter class
    and removed old code from the pointcloud converted class which was
    previously used to filter targets based on relative speed.
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Tue, 19 Nov 2019 06:00:00 -0000

ros-kinetic-ainstein-radar-filters (2.0.1-1xenial) xenial; urgency=high



 -- Nick Rotella <nick.rotella@ainstein.ai>  Tue, 12 Nov 2019 06:00:00 -0000

ros-kinetic-ainstein-radar-filters (2.0.0-1xenial) xenial; urgency=high

  * Add K79 people tracking filter launch and params
  * Add tf2_eigen dependency to build
  * Minor, fix jsk messages dependency
  * Add bounding box output from radar tracking filter
    Added publication of bounding boxes for the tracked targets of the
    radar target tracking filter, computed to bound all targets used for
    a Kalman Filter update at each step.  This is a sort of "model-based
    clustering" of radar data since the KF itself tracks with the aid of
    a simple motion model.
    Next, plan to add Cartesian pose+covariance output.
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Tue, 12 Nov 2019 06:00:00 -0000

ros-kinetic-ainstein-radar-filters (1.1.0-1xenial) xenial; urgency=high

  * Minor, add radar SNR as laserscan intensities
  * Refactor pointcloud and laserscan converters
    Refactored the radar to pointcloud and laserscan conversion class and
    nodes in order to remove deprecated functionality and keep topic names
    consistent between them. The laserscan converter still has filtering
    based on the min/max angle/range parameters which should be removed and
    these parameters should be set from a radar sensor info message similar
    to camera info.
  * Minor fixes to package XML formatting
    Fixed the package XML file formatting and added missing content to
    conform to the suggested style guidelines.
  * Expose radar target array to point cloud conversion
    Exposed a function from ainstein_radar_filters which converts from the
    RadarTargetArray message type to the custom PCL point cloud type which
    includes radar data by making it static.  This was needed for new
    tools which need easy access to a polar-to-cartesian function. It may
    make more sense to pull out such conversions and put them in utility
    class somewhere else.
    Note that the only change to CMakeLists required to expose the header
    from this package to any package which imports it was to add an
    INCLUDE_DIRS line in the catkin_Package() function of this package.
  * Add param for fixed frame to point cloud converter
    Add an optional fixed frame parameter for the radar target array to
    point cloud converted which takes in the name of the fixed frame,
    otherwise defaulting to map. Previously, map was hardcoded.
  * Refactor redundant radar to pointcloud class
    Refactored the old, redundant radar to pointcloud converter class and
    associated node/lets to a radar speed filter class, preserving the
    projected speed filtering functionality. Tested on K79 data and working
    with mock zero speed command, should test further with nonzero GPS
    speed.
    There is still deprecated functionality in this class for testing the
    radar rotated which should be removed at some point as this was only
    experimental.
  * Use custom PCL radar point for data converter class
    Switched from using the normal pcl::PointXYZ type to the custom radar
    specific ainstein_radar_filters::PointRadarTarget type in the radar to
    point cloud conversion class. Tested on radar data and verified that it
    allows coloring clouds according to additional radar-specific fields eg
    range, speed, etc. This permits using existing point cloud-based filter
    node/lets to filter based on radar parameters, deprecating eg the range
    filter class in this repo.
    Also removed a debug printout from the rviz plugin class.
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Tue, 29 Oct 2019 05:00:00 -0000

ros-kinetic-ainstein-radar-filters (1.0.3-1xenial) xenial; urgency=high

  * Minor bug fix in tracking filter update
    Fixed a small bug in the Kalman Filter state covariance update equation
    which had an extra transpose in it. This likely didn't affect filter
    performance noticeably because it only affected off-diagonal elements.
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Thu, 03 Oct 2019 05:00:00 -0000

ros-kinetic-ainstein-radar-filters (1.0.2-1xenial) xenial; urgency=high



 -- Nick Rotella <nick.rotella@ainstein.ai>  Wed, 25 Sep 2019 05:00:00 -0000

ros-kinetic-ainstein-radar-filters (1.0.1-1xenial) xenial; urgency=high

  * Refactor filters into separate subpkg, fix bug
    Created subpackage ainstein_radar_filters for radar filters and
    conversions, moved all filters from ainstein_radar_drivers into this
    subpkg and tested build and launch on rosbag data.
    Also fixed a small bug in the radar data range filter in which the
    dynamic reconfigure callback was not being registered, preventing the
    filter from working. Now, the filter compiles and works properly.
  * Contributors: Nick Rotella

 -- Nick Rotella <nick.rotella@ainstein.ai>  Tue, 24 Sep 2019 05:00:00 -0000


