mosamatic2 2.0.24__py3-none-any.whl

models.py

@@ -0,0 +1,259 @@
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+
+def double_conv(in_c, out_c, dropout_rate):
+    conv = nn.Sequential(
+        nn.Conv2d(in_c, out_c, kernel_size=3, padding="same"),
+        nn.PReLU(),
+        nn.BatchNorm2d(out_c),
+        nn.Dropout(dropout_rate),
+        nn.Conv2d(out_c, out_c, kernel_size=3, padding="same"),
+        nn.PReLU(),
+        nn.BatchNorm2d(out_c),
+    )
+    return conv
+
+
+class UNet(nn.Module):
+    def __init__(self, params, num_classes):
+        super(UNet, self).__init__()
+        # num_classes = params.dict['num_classes_bc']
+        dropout_rate = params.dict["dropout_rate"]
+
+        self.max_pool_2x2 = nn.MaxPool2d(kernel_size=2, stride=2)
+        self.down_conv_1 = double_conv(1, 32, dropout_rate)
+        self.down_conv_2 = double_conv(32, 64, dropout_rate)
+        self.down_conv_3 = double_conv(64, 128, dropout_rate)
+        self.down_conv_4 = double_conv(128, 256, dropout_rate)
+        self.down_conv_5 = double_conv(256, 512, dropout_rate)
+
+        self.up_trans_1 = nn.ConvTranspose2d(
+            in_channels=512, out_channels=256, kernel_size=2, stride=2
+        )
+
+        self.up_conv_1 = double_conv(512, 256, dropout_rate)
+
+        self.up_trans_2 = nn.ConvTranspose2d(
+            in_channels=256, out_channels=128, kernel_size=2, stride=2
+        )
+
+        self.up_conv_2 = double_conv(256, 128, dropout_rate)
+
+        self.up_trans_3 = nn.ConvTranspose2d(
+            in_channels=128, out_channels=64, kernel_size=2, stride=2
+        )
+
+        self.up_conv_3 = double_conv(128, 64, dropout_rate)
+
+        self.up_trans_4 = nn.ConvTranspose2d(
+            in_channels=64, out_channels=32, kernel_size=2, stride=2
+        )
+
+        self.up_conv_4 = double_conv(64, 32, dropout_rate)
+
+        self.out = nn.Conv2d(in_channels=32, out_channels=num_classes, kernel_size=1)
+
+    def forward(self, image):
+
+        x1 = self.down_conv_1(image)
+        # after each convolution apply max_pooling
+        p1 = self.max_pool_2x2(x1)
+
+        x2 = self.down_conv_2(p1)
+        p2 = self.max_pool_2x2(x2)
+
+        x3 = self.down_conv_3(p2)
+        p3 = self.max_pool_2x2(x3)
+
+        x4 = self.down_conv_4(p3)
+        p4 = self.max_pool_2x2(x4)
+
+        x5 = self.down_conv_5(p4)
+
+        # decoder
+        u6 = self.up_trans_1(x5)
+        x6 = self.up_conv_1(torch.cat([u6, x4], 1))
+
+        u7 = self.up_trans_2(x6)
+        x7 = self.up_conv_2(torch.cat([u7, x3], 1))
+
+        u8 = self.up_trans_3(x7)
+        x8 = self.up_conv_3(torch.cat([u8, x2], 1))
+
+        u9 = self.up_trans_4(x8)
+        x9 = self.up_conv_4(torch.cat([u9, x1], 1))
+
+        x = self.out(x9)
+        x = F.softmax(x, dim=1)
+        return x
+
+
+class BasicConv2d(nn.Module):
+    def __init__(self, in_channels, out_channels, dropout, **kwargs):
+        super(BasicConv2d, self).__init__()
+        self.conv = nn.Conv2d(
+            in_channels,
+            out_channels,
+            kernel_size=3,
+            stride=1,
+            padding="same",
+            bias=True,
+            **kwargs
+        )
+        # self.norm = nn.GroupNorm(32, out_channels, affine=True)
+        # self.norm = nn.InstanceNorm2d(out_channels, affine=True)
+        self.norm = nn.BatchNorm2d(out_channels)
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.norm(x)
+        x = F.relu(x, inplace=True)
+        x = self.dropout(x)
+        return x
+
+
+class AttentionGate2D(nn.Module):
+    def __init__(self, in_channels_g, in_channels_l, out_channels, **kwargs):
+        super(AttentionGate2D, self).__init__()
+        self.wg = nn.Conv2d(
+            in_channels_g, out_channels, bias=True, padding=0, kernel_size=1, stride=1
+        )
+        # self.norm_wg = nn.GroupNorm(num_groups=32, num_channels=out_channels, affine=True)
+        # self.norm_wg = nn.InstanceNorm2d(out_channels, affine=True)
+        self.norm_wg = nn.BatchNorm2d(out_channels)
+        self.wx = nn.Conv2d(
+            in_channels_l, out_channels, bias=True, padding=0, kernel_size=1, stride=1
+        )
+        # self.norm_wx = nn.GroupNorm(num_groups=32, num_channels=out_channels, affine=True)
+        # self.norm_wx = nn.InstanceNorm2d(out_channels, affine=True)
+        self.norm_wx = nn.BatchNorm2d(out_channels)
+        self.psi = nn.Conv2d(
+            in_channels=out_channels,
+            out_channels=1,
+            bias=True,
+            padding=0,
+            kernel_size=1,
+            stride=1,
+        )
+        # self.norm_psi = nn.GroupNorm(num_groups=32, num_channels=out_channels, affine=True)
+        # self.norm_psi = nn.InstanceNorm2d(out_channels, affine=True)
+        self.norm_psi = nn.BatchNorm2d(1)
+
+    def forward(self, g, x):
+        g1 = self.wg(g)
+        g1 = self.norm_wg(g1)
+        x1 = self.wx(x)
+        x1 = self.norm_wx(x1)
+        psi = F.relu(g1 + x1, inplace=True)
+        psi = self.psi(psi)
+        psi = self.norm_psi(psi)
+        psi = torch.sigmoid(psi)
+        return x * psi
+
+
+class ConvBlock2D(nn.Module):
+    def __init__(self, in_channels, out_channels, dropout, **kwargs):
+        super(ConvBlock2D, self).__init__()
+        self.conv1 = BasicConv2d(
+            in_channels=in_channels, out_channels=out_channels, dropout=dropout
+        )
+        self.conv2 = BasicConv2d(
+            in_channels=out_channels, out_channels=out_channels, dropout=dropout
+        )
+
+    def forward(self, input):
+        x1 = self.conv1(input)
+        x2 = self.conv2(x1)
+        return x2
+
+
+class AttentionUNet(nn.Module):
+    def __init__(self, params, num_classes):
+        super(AttentionUNet, self).__init__()
+        # num_classes = params.dict['num_classes_bc']
+        dropout_rate = params.dict["dropout_rate"]
+
+        self.max_pool_2x2 = nn.MaxPool2d(kernel_size=2, stride=2)
+        # self.down_conv_1 = double_conv(1, 32, dropout_rate)
+        self.down1 = ConvBlock2D(1, 32, dropout_rate)
+        # self.down_conv_2 = double_conv(32, 64, dropout_rate)
+        self.down2 = ConvBlock2D(32, 64, dropout_rate)
+        # self.down_conv_3 = double_conv(64, 128, dropout_rate)
+        self.down3 = ConvBlock2D(64, 128, dropout_rate)
+        # self.down_conv_4 = double_conv(128, 256, dropout_rate)
+        self.down4 = ConvBlock2D(128, 256, dropout_rate)
+        # self.down_conv_5 = double_conv(256, 512, dropout_rate)
+        self.down5 = ConvBlock2D(256, 512, dropout_rate)
+
+        self.up_trans_5 = nn.ConvTranspose2d(
+            in_channels=512, out_channels=256, kernel_size=2, stride=2
+        )
+
+        # self.up_conv_1 = double_conv(512, 256, dropout_rate)
+        self.up5 = ConvBlock2D(512, 256, dropout_rate)
+        self.ag5 = AttentionGate2D(256, 256, 128)
+
+        self.up_trans_4 = nn.ConvTranspose2d(
+            in_channels=256, out_channels=128, kernel_size=2, stride=2
+        )
+
+        # self.up_conv_2 = double_conv(256, 128, dropout_rate)
+        self.up4 = ConvBlock2D(256, 128, dropout_rate)
+        self.ag4 = AttentionGate2D(128, 128, 64)
+        self.up_trans_3 = nn.ConvTranspose2d(
+            in_channels=128, out_channels=64, kernel_size=2, stride=2
+        )
+
+        # self.up_conv_3 = double_conv(128, 64, dropout_rate)
+        self.up3 = ConvBlock2D(128, 64, dropout_rate)
+        self.ag3 = AttentionGate2D(64, 64, 32)
+
+        self.up_trans_2 = nn.ConvTranspose2d(
+            in_channels=64, out_channels=32, kernel_size=2, stride=2
+        )
+
+        # self.up_conv_4 = double_conv(64, 32, dropout_rate)
+        self.up2 = ConvBlock2D(64, 32, dropout_rate)
+        self.ag2 = AttentionGate2D(32, 32, 32)
+        self.out = nn.Conv2d(in_channels=32, out_channels=num_classes, kernel_size=1)
+
+    def forward(self, image):
+
+        x1 = self.down1(image)
+        # after each convolution apply max_pooling
+        p1 = self.max_pool_2x2(x1)
+
+        x2 = self.down2(p1)
+        p2 = self.max_pool_2x2(x2)
+
+        x3 = self.down3(p2)
+        p3 = self.max_pool_2x2(x3)
+
+        x4 = self.down4(p3)
+        p4 = self.max_pool_2x2(x4)
+
+        x5 = self.down5(p4)
+
+        # decoder
+        u6 = self.up_trans_5(x5)
+        s4 = self.ag5(g=u6, x=x4)
+        x6 = self.up5(torch.cat([u6, s4], 1))
+
+        u7 = self.up_trans_4(x6)
+        s3 = self.ag4(u7, x3)
+        x7 = self.up4(torch.cat([u7, s3], 1))
+
+        u8 = self.up_trans_3(x7)
+        s2 = self.ag3(u8, x2)
+        x8 = self.up3(torch.cat([u8, s2], 1))
+
+        u9 = self.up_trans_2(x8)
+        s1 = self.ag2(u9, x1)
+        x9 = self.up2(torch.cat([u9, s1], 1))
+
+        x = self.out(x9)
+        x = F.softmax(x, dim=1)
+        return x

mosamatic2/app.py

@@ -0,0 +1,32 @@
+import sys
+import traceback
+import mosamatic2.constants as constants
+from PySide6 import QtWidgets
+from mosamatic2.ui.settings import Settings
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.widgets.splashscreen import SplashScreen
+
+LOG = LogManager()
+
+
+def run_tests():
+    return 'PASSED'
+
+
+def main():
+    settings = Settings()
+    application_name = settings.get(constants.MOSAMATIC2_WINDOW_TITLE)
+    QtWidgets.QApplication.setApplicationName(application_name)
+    app = QtWidgets.QApplication(sys.argv)
+    app.setApplicationName(application_name)
+    try:
+        splash = SplashScreen()
+        splash.show()
+        sys.exit(app.exec())
+    except Exception as e:
+        LOG.error(str(e))
+        LOG.error(traceback.format_exc())
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

mosamatic2/cli.py

@@ -0,0 +1,50 @@
+import click
+from mosamatic2.commands import (
+    calculatescores,
+    calculatemaskstatistics,
+    rescaledicomimages,
+    segmentmusclefatl3tensorflow,
+    createpngsfromsegmentations,
+    dicom2nifti,
+    selectslicefromscans,
+    createdicomsummary,
+    defaultpipeline,
+    defaultdockerpipeline,
+    boadockerpipeline,
+    liveranalysispipeline,
+    totalsegmentator,
+)
+from mosamatic2.core.utils import show_doc_command
+
+
+class CustomHelpGroup(click.Group):
+    def format_commands(self, ctx, formatter):
+        commands = self.list_commands(ctx)
+        with formatter.section('Commands'):
+            for command_name in commands:
+                command = self.get_command(ctx, command_name)
+                if command is None or command.hidden:
+                    continue
+                help_text = command.get_short_help_str()
+                formatter.write_text(f'{command_name:15} {help_text}')
+
+
+@click.group(cls=CustomHelpGroup)
+def main():
+    pass
+
+
+main.add_command(calculatescores.calculatescores)
+main.add_command(calculatemaskstatistics.calculatemaskstatistics)
+main.add_command(rescaledicomimages.rescaledicomimages)
+main.add_command(segmentmusclefatl3tensorflow.segmentmusclefatl3tensorflow)
+main.add_command(createpngsfromsegmentations.createpngsfromsegmentations)
+main.add_command(dicom2nifti.dicom2nifti)
+main.add_command(selectslicefromscans.selectslicefromscans)
+main.add_command(createdicomsummary.createdicomsummary)
+main.add_command(defaultpipeline.defaultpipeline)
+main.add_command(defaultdockerpipeline.defaultdockerpipeline)
+main.add_command(boadockerpipeline.boadockerpipeline)
+main.add_command(liveranalysispipeline.liveranalysispipeline)
+main.add_command(totalsegmentator.totalsegmentator)
+main.add_command(show_doc_command(main)) # Special command to show long description for command

mosamatic2/commands/boadockerpipeline.py

@@ -0,0 +1,48 @@
+import click
+
+from mosamatic2.core.pipelines import BoaDockerPipeline
+
+
+@click.command(help='Runs 3D body composition analysis pipeline using BOA algorithm')
+@click.option(
+    '--scans', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Root directory with scan directories for each patient (no spaces allowed)',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory (no spaces allowed)'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def boadockerpipeline(scans, output, overwrite):
+    """
+    Runs 3D body composition analysis pipeline using BOA algorithm.
+    
+    Parameters
+    ----------
+    --scans : str
+        Root directory with scan directories for each patient. Each scan directory should 
+        contain DICOM images for a single scan only and nothing else. Also, the directory
+        paths cannot contain any spaces.
+
+    --output : str
+        Path to output directory. No spaces allowed.
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    pipeline = BoaDockerPipeline(
+        inputs={'scans': scans},
+        params=None,
+        output=output,
+        overwrite=overwrite,
+    )
+    pipeline.run()

mosamatic2/commands/calculatemaskstatistics.py

@@ -0,0 +1,59 @@
+import click
+
+from mosamatic2.core.tasks import CalculateMaskStatisticsTask
+
+
+@click.command(help='Calculates segmentation mask statistics')
+@click.option(
+    '--scans', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Directory with scans in NIFTI format',
+)
+@click.option(
+    '--masks',
+    required=True,
+    type=click.Path(exists=True), 
+    help='Directory with segmentation mask files in NIFTI format',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def calculatemaskstatistics(scans, masks, output, overwrite):
+    """
+    Calculates segmentation mask statistics. The following metrics are calculated:
+
+    (1) Mean radiation attenuation (HU)
+    (2) Standard deviation radiation attenuation (HU)
+    (3) Segmentation mask volume (mL)
+    
+    Parameters
+    ----------
+    --scans : str
+        Directory with scans in NIFTI format
+
+    --masks : str
+        Directory with segmentation mask files in NIFTI format
+
+    --output : str
+        Path to output directory
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CalculateMaskStatisticsTask(
+        inputs={'scans': scans, 'masks': masks},
+        params=None,
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/commands/calculatescores.py

@@ -0,0 +1,73 @@
+import click
+
+from mosamatic2.core.tasks import CalculateScoresTask
+
+
+@click.command(help='Calculates body composition scores')
+@click.option(
+    '--images', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Directory with images',
+)
+@click.option(
+    '--segmentations',
+    required=True,
+    type=click.Path(exists=True), 
+    help='Directory with segmentations',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--file_type',
+    default='npy',
+    help='Options: [npy, tag]'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def calculatescores(images, segmentations, output, file_type, overwrite):
+    """
+    Calculates the following body composition metrics from the muscle and fat 
+    images and segmentation files:
+
+    (1) Muscle area (cm^2)
+    (2) Mean muscle radiation attenuation (HU)
+    (3) Subcutaneous fat area (cm^2)
+    (4) Mean subcutaneous fat radiation attenuation (HU)
+    (5) Visceral fat area (cm^2)
+    (6) Mean visceral fat radiation attenuation (HU)
+    
+    Parameters
+    ----------
+    --images : str
+        Directory with input L3 images
+
+    --segmentations : str
+        Directory with L3 muscle and fat segmenation files. Must be output of 
+        "mosamatic2-cli segmentmusclefatl3tensorflow" OR a list of TAG files
+        corresponding to the input images
+
+    --output : str
+        Path to output directory
+
+    --file_type : str
+        Type of segmentation file to use. Can be either "npy" or "tag"
+    
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CalculateScoresTask(
+        inputs={'images': images, 'segmentations': segmentations},
+        params={'file_type': file_type},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/commands/createdicomsummary.py

@@ -0,0 +1,61 @@
+import click
+
+from mosamatic2.core.tasks import CreateDicomSummaryTask
+
+
+@click.command(help='Creates a DICOM summary inside a root directory')
+@click.option(
+    '--directory', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Root directory with DICOM images (can be multiple scans)',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def createdicomsummary(directory, output, overwrite):
+    """
+    Creates a DICOM summary inside a root directory. Each patient should have
+    its own directory. Inside each patient's directory, there can be multiple
+    scans (called series) and multiple DICOM files per scan. The output of this
+    command is a file summary.txt (stored in the output directory) that contains
+    the following information:
+
+    - A list of patient directory names with the number of scans inside each
+      patient directory
+    - For each patient directory and scan directory the following information:
+        - Nr. of DICOM images in the scan
+        - Modality (e.g., CT or MRI)
+        - Image type (e.g., for Dixon scans can be in-phase, opposite-phase, 
+          water or fat images)
+        - Rows/columns (size of the images)
+        - Pixel spacing (size of each pixel in mm^2)
+        - Slice thickness: (thickness of each image slice)
+
+    Parameters
+    ----------
+    --directory : str
+        Root directory with patient directories, scans and DICOM images
+
+    --output : str
+        Path to output directory
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CreateDicomSummaryTask(
+        inputs={'directory': directory},
+        params=None,
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/commands/createpngsfromsegmentations.py

@@ -0,0 +1,65 @@
+import click
+
+from mosamatic2.core.tasks import CreatePngsFromSegmentationsTask
+
+
+@click.command(help='Create PNG images from segmentation files')
+@click.option(
+    '--segmentations', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Input directory to segmentation files'
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory for PNG images'
+)
+@click.option(
+    '--fig_width', 
+    type=click.Path(), 
+    default=10,
+    help='Figure width (default: 10)'
+)
+@click.option(
+    '--fig_height', 
+    type=click.Path(), 
+    default=10,
+    help='Figure height (default: 10)'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def createpngsfromsegmentations(segmentations, output, fig_width, fig_height, overwrite):
+    """
+    Creates PNG images from L3 muscle and fat segmentation files
+    
+    Parameters
+    ----------
+    --segmentations : str
+        Directory with with input segmentation files. Must be L3 muscle and fat segmentations
+        (output of "mosamatic2-cli segmentmusclefatl3tensorflow")
+
+    --output : str
+        Path to output directory
+
+    --fig_width : int
+        Width of PNG image
+
+    --fig_height : int
+        Height of PNG image
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CreatePngsFromSegmentationsTask(
+        inputs={'segmentations': segmentations},
+        params={'fig_width': fig_width, 'fig_height': fig_height},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()