2021-11-12

When serializing an object, it is now possible to request the serializer to create specific versions for
certain classes (older than their respective current versions), by means of
ReflectorInterface::desireClassVersions(). Note that most classes' serialization implementations do not yet
support this feature and will have to be updated before it becomes comprehensively usable. Desiring an older
version from a class that does not implement it will only result in a warning output, but not change the
behaviour otherwise (compared to past releases).

The service level for a remote channel subscription can now include an update interval, i.e. there will be a
minimum time between channel updates sent to the remote subscriber (in other words, the update rate is limited).
The purpose is of course to save transfer bandwidth for large data/high publish rate channels. The implementation
ensures the latest update is always sent to the remote subscriber if the minimum interval expires without newer
data being published (ensuring the subscriber will not permanently miss the latest channel state).
Of course this only works if local (subscriber) and remote (publisher) framework run with this neweest release
(or later). For connections to older remote frameworks, a ServiceLevel.Interval setting is ignored, just showing
a warning.

More consistent clock offset estimation for remote framework connections:
The clock offset is now only estimated on one end of the connection (the outgoing side), and applied to both
received and sent channel updates.
Formerly, both ends of the connection estimated the offset independently and applied it to received messages
only. This mostly lead to different estimates, which would then e.g. be applied as different corrections to
timestamps sent on a 'round trip'. That means when a publisher at framework A was publishing to channel CA
with a timestamp, and a subscriber in framework B was copying the received timestamp from CA, using it
to publish to channel CB, a subscriber to CB in framework A would then receive a timestamp significantly
different from the original publish to CA.
With the new correction scheme, the offsets applied on sending and receiving will cancel out, except for
changes of the offset estimation over time (which should be nearly insignificant for data sent and received
in quick succession).

Names of a couple of basic visualization classes has changed, in order to improve naming scheme consistency.
This may lead to existing workspace files becoming unloadable, as some stored class names are not valid
anymore. For convenience, an update script is provided which can be used to substitute the changed class
names in a workspace file: scripts/updateWorkspaces-Visualization.sh 

Clearer presentation of available visualizations when drag+dropping a channel to the MDI area or a view:
Visualizations can be marked as 'auxiliary' and will not appear in the visualization selection list although
they could take the respective channel as input. All items in the selection list got a tooltip showing their
description.
The 'auxiliary' categorization is done by the visualization's developer (together with the description).
E.g. Plot Threshold visualizations from 2021-05-19 release have been marked as auxiliary, for less clutter
in visualization selection dialog.
Auxiliary visualization can still be created from the VisualizationControl panel, as before. Users can also
change MIRACenter preferences to include them in selection lists again.

BarChart plots/visualizations from toolbox PlotVisualization have been not working since at least
MIRA Release 2017-01-18, they have now been fixed and are available again.

2021-07-28

Pending RPC calls will automatically return with an error when the corresponding service is removed (e.g. the
connection to a remote framework is lost), without having to wait for a timeout (or, even worse, wait infinitely).

The CRSplineInterpolator has been completed to be usable as an alternative to e.g. LinearInterpolator.

Authority constructor was ignoring the flag INDEPENDENT_SUBSCRIBER_THREAD,
and Authority::subscribeInterval() was ignoring the independentThread parameter. Both issues have been fixed.
(Authority::subscribe() was properly respecting its independentThread parameter though.)

Specifying explicit transformation types FIXED/MOVING (introduced 2021-12-23) has been simplified:
the type can be specified in config <link> tags (read by LinkLoader), and also in Authority::addTransformLink().
The documentation of the transformation framework has been updated to explain the meaning of fixed and moving
transformations.

Numerous improvements to tape handling:
Trying to open a tape that is not a file will throw with a meaningful error message (instead of reading garbage).
TapePlayer::stepTo(channel) could add some unnecessary waiting time, which was fixed. Also added stepToAnyOf()
to use multiple channels.
TapeRecorder could mess up message order when used with avoidDataLoss=true, fixed. Instead of waiting for
the recording queue to be processed in the background thread, TapeRecorder::stop() can return immediately and
rely on the caller to clean up the queue. This is used by the TapeRecorderWidget to show a progress bar while
waiting for the queue to finish. That widget now also allows to set a time limit when starting a recording.

Writing/posting to channels with an invalid timestamp (Time::invalid()) could easily terminate the entire program.
This could happen e.g. when unknowingly creating an unitialized Stamped<> while trying to post a channel-type
object to be initialized with an empty initializer-list. A number of fixes have been added to remove the risk
of termination (ensuring an exception is thrown, or, if that is unsafe, an error message displayed) and prevent
accidental wrong usage of Channel::post().

A possible deadlock was fixed between channel writers and interval readers when using up the channel's
maximum slot number (when writing faster than reading).

Toolbox Navigation: documentation has been updated for complete description of all task types provided by
the toolbox.

Toolbox RobotDataTypes: added IPTU (generic interface for Pan-Tilt-Unit driver).

Tool mirapackage supports git repositories whose default branch is not 'master'.

Tool miratape: simplified selection of a common time interval for play/merge with multiple tapes.



2021-05-19

Framework gets a new RPC method 'loadConfig' (designated by the new interface 'IConfigurationLoader'). Using
this RPC, additional configuration parts can be loaded at any time (just as they normally are at startup). Since
it is an RPC, this can even be done remotely.
MIRACenter's 'Configuration Editor' view has been upgraded and is now using this RPC. That means any valid
configuration can be entered (using the usual xml syntax) and executed. If remote frameworks are connected,
the config can be loaded to those, via a selection combobox.

RPC calls using parameters of type std::string do not need to explicitly cast string literals to search for the
correct RPC signature (like callService<void>("Service", "method", "std::string("foo"));). Such literals will be
recognized as std::string type automatically.

3D view gets new tools: "Localize - Position only" and "Localize - Orientation only". Services supporting the
respective RPC methods setInitPosition/setInitorientation will only re-initialize the position and keep the
current orientation distribution unchanged (or vice versa).
Furthermore, the interpretation of the selected range (for pose and orientation) by the Localize tools has
been changed to allow more intuitive input: where before the region was taken as sigma^2 (=variance), it
is now a 2*sigma range, i.e. 95% of distribution should be in this region.

PlotVisualization gets a bunch of useful new items: The Events visualization can plot a vertical line marker
for just the time of each channel update. Thresholds visualizations plot horizontal line markers, either from
channel data or from a manually edited property.



2021-04-07

Definition of RPC methods without RPC parameter documentation is marked as deprecated. Such definitions will
show compile time deprecation warnings. To get rid of these warnings, add parameter documentation (name, description
[, sample value] for each parameter) to the service's RPC method definitions (= calls to r.method() in reflect()).

RemoteConnection has been overhauled to make it more stable and fix frequent crashes on disconnection.



2021-02-17

Process supports recursive shutdown, i.e. stopping the spawned process will (optionally) also terminate all
descendant processes. The <process> configuration tag makes this available through its new attribute
'shutdownRecursively'.

Framework gets a new option '--show-variables' (available to tools like mira, miracenter etc.), which lists all
known configuration variables and their values at startup.

ConfigurationLoader plugins (handlers for configuration tags) hold the list of associated tags in their class
factory metadata. It is not required anymore to load all libraries with the loader implementations just to
determine which loader handles which tags. Only loader libraries required for present tags will be loaded.



2020-12-23

MIRA libraries are automatically registered to a LibraryRegistry on application start. The registry keeps track
of known libraries (=manifests) and loaded libraries, with their respective versions. The registry information is
available through new Framework RPC methods 'getLibraries'/'getLoadedLibraries'. MIRACenter gets a new
LibrariesListView where this information can be looked up, for the local or any connected framework.

The print() function gets a new 'CompactPrint' mode (no line breaks, helpful e.g. for logging), and a new parameter
to control the output floating point precision.

PropertyNode and property interaction tools like MIRACenter's property editor are significantly extended to support
dynamic properties (adding or removing properties at runtime).
The most notable use case is containers of dynamic size: the property editor will automatically update itself to
show when items are added or removed by internal processing (the option to let the user add or remove items through
the GUI is planned for the future).
This enables to add the RemoteModule with its (updating) list of current remote connections as read-only property
of the Framework itself.

A number of optimizations has been implemented to reduce overhead for internal copying of RPC parameters/results. In
some cases, internal processing amounted to up to 15 copy operations on a parameter object! Now copies are avoided
in favor of moves whereever possible, no more than 3 copies are ever necessary.
Note:
1. const& parameters and return values are more efficient than value parameters, even when used through RPC.
2. non-const reference parameters in RPC methods will lead to compile errors now. However, this has never been a valid
   option anyway, as RPCs are callable from a different process. That means there is no assumption of shared memory
   between caller and function, the reference will most likely just refer to a temporary variable in the RPC framework,
   no use modifying it.

FrameworkTransformer nodes can be marked as FIXED or MOVING. Creating such transformation nodes from model files will
automatically set their types, based on the Joint type. For fixed nodes, the corresponding channel's slot limit is
automatically set to 1, preventing (unwanted) interpolation when the transformation is changed (e.g. calibration, not
motion). MIRACenter's TransformTreeView shows the type of each node.

GUI widgets with filters do not filter once when the filter string is edited, but keep filtering when their content
changes (e.g. AuthorityView will show any authorities added later as long as they are matching the currently set filter).

The new interface IResourceFileProvider complements IRigidModelProvider: a service providing a model description can
also provide resource files for its visualization. RigidModelVisualization (for 3D view) tries downloading mesh files
that the model is referring to from the service, if they are not found locally.



2020-09-10

The time synchronisation between connected frameworks is smoothed: offset is aligned slowly between estimates,
to prevent changing the time order of channel updates received from remote framework when the offset estimation
changes by more than the channel update interval.

MIRACenter 3DView: camera motion discontinuities are fixed. Changing the CameraFrame property will adapt the camera pose
reversely to keep the current view unchanged, instead of moving around the camera.



2020-07-21

The RPC framework shows a warning when a service registers multiple methods with same name and parameter count (even with
different parameter types, aka 'overloading'), as these are not distinguishable for JSON RPC (all parameters are presented
as JSON representation, their type cannot be determined in general).

RemoteConnection stores incoming RPC requests and responses (to be transferred to the remote framework) in a queue
and handles the actual transfer in a separate thread. This avoids blocking the local RPC framework while waiting for a
slow/overloaded network connection.

Service levels for channel connections can now also be set by channel type (in addition to channel name). Thus it is
possible to e.g. select PngCodec to be used for all channels of type 'mira::Img<>'. Service levels set for individual
channel names take priority over service levels set for a channel type.

When writing a tape, compression can not just be enabled or disabled, but different levels of compression can be selected.
The TapeRecorder widget in MIRACenter presents a combobox for compression level instead of a checkbox.

MIRACenter AuthorityView shows unknown authority status (not queried yet or query RPC timed out) as 'Unknown' instead of
'Paused'. Start/Stop is split into two buttons, which also work while the respective authority status is locally unknown.



2020-06-03

Framework's variables and aliases (<using> declarations) are exposed through new RPC methods 'getAliases'/'getVariables'.
MIRACenter DefinitionsListView uses these to query and present the definitions from all connected frameworks.



2020-04-26

JSON values always keep maximum floating point precision when transferred to a remote framework
(not limited to local default display precision). Most notable case is JSON RPC parameters/return values.

MIRA exception types are now serializable. When an exception is thrown within an RPC method, it is serialized
and transfered to the call site. The caller can choose whether in that case a generic XRPC or the restored specific
exception should be thrown to him by the RPC framework, via a parameter in his call to RPCFuture::get().
(Previously, XRPC was the only option, in that case the message string is the only element identifying the original
error).
