- add a new job that calls sight-git's sight-cov to create a coverage report.
- pushes a comment using gitlab api to the current MR.
- removes any previous comment left by this same job.

- Enable drawing fiducial graphic data
- Store the referenced frame and graphic data when querying fiducial data
- Update fiducials_series data with convenience methods
- Add helper functions to draw fiducial content

Our root folders uses plural names like `libs` and `modules` while we use the singular in the C++ namespaces. Now we use the singular everywhere.

- Fix large file (>2GB) support
- use low level nifti

* Only for buttonbar for now

- Updated the docker image and the sight-gitlab references
- Implemented `sight::io::joystick::interactor`, `sight::io::joystick::detail::event_loop` and a module `sight::modules::io::joystick`.

#### sight::modules::io::joystick module

Controls the global joystick `event_loop` instance.

Basically, it starts it when `sight::modules::io::joystick::plugin::start()` is called and stops it on `sight::modules::io::joystick::plugin::stop()`. Once started, registered `interactor` will start receiving joystick events.

There is a unit test (`sight::module::io::joystick::ut`) which demonstrates basic usage, the support of module unloading, etc..

#### sight::io::joystick::detail::event_loop class

This is where the whole implementation is. It is a singleton that uses a timer to poll for SDL events on the main thread. When one is catch, it is simply forwarded to the registered `interactor` with specific callback functions. It implies that all callback functions are executed on the main thread, so you may have to protect the access if your service runs on a specific worker.

The code of `instance()` could have been simpler, but, since we are dealing with posted tasks on the main thread, special care has been needed to let the instance die without making waiting tasks crash.

#### sight::io::joystick::interactor interface

This register / unregister automatically to the `event_loop` any class that inherits from it. Then, these callbacks will be available:

``` c++ 
    void joystick_axis_motion_event(const axis_motion_event& _event);
    void joystick_axis_direction_event(const axis_direction_event& _event);
    void joystick_hat_motion_event(const hat_motion_event& _event);
    void joystick_ball_motion_event(const ball_motion_event& _event);
    void joystick_button_pressed_event(const button_event& _event);
    void joystick_button_released_event(const button_event& _event);
    void joystick_added_event(const joystick_event& _event);
    void joystick_removed_event(const joystick_event& _event);
```

All callbacks use "event" structures, which should provides all needed information (device name, index, guid, axis, buttons, ...). Indeed, almost all of what is available from SDL is forwarded.
Additionally, it is possible to list all attached devices with `devices()` and to temporary stop receiving event with `block_events(bool)`.

> `joystick_axis_direction_event` is derived from `joystick_axis_motion_event`, but instead of sending the axis values on every change, it converts it to "up" or "down", and is only trigered once, until the axis goes back to neutral.

We need to set the material permutation before generating any subsequent rendering pass, otherwise these passes, like the selected material, may end-up with the wrong vertex/fragment program.

- Relayout, fix spacings / margins, cleanup, fix bugs so that the settings widgets are correctly displayed. This is not perfect (the vertical mode of checkbox is not fully centered ...because the widget is not symmetric!), but this is an overall improvement.

Flavien BRIDAULT authored 1 month ago and Flavien BRIDAULT committed 1 month ago

This option mode can be set on a material to highlight some meshes.

Flavien BRIDAULT authored 1 month ago and Flavien BRIDAULT committed 1 month ago

The 2D and 2D negatoscopes code was also widely refactored to share as much code as possible; this will make future maintenance easier.

Luis MENDOZA authored 1 month ago and Luis MENDOZA committed 1 month ago

- Some services handle their services on their own. The registering service doesn't handle start so we want to at least be smart about the stop and do it only when needed

Under windows, we previously used standard threads which is significantly slower, in particular for vtkImageReslice. We now built TBB support in our VCPkg which allows us to switch to the TBB backend on both platforms.

A new service `sight::module::data::validate` was implemented to validate objects in a generic way. Here is an example to check that an image is filled:

```xml
<service uid="..." type="sight::module::data::validate" >
    <in key="data" uid="image"/>
    <config id="sight::data::validator::filled" />
</service>
```

It provides the following signals in XML, which can be connected to your application logic:

* valid()
* invalid()
* is_valid(bool)
* is_invalid(bool)

Also, a new validator `sight::data::validator::has_fiducials` was implemented to check if a series contains at least one fiducial.

This service allowing to display a string and a label can now take any data inheriting from data::serializable as input.
A suffix can also be added, and it is possible to customize the font size and weight.

Instead of creating a material adapter to bind shader uniforms and then referencing that material, we can now pass them directly to the mesh, reconstruction, model_series, and point_list adaptors. This is especially useful for model_series, because each mesh within it has its own material; so we couldn't pass a material adapter for each one.

This mask can be used to hides part of the image.

First, a new object validator that verifies if an object is empty. For now it handles `sight::data::image` and `sight::data::point_list`. It is likely to be extended to support more object types in the future. 
Then some cleaning was required in the configuration manager to make recent features compatible with activities. For instance, we require activity objects to have a real unique identifier that matches the requirement names. This is mandatory to get those objects work with the recent `sight::ui::module_qt::settings` service.

This slots was clearly duplicated in the API comparing to start_camera. A new configuration setting was added to select a given grabber according to the camera identifier.

This is a port from Qt 5 to Qt 6.

Included:
- Use new Qt 6 VCPKG and Qt 6 docker image
- Updated many dependencies due to VCPKG update
- Removed QML, Qt3D

Also:
- Removed deprecated boost::asio::io_service
- Fixed rare race condition in worker_asio
- Fixed selector
- Fixed http post test
- Fixed video_controls GUI tests
- Fixed cardinal layout main title
- Sequencer widget reimplementation
- Removed CMake warnings and deprecated code

Flavien BRIDAULT authored 1 month ago and Flavien BRIDAULT committed 1 month ago

A new service to extract activity objects was added. This can be useful for extracting objects in an application's main configuration, for instance.

```xml
<service uid="..." type="sight::module::data::get_activity_object" >
    <in key="activity_set" uid="..."/>
    <id>...</id>
    <out group="objects">
        <key name="requirement1" uid="..."/>
        <key name="requirement2" uid="..."/>
    </out>
</service>
```

Luis MENDOZA authored 1 month ago and Luis MENDOZA committed 1 month ago

- add an example of usage for this service in the tuto14GUI

Marc SCHWEITZER authored 1 month ago and Marc SCHWEITZER committed 1 month ago

* add new qss class to round background as toolbar

This _should_ stabilize GUI tests a bit. This roughly fixes a kind of race condition in the GUI test start and stop code.

When test instructions are posted in the GUI thread (because we must do that to manipulate GUI stuff), mutexes are used to allow the test thread to wait until the current test instruction is processed on the GUI thread event loop. This mechanism works well, ...until the last window is closed, which exit the application. In that case, the GUI event loop is stopped straight, which is not problematic most of the time in a real application, but unfortunately in a GUI test, if something that should have been processed is still in the event loop, like the synchronization mutex unlock, the calling thread will simply expire, making the test fail.

This MR try to work around that, we try to avoid closing the window in the GUI event loop, we try to close _ALL_ window, including modal dialogs, and we try to flush the GUI event loop before exiting the test thread.

`sight::module::ui::qt::signal_shortcut` provides a signal that can be connected in XML, triggered by a keyboard shortcut.

We added an optional toggle state, offering a similar signal/slots interface as a `sight::module::ui::action`:
 - is_checked(bool): Emitted when the state is checked or unchecked.
 - checked(): Emitted when the state is checked.
 - unchecked(): Emitted when the state is unchecked..
 - set_checked(bool): sets whether the state is checked.
 - check(): check the state.
 - uncheck(): uncheck the state.

On top of that, three other improvements were made:
- a comma or semi-colon-separated list of shortcuts can be given
- the `QShortcut` are now only created when the state is enabled, which allows to have multiple services running at the same time on the same shortcut, but of course, only one can be enabled at once, and it will be up to the developer to ensure that
- the unit test has been really implemented, testing previous and new features