pumpia-uniform-phantom 0.0.1__tar.gz

pumpia_uniform_phantom-0.0.1/.gitignore

@@ -0,0 +1,118 @@
+# Editor temporary/working/backup files #
+#########################################
+.#*
+[#]*#
+*~
+*$
+*.bak
+*.diff
+.idea/
+*.iml
+*.ipr
+*.iws
+*.org
+.project
+pmip
+*.rej
+.settings/
+.*.sw[nop]
+.sw[nop]
+*.tmp
+*.vim
+.vscode
+tags
+cscope.out
+# gnu global
+GPATH
+GRTAGS
+GSYMS
+GTAGS
+.cache
+.mypy_cache/
+
+# Compiled source #
+###################
+*.a
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.o.d
+*.py[ocd]
+*.so
+*.mod
+*.dist
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.bz2
+*.bzip2
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.tbz2
+*.tgz
+*.zip
+
+# Python files #
+################
+# meson build/installation directories
+build
+build-install
+# meson python output
+.mesonpy-native-file.ini
+# sphinx build directory
+_build
+# dist directory is where sdist/wheel end up
+dist
+doc/build
+doc/docenv
+doc/cdoc/build
+# Egg metadata
+*.egg-info
+# The shelf plugin uses this dir
+./.shelf
+.cache
+pip-wheel-metadata
+.python-version
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+*nuitka-crash-report.xml
+
+# Patches #
+###########
+*.patch
+*.diff
+
+# OS generated files #
+######################
+.DS_Store*
+.VolumeIcon.icns
+.fseventsd
+Icon?
+.gdb_history
+ehthumbs.db
+Thumbs.db
+.directory
+
+# pytest generated files #
+##########################
+/.pytest_cache
+
+# doc build generated files #
+#############################
+doc/source/savefig/
+doc/source/**/generated/
+doc/source/release/notes-towncrier.rst
+doc/source/.jupyterlite.doit.db

pumpia_uniform_phantom-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Principle Five
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pumpia_uniform_phantom-0.0.1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: pumpia-uniform-phantom
+Version: 0.0.1
+Summary: Uniform MRI phantom analysis based using the PumpIA framework.
+Project-URL: Homepage, https://www.principlefive.org.uk/
+Project-URL: Documentation, https://github.com/Principle-Five/pumpia-uniform-phantom
+Project-URL: Source, https://github.com/Principle-Five/pumpia-uniform-phantom
+Project-URL: Issues, https://github.com/Principle-Five/pumpia-uniform-phantom/issues
+Author: Zack Ravetz et al.
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Software Development
+Requires-Python: >=3.12
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pumpia==0.6.*,>=0.6.7
+Requires-Dist: pylibjpeg[all]
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# Introduction
+This repository contains code to analyse a uniform phantom using the [PumpIA](https://github.com/Principle-Five/pumpia) framework.
+It uses the subtraction SNR method and therefore expects a repeat image, however the uniformity module will run with a single image.
+
+It is currently not validated and is provided as is, see the license for more information.
+
+The collection contains the following tests:
+- SNR
+- Uniformity
+
+# Usage
+
+Users should make themselves familiar with the [PumpIA user interface](https://principle-five.github.io/pumpia/usage/user_interface.html)
+
+To run the collection:
+1. Clone the repository
+2. Use an environment manager to install the requirements from `requirements.txt` or install the requirements using the command `pip install -r requirements.txt` when in the repository directory
+3. Run the `run_uniform_rpt_collection.py` script
+
+To use the collection:
+1. Load the folder with the relevant images
+2. Drag and drop the series containing the relevant images into the viewer of the `Main` tab
+3. Generate the ROIs and run analysis
+4. Correct the context if required (see below)
+    - Re-run generating ROIs
+5. Move any ROIs as required, this should be done through their relevant modules.
+    - Re-run analysis
+6. Copy the results in the relevant format. Horizontal is tab separated, vertical is new line separated.
+
+## Correcting Context
+
+The context used for this collection is the Auto Phantom Context Manager provided with PumpIA, see the [relevant documentation](https://principle-five.github.io/pumpia/usage/user_interface.html) for this.

pumpia_uniform_phantom-0.0.1/README.md

@@ -0,0 +1,32 @@
+# Introduction
+This repository contains code to analyse a uniform phantom using the [PumpIA](https://github.com/Principle-Five/pumpia) framework.
+It uses the subtraction SNR method and therefore expects a repeat image, however the uniformity module will run with a single image.
+
+It is currently not validated and is provided as is, see the license for more information.
+
+The collection contains the following tests:
+- SNR
+- Uniformity
+
+# Usage
+
+Users should make themselves familiar with the [PumpIA user interface](https://principle-five.github.io/pumpia/usage/user_interface.html)
+
+To run the collection:
+1. Clone the repository
+2. Use an environment manager to install the requirements from `requirements.txt` or install the requirements using the command `pip install -r requirements.txt` when in the repository directory
+3. Run the `run_uniform_rpt_collection.py` script
+
+To use the collection:
+1. Load the folder with the relevant images
+2. Drag and drop the series containing the relevant images into the viewer of the `Main` tab
+3. Generate the ROIs and run analysis
+4. Correct the context if required (see below)
+    - Re-run generating ROIs
+5. Move any ROIs as required, this should be done through their relevant modules.
+    - Re-run analysis
+6. Copy the results in the relevant format. Horizontal is tab separated, vertical is new line separated.
+
+## Correcting Context
+
+The context used for this collection is the Auto Phantom Context Manager provided with PumpIA, see the [relevant documentation](https://principle-five.github.io/pumpia/usage/user_interface.html) for this.

pumpia_uniform_phantom-0.0.1/pumpia_uniform_phantom/modules/sub_snr.py

@@ -0,0 +1,192 @@
+"""
+Subtraction SNR module for uniform phantom
+"""
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+
+from pumpia.module_handling.modules import PhantomModule
+from pumpia.module_handling.fields.roi_fields import GeneralROIField
+from pumpia.module_handling.fields.viewer_fields import MonochromeDicomViewerField
+from pumpia.module_handling.fields.simple import (PercField,
+                                                  FloatField,
+                                                  BoolField)
+from pumpia.image_handling.roi_structures import EllipseROI, RectangleROI
+from pumpia.file_handling.dicom_structures import Series, Instance
+from pumpia.file_handling.dicom_tags import MRTags
+from pumpia.module_handling.context import PhantomContext
+from pumpia.widgets.context_managers import AutoPhantomManager
+
+
+class SubSNR(PhantomModule):
+    """
+    Module for subtraction method SNR on uniform phantom.
+    """
+    context_manager = AutoPhantomManager()
+    show_draw_rois_button = True
+    show_analyse_button = True
+    title = "Subtraction SNR"
+
+    viewer1 = MonochromeDicomViewerField(row=0, column=0)
+    viewer2 = MonochromeDicomViewerField(row=0, column=1, allow_changing_rois=False)
+
+    size = PercField(70, verbose_name="Size (%)")
+    ref_bandwidth = FloatField(1, verbose_name="Reference Bandwidth (Hz/px)")
+    bw_cor_bool = BoolField(verbose_name="Bandwidth Correction")
+    pix_size_bool = BoolField(verbose_name="Pixel Size Correction")
+    avg_cor_bool = BoolField(verbose_name="Averages Correction")
+    pe_cor_bool = BoolField(verbose_name="Phase Encode Correction")
+
+    im_bw = FloatField(verbose_name="Image Bandwidth (Hz/px)", read_only=True)
+    pixel_size_cor = FloatField(verbose_name="Pixel Size Correction", read_only=True)
+    pe_cor = FloatField(verbose_name="Phase Encode Correction", read_only=True)
+    avg_cor = FloatField(verbose_name="Averages Correction", read_only=True)
+    signal = FloatField(read_only=True)
+    noise = FloatField(read_only=True)
+    snr = FloatField(verbose_name="SNR", read_only=True)
+    cor_snr = FloatField(verbose_name="Corrected SNR", read_only=True)
+
+    signal_roi1 = GeneralROIField("SNR ROI1", default_type="ROI rectangle")
+    signal_roi2 = GeneralROIField("SNR ROI2", allow_manual_draw=False)
+
+    def draw_rois(self, context: PhantomContext, batch: bool = False) -> None:
+        if isinstance(self.viewer1.image, (Instance, Series)):
+            factor = self.size / 100
+            if context.shape == "rectangle":
+                xmin = round(context.xcent - (factor * context.x_length / 2))
+                xmax = round(context.xcent + (factor * context.x_length / 2))
+                ymin = round(context.ycent - (factor * context.y_length / 2))
+                ymax = round(context.ycent + (factor * context.y_length / 2))
+                self.signal_roi1.register_roi(RectangleROI(self.viewer1.image,
+                                                           xmin,
+                                                           ymin,
+                                                           xmax - xmin,
+                                                           ymax - ymin,
+                                                           slice_num=self.viewer1.current_slice))
+            else:
+                a = round(factor * context.x_length / 2)
+                b = round(factor * context.y_length / 2)
+                self.signal_roi1.register_roi(EllipseROI(self.viewer1.image,
+                                                         round(context.xcent),
+                                                         round(context.ycent),
+                                                         a,
+                                                         b,
+                                                         slice_num=self.viewer1.current_slice))
+
+    def post_roi_register(self, roi_input: GeneralROIField):
+        if (roi_input == self.signal_roi1
+                and self.signal_roi1.roi is not None):
+            if self.manager is not None:
+                self.manager.add_roi(self.signal_roi1.roi)
+
+            if isinstance(self.viewer2.image, (Instance, Series)):
+                image = self.viewer2.image
+                roi = self.signal_roi1.roi.copy_to_image(image,
+                                                         image.current_slice,
+                                                         "SNR ROI",
+                                                         True)
+                self.signal_roi2.register_roi(roi)
+                if (self.signal_roi2.roi is not None
+                        and self.manager is not None):
+                    self.manager.add_roi(self.signal_roi2.roi)
+
+    def link_rois_viewers(self):
+        self.signal_roi1.viewer = self.viewer1
+        self.signal_roi2.viewer = self.viewer2
+
+    def analyse(self, batch: bool = False):
+        if self.signal_roi1.roi is not None and self.signal_roi2.roi is not None:
+            roi1 = self.signal_roi1.roi
+            roi2 = self.signal_roi2.roi
+            roi_sum = roi1.pixel_values + roi2.pixel_values
+            roi_sub = np.array(roi1.pixel_values) - np.array(roi2.pixel_values)
+            sum_roi = np.mean(roi_sum)
+            if isinstance(sum_roi, float):
+                self.signal = sum_roi
+            roi_noise = np.std(roi_sub) / math.sqrt(2)
+            if isinstance(roi_noise, float):
+                self.noise = roi_noise
+            snr = sum_roi / roi_noise
+            if isinstance(snr, float):
+                self.snr = snr
+
+            cor_snr = snr
+
+            image = roi1.image
+            if isinstance(image, Instance):
+                px_cor = 1
+                bw_cor = 1
+                avg_cor = 1
+                pe_cor = 1
+
+                if (self.pix_size_bool
+                    and not (image.slice_thickness is None
+                             or image.pixel_spacing is None)):
+                    pix_size = image.slice_thickness, *image.pixel_spacing
+                    self.logger.info("pixel size = %s", pix_size)
+                    px_cor = 1 / math.prod(pix_size)
+                    self.pixel_size_cor = px_cor
+
+                if self.bw_cor_bool:
+                    ref_bw = self.ref_bandwidth
+                    try:
+                        im_bw = image.get_tag(MRTags.PixelBandwidth)
+                        try:
+                            im_bw = float(im_bw)  # type: ignore
+                        except (ValueError, TypeError):
+                            im_bw = ref_bw
+                    except KeyError:
+                        im_bw = ref_bw
+                    self.im_bw = im_bw
+                    bw_cor = math.sqrt(im_bw / ref_bw)
+
+                if self.avg_cor_bool:
+                    try:
+                        im_av = image.get_tag(MRTags.NumberOfAverages)
+                        try:
+                            im_av = float(im_av)  # type: ignore
+                        except (ValueError, TypeError):
+                            im_av = 1
+                    except KeyError:
+                        im_av = 1
+                    avg_cor = 1 / math.sqrt(im_av)
+                    self.avg_cor = avg_cor
+
+                if self.pe_cor_bool:
+                    try:
+                        im_pe = float(
+                            image.get_tag(MRTags.NumberOfPhaseEncodingSteps))  # type: ignore
+                    except (KeyError, ValueError, TypeError):
+                        im_pe = 1
+
+                    if im_pe == 1:
+                        try:
+                            if image.get_tag(MRTags.InPlanePhaseEncodingDirection) == "ROW":
+                                num = int(
+                                    image.get_tag(MRTags.Rows))  # type: ignore
+                            else:
+                                num = int(
+                                    image.get_tag(MRTags.Columns))  # type: ignore
+                            im_pe = float(
+                                image.get_tag(MRTags.PercentSampling)) * num  # type: ignore
+                        except (KeyError, ValueError, TypeError):
+                            im_pe = 1
+
+                    pe_cor = 1 / math.sqrt(im_pe)
+                    self.pe_cor = pe_cor
+
+                cor_snr = snr * px_cor * bw_cor * avg_cor * pe_cor
+
+            self.cor_snr = float(cor_snr)
+
+    def load_commands(self):
+        self.register_command("Show Subtraction Image", self.show_sub_image)
+
+    def show_sub_image(self):
+        if self.signal_roi1.roi is not None and self.signal_roi2.roi is not None:
+            roi1 = self.signal_roi1.roi
+            roi2 = self.signal_roi2.roi
+            sub_array = roi1.image.array[0] - roi2.image.array[0]
+            plt.imshow(sub_array, cmap='grey')
+            plt.colorbar()
+            plt.show()

pumpia_uniform_phantom-0.0.1/pumpia_uniform_phantom/modules/uniformity.py

@@ -0,0 +1,86 @@
+"""
+Integral uniformity module for uniform phantom
+"""
+import numpy as np
+from scipy.signal import convolve2d
+
+from pumpia.module_handling.modules import PhantomModule
+from pumpia.module_handling.fields.roi_fields import GeneralROIField
+from pumpia.module_handling.fields.viewer_fields import MonochromeDicomViewerField
+from pumpia.module_handling.fields.simple import (PercField,
+                                                  BoolField,
+                                                  FloatField)
+from pumpia.image_handling.roi_structures import EllipseROI, RectangleROI
+from pumpia.file_handling.dicom_structures import Series, Instance
+from pumpia.module_handling.context import PhantomContext
+from pumpia.widgets.context_managers import AutoPhantomManager
+
+LOW_PASS_KERNEL = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) / 16
+
+
+class Uniformity(PhantomModule):
+    """
+    Integral uniformity module for uniform phantom.
+    """
+    context_manager = AutoPhantomManager()
+    show_draw_rois_button = True
+    show_analyse_button = True
+    title = "Uniformity"
+
+    viewer = MonochromeDicomViewerField(row=0, column=0)
+
+    size = PercField(70, verbose_name="Size (%)")
+    kernel_bool = BoolField(verbose_name="Apply Low Pass Kernel")
+
+    uniformity = FloatField(verbose_name="Uniformity (%)", read_only=True)
+
+    uniformity_roi = GeneralROIField("Uniformity ROI", default_type="ROI rectangle")
+
+    def draw_rois(self, context: PhantomContext, batch: bool = False) -> None:
+        if isinstance(self.viewer.image, (Instance, Series)):
+            factor = self.size / 100
+            if context.shape == "rectangle":
+                xmin = round(context.xcent - (factor * context.x_length / 2))
+                xmax = round(context.xcent + (factor * context.x_length / 2))
+                ymin = round(context.ycent - (factor * context.y_length / 2))
+                ymax = round(context.ycent + (factor * context.y_length / 2))
+                self.uniformity_roi.register_roi(RectangleROI(self.viewer.image,
+                                                              xmin,
+                                                              ymin,
+                                                              xmax - xmin,
+                                                              ymax - ymin,
+                                                              slice_num=self.viewer.current_slice))
+            else:
+                a = round(factor * context.x_length / 2)
+                b = round(factor * context.y_length / 2)
+                self.uniformity_roi.register_roi(EllipseROI(self.viewer.image,
+                                                            round(context.xcent),
+                                                            round(context.ycent),
+                                                            a,
+                                                            b,
+                                                            slice_num=self.viewer.current_slice))
+
+    def post_roi_register(self, roi_input: GeneralROIField):
+        if (roi_input == self.uniformity_roi
+            and self.uniformity_roi.roi is not None
+                and self.manager is not None):
+            self.manager.add_roi(self.uniformity_roi.roi)
+
+    def link_rois_viewers(self):
+        self.uniformity_roi.viewer = self.viewer
+
+    def analyse(self, batch: bool = False):
+        if self.uniformity_roi.roi is not None:
+            roi = self.uniformity_roi.roi
+            if self.kernel_bool:
+                array = roi.image.array[0]
+                array = convolve2d(array, LOW_PASS_KERNEL, mode="same")
+                mask = roi.mask
+                pixel_values = list(array[mask])
+            else:
+                pixel_values = roi.pixel_values
+
+            max_val = max(pixel_values)
+            min_val = min(pixel_values)
+            uniformity = 100 * (1 - ((max_val - min_val) / (max_val + min_val)))  # type: ignore
+            self.uniformity = uniformity

pumpia_uniform_phantom-0.0.1/pumpia_uniform_phantom/repeat/collection.py

@@ -0,0 +1,66 @@
+"""
+Collection for uniform phantom with repeat images.
+"""
+
+from pumpia.module_handling.collections import ModuleGroup, BaseCollection
+from pumpia.module_handling.fields.windows import FieldWindow
+from pumpia.module_handling.fields.groups import FieldGroup
+from pumpia.module_handling.fields.viewer_fields import MonochromeDicomViewerField
+from pumpia.widgets.viewers import MonochromeDicomViewer
+from pumpia.widgets.context_managers import AutoPhantomManager
+
+from pumpia_uniform_phantom.modules.sub_snr import SubSNR
+from pumpia_uniform_phantom.modules.uniformity import Uniformity
+
+
+class RepeatImagesCollection(BaseCollection):
+    """
+    Collection for uniform phantom with repeated scans.
+    """
+    context_manager = AutoPhantomManager()
+    title = "Uniform Phantom Repeat Collection"
+
+    viewer1 = MonochromeDicomViewerField(row=0, column=0)
+    viewer2 = MonochromeDicomViewerField(row=0, column=1)
+
+    snr = SubSNR(verbose_name="SNR")
+
+    uniformity1 = Uniformity(verbose_name="Uniformity")
+    uniformity2 = Uniformity(verbose_name="Uniformity")
+
+    snr_output = FieldWindow(snr.fields.signal,
+                             snr.fields.noise,
+                             snr.fields.snr,
+                             snr.fields.cor_snr,
+                             verbose_name="SNR Output")
+    image1_output = FieldWindow(uniformity1.fields.uniformity, verbose_name="Image 1 Results")
+    image2_output = FieldWindow(uniformity2.fields.uniformity, verbose_name="Image 2 Results")
+    full_results = FieldWindow(snr.fields.signal,
+                               snr.fields.noise,
+                               snr.fields.snr,
+                               snr.fields.cor_snr,
+                               uniformity1.fields.uniformity,
+                               uniformity2.fields.uniformity,
+                               field_names=[None,
+                                            None,
+                                            None,
+                                            None,
+                                            "Image 1 Uniformity",
+                                            "Image 2 Uniformity"])
+
+    size_group = FieldGroup(uniformity1.fields.size, uniformity2.fields.size)
+    kernel_group = FieldGroup(uniformity1.fields.kernel_bool, uniformity2.fields.kernel_bool)
+
+    uniformity_window = ModuleGroup(uniformity1, uniformity2, verbose_name="Uniformity")
+
+    def on_image_load(self, viewer: MonochromeDicomViewer) -> None:
+        if viewer is self.viewer1:
+            if self.viewer1.image is not None:
+                image = self.viewer1.image
+                self.snr.viewer1.load_image(image)
+                self.uniformity1.viewer.load_image(image)
+        elif viewer is self.viewer2:
+            if self.viewer2.image is not None:
+                image = self.viewer2.image
+                self.snr.viewer2.load_image(image)
+                self.uniformity2.viewer.load_image(image)

pumpia_uniform_phantom-0.0.1/pumpia_uniform_phantom/scripts/run_uniform_rpt.py

@@ -0,0 +1,9 @@
+from pumpia_uniform_phantom.repeat.collection import RepeatImagesCollection
+
+
+def run_repeat_uniform():
+    RepeatImagesCollection.run()
+
+
+if __name__ == "__main__":
+    run_repeat_uniform()

pumpia_uniform_phantom-0.0.1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pumpia-uniform-phantom"
+version = "0.0.1"
+authors = [{ name = "Zack Ravetz et al." }]
+description = "Uniform MRI phantom analysis based using the PumpIA framework."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pumpia == 0.6.*, >=0.6.7",
+    "scipy",
+    "numpy",
+    "pylibjpeg[all]",
+    "matplotlib",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3.14',
+    "Intended Audience :: Science/Research",
+    'License :: OSI Approved :: BSD License',
+    'Topic :: Software Development',
+    'Topic :: Scientific/Engineering',
+    'Topic :: Scientific/Engineering :: Image Processing',
+]
+
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+
+[project.urls]
+Homepage = "https://www.principlefive.org.uk/"
+Documentation = "https://github.com/Principle-Five/pumpia-uniform-phantom"
+Source = "https://github.com/Principle-Five/pumpia-uniform-phantom"
+Issues = "https://github.com/Principle-Five/pumpia-uniform-phantom/issues"
+
+[tool.hatch.build.targets.sdist]
+include = ["pumpia_uniform_phantom*"]
+
+[project.gui-scripts]
+pumpia-uniform-phantom = "pumpia_uniform_phantom.scripts.run_uniform_rpt:run_repeat_uniform"