Asclepios DICOM Viewer

The asclepios::gui::TransferFunction class manages the visual properties of volume rendering, including window/level settings, lighting (shading), and the mapping of intensity values to colors and opacity.

Lighting and Window/Level

You can control the appearance of the rendered volume using:

• Window/Level: Controls the intensity range displayed.
• Shading: Toggles shading on/off via setHasShade and configures lighting parameters like setAmbient, setDiffuse, setSpecular, and setSpecularPower.

Color and Opacity Mapping

The class manages two types of transfer functions:

1. Color Transfer Function: Maps intensity values to RGB colors. It uses vtkColorTransferFunction internally.
2. Opacity Transfer Function: Maps intensity values to alpha (transparency) values. It uses vtkPiecewiseFunction internally.

Data Loading

• File Loading: Use loadFilterFromFile(const QString& t_fileName) to load transfer function configurations from a file.
• JSON Integration: The class provides internal methods extractColorFunctionInfo and extractOpacityFunctionInfo to populate transfer functions from QJsonArray data structures.

#include "src/gui/transferfunction.h"

asclepios::gui::TransferFunction tf;

// Configure window/level
tf.setWindow(400);
tf.setLevel(40);

// Configure shading/lighting
tf.setHasShade(true);
tf.setAmbient(0.2);
tf.setSpecular(0.8);

// Access underlying VTK functions for advanced manipulation
auto* colorFunc = tf.getColorFunction();
auto* opacityFunc = tf.getOpacityFunction();

The TabWidget class is a UI component used to manage different types of DICOM view tabs (2D and 3D/MPR). It acts as a container for WidgetBase objects and provides methods to create, reset, and manipulate these view tabs.

Creating View Tabs

• Use createWidget2D() to instantiate a 2D viewer tab.
• Use createWidgetMPR3D(WidgetBase::WidgetType t_type) to instantiate a 3D/Multiplanar Reconstruction tab. The type of 3D widget is determined by the WidgetBase::WidgetType provided.
• Use resetWidget() to clear the current tab content.

Tab Manipulation

• setTabTitle(int t_index, const QString& t_name): Sets the display name for a specific tab index.
• closeWidget(int t_index): Closes the tab at the specified index.
• onMaximize(): A slot to trigger the maximization of the current tab view.

State Inspection

• getWidgetType(): Returns the current WidgetBase::WidgetType of the active tab.
• getTabbedWidget(): Returns the pointer to the underlying WidgetBase instance.
• getActiveTabbedWidget(): Returns the WidgetBase currently being viewed.
• getIsActive(): Returns whether the tab widget is currently active.
• getIsMaximized(): Returns whether the tab view is in maximized mode.

// Example conceptual usage of TabWidget methods
asclepios::gui::TabWidget* tabWidget = new asclepios::gui::TabWidget(parent);

// Create a 2D view
tabWidget->createWidget2D();

// Create a specific 3D MPR view
tabWidget->createWidgetMPR3D(WidgetBase::WidgetType::MPR);

// Set a custom title for the first tab
tabWidget->setTabTitle(0, "Axial View");

// Check current state
if (tabWidget->getIsMaximized()) {
    // handle maximized state
}

The asclepios::gui::StudyList class is a QListWidget based component used to display and manage a list of DICOM studies and series. It allows developers to associate a specific core::Patient and core::Study with the list view and provides methods to populate the list with series and image data.

Key Functionalities:

• Data Association: Link the list to a specific patient or study using setPatient() and setStudy().
• Populating Content: Use insertNewSeries() to add new series and image information to the list.
• Concurrency Tracking: Access active background tasks via getFutures() to monitor loading or processing states.
• Signals: The finishConcurrent() signal is emitted when concurrent operations associated with the list have completed.

// Example usage of StudyList
#include "src/gui/studylist.h"

asclepios::gui::StudyList* studyList = new asclepios::gui::StudyList(parent);

// Associate with data
studyList->setPatient(myPatientPointer);
studyList->setStudy(myStudyPointer);

// Add content
studyList->insertNewSeries(mySeriesPointer, myImagePointer);

// Monitor background tasks
std::vector<QFuture<void>> tasks = studyList->getFutures();

// Connect to completion signal
connect(studyList, &asclepios::gui::StudyList::finishConcurrent, []() {
    // Handle completion
});

The CoreRepository class serves as the central repository for managing the hierarchy of DICOM data within the application. It manages the lifecycle and ownership of Patient, Study, Series, and Image objects.

Data Hierarchy and Ownership

• Ownership: The repository owns the Patient objects via std::unique_ptr. Other entities like Study, Series, and Image are managed via raw pointers (Patient*, Study*, etc.) which are updated as the user navigates the DICOM hierarchy.
• Navigation State: The repository tracks the 'last' accessed entity at each level of the hierarchy (getLastPatient(), getLastStudy(), getLastSeries(), and getLastImage()).
• Change Tracking: You can check if new data has been added to the current context using newSeriesAdded() and newImageAdded().

#include "src/core/corerepository.h"

asclepios::core::CoreRepository repo;

// Adding data
repo.addPatient(std::make_unique<Patient>(...));

// Accessing current state
asclepios::core::Patient* currentPatient = repo.getLastPatient();
if (repo.newSeriesAdded()) {
    // Handle new series logic
}

// Deleting data
repo.deletePatient(currentPatient);
// or
repo.deleteAllPatients();