Software development for Dr. Sennewald Medizintechnik GmbH

The initial situation

Dr. Sennewald Medizintechnik became aware of t2informatik through a recommendation from the Hamburg-based design company Held+Team. Held+Team had already successfully designed the user interface (GUI) for the project and was convinced that in t2informatik they had found the ideal partner for the technical implementation. This recommendation was based on positive experiences from previous projects as well as on t2informatik’s recognised expertise in the realisation of sophisticated software solutions.

From the very first exchange, it became clear that t2informatik’s approach was an excellent match for the project’s requirements. While Held+Team continued to refine the visual design, t2informatik took over the seamless and efficient implementation of the user interface. The result: a solution that not only impresses in terms of functionality, but also meets the highest design standards.

The process from the point of view of Dr. Sennewald Medical Technology

The collaboration was characterised by a high level of technical expertise, clear communication and a spirit of partnership throughout the entire project.

Porting and reusing the model logic from the C++ prototype

At the beginning of the collaboration, a first prototype was developed in C++ with WinUI 3. To optimise performance, the application was split into two separate components: the existing model logic from C++ was retained, while the rest of the application was rebuilt.

Reusing the model part was particularly valuable because the dose calculations are implemented in a C++ library. This decision enabled us to quickly provide a first functional version of the new application. For the user interface, we chose Avalonia, a cross-platform open-source UI framework that is particularly suitable for desktop applications and is continuously being developed.

Architecture for distributed work on the app and model

To enable parallel development of the application and model, the project was split into separate GitHub repositories. New model versions could be integrated iteratively into the application as NuGet packages. A shared interface library ensured clearly defined and strictly adhered-to communication between the two components.

One particular advantage of this architecture is that a simplified model variant could be implemented in the application during development. This allowed the UI to be developed independently without having to wait for the latest model versions. This approach proved to be extremely efficient and productive during the course of the project.

Integration of C++ code in a.NET environment

The existing C++ library was integrated into the.NET ecosystem via C++/CLI. This technology is mainly used to convert data between environments and to forward function calls. The result is a compact.NET-compatible DLL that was integrated into the application as a NuGet package.

Integration of VTK visualisations into Avalonia

To visualise medical data such as DICOM images and volume data, VTK (Visualisation Toolkit) was used – a widely used technology developed in C++ for displaying complex scientific and medical data. Since the model logic is also written in C++, VTK could be seamlessly integrated.

Kitware’s ActiViz.NET was used for the user interface – a.NET wrapper library for VTK. It offers both an interface to VTK and its own controls for 2D and 3D representations. This meant that integration could be realised with minimal effort.

During the course of the project, an architecture was developed that enables the creation of complex UI interactions with VTK.

Design and implementation of a Redux-based MVVM architecture

To meet the requirements of complex data structures, a Redux store was integrated to efficiently manage state changes. A specially developed, slim Redux variant was used, which has proven to be powerful and reliable in practical use.

The Redux store is tightly integrated into the model layer, while the application’s other components are built according to the classic MVVM (Model-View-ViewModel) principle. This architecture ensures a clear separation of the user interface and business logic and provides a clear, maintainable code base.

CI/CD pipeline and release process

A CI/CD pipeline was set up at the start of the project to ensure seamless integration and continuous delivery. Every time a change was made to the main development branch, a new version of the application was automatically built and made available for testing. This meant that an up-to-date and functional version of the software was always available.

In addition, a structured release process based on GitFlow was defined. During the course of development, several releases were successfully simulated to optimally prepare and test the transition from the development phase to market launch.

Agile process model for an efficient development process

To ensure that the project ran efficiently and transparently, a suitable agile process model was introduced. This included, among other things,

• daily stand-up meetings to promote exchange within the team and ensure daily coordination.
• weekly reviews with live demos to make progress tangible and enable early feedback.
• Short iterations in one-week sprints to regularly deliver functioning results.

This approach not only enabled the project to progress steadily, but also strengthened mutual trust within the team and sustainably boosted the motivation of everyone involved.