Skip to main content

Using generic configuration

In most cases, even a processing-only prototype requires some configurability by the user. The respective target environments AIRC research as well as open apps allow for user specific configuration:

  • In the open apps case, this can be found in the options section of the syngo system (e.g. syngo.via). The configuration settings are valid on a system level.
  • In AIRC research this is part of the configuration screen in the AIRC portal. The configuration settings are valid on institution level.

The interesting configuration property for our DicomImageRotator app is of course the rotation angle. In this tutorial we will add configurability of this angle utilizing the generic config UI functionality offered by the Frontier Fusion environment.

For using the generic configuration approach, the prototype needs to be prepared to read a config JSON file from a certain directory. This directory will be provided as command line argument.

Adding generic configuration to our Prototype

Step 1: Enable the prototype to read config from JSON file

The provided example is already prepared to read the configuration of the rotation angle from a JSON file. Find the place in the source code and understand how to read the config file using the config directory provided as a command line argument.

note

In case the file does not exist, it uses the default of 90 degrees. It is critically important that the prototype is robust enough to work also in cases when the config file is not existing or corrupted (e.g. by applying sensible defaults).

The expected config file for our prototype is quite simple:

{
"angle": "90"
}

So we need to create a generic config form with one parameter called "angle".

Step 2: Provide the name of the config file

In the dev portal, open the application config section and switch to the "User Interface tab. Make sure that "Generic" is coloured by orange as currently chosen. This means that a generic UI is used (for configuration as well as for viewing/confirmation of results). Using a custom UI is a topic for a different tutorial.

As we can see in the code, the expected config file name is "RotateAngleConfig.json". Enter this name in the config form under "Configuration file name".

Afterwards we need to configure the structure of the configuration object. For this purpose the dev portal offers the input field "Configuration JSON schema". Initially it shows an example demonstrating the different data types and capabilities it supports. As mentioned, in our case we only need a single parameter named "angle". Hence, we need to replace the default JSON with this:

{
"type": "object",
"properties": {
"angle": {
"type": "integer",
"maximum": 180,
"minimum": -180
}
},
"required": [
"angle"
]
}

This should be rather self-explanatory.

Copy this text and add it to Configuration JSON Schema.

Generic config

Additional config parameters can be added in a similar way as the "angle". Supported data types can be derived from the default config (press the "restore defaults" button).

Now we can have a preview of the configuration. This is done automatically after updating the scheme.

Generic config The preview form will also indicate that this is a mandatory field.

Save this configuration.

Step 3: Create a new deployment

Before we can redeploy the modified prototype, we need to create deployable artifacts. Select the "Deployments" tab of the application.

Add a new "deployment with the "+" button in the lower right corner.

A wizard-like screen will appear. In the first step, select the configuration version which you just created. Ensure you select the config version with the correct timestamp. Generic config build

note

In this step you also have the chance to "roll back" to an earlier deployed configuration in case the current one does not work.

In the next step of the wizard you need to select the binaries which should be deployed. Here you have the possibility to select an existing binaries ZIP. In our case we have not made any changes to the binaries, hence we don't have to upload a new version. Select the version uploaded in the last tutorial

Generic config build

As we are still not using a custom UI, we deselect No UI required and choose the one we created in the last step. Then choose correct deployment target and in the last step, review the changes and initiate creation of deployment artifacts. Wait until the creation is finished and the "check" icon appears. You can monitor the progress of the artifact creation by clicking on "lab32" or "OpenApps" buttons.

Step 4: Redeploy

Finally we can redeploy the modified prototype. Select the "Deployments" tab of the application. Add a new "deployment" with the "+" button in the lower right corner.

In the next screen please select the deployment build you just created and the environment you want to deploy the prototype to and press "Deploy". A new deployment is shown with the respective button being shown in blue, indicating "in progress".

Generic config build

After the deployment has succeeded, the color of the button will turn into green.

Step 5: Change config in AIRC portal

Now it is time to test the new configuration capabilities. For this we open the AIRC Research portal and select the configuration view. Afterwards we open the "Tutorial B" tab (if you gave your app a different name, you will find the tab to have this name).

note

At the time being you most likely need to re-enable the app after a new deployment. This is a known issue which will be fixed.

We see the form where we can configure the rotation angle. Set 25 as a value. Press "Save".

Generic config build

note

Please note that we leave the "Confirmation required" toggle unchanged, at "off". This means that the results are immediately sent back and no manual review and confirmation step is required. There is another tutorial showing how to use generic review and confirmation.

Step 6: Test effectiveness of the config change

Finally we execute the prototype and check whether the config change was effective. For this we again go to the teamplay DICOM hub and send an image. We do this in exactly the same way as in the earlier tutorial Python based prototype.

Send test image

After a few minutes it should finish computing and results should be sent back to teamplay DICOM hub. If needed you can check the progress in the AIRC Research UI. IF everything has worked nicely, the result should be visible in teamplay DICOM hub and it should be rotated by a 25 degree rotation angle.