pylinac 0.5.0.2__zip → 0.6.0.1__zip

{pylinac-0.5.0.2 → pylinac-0.6.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pylinac
-Version: 0.5.0.2
+Version: 0.6.0.1
 Summary: A toolkit for performing TG-142 QA-related tasks on a linear accelerator
 Home-page: https://github.com/jrkerns/pylinac
 Author: James Kerns

{pylinac-0.5.0.2 → pylinac-0.6.0.1}/README.rst

@@ -1,17 +1,12 @@
 Pylinac
 =======
 
-.. image:: https://pypip.in/version/pylinac/badge.svg?style=flat
-    :target: https://pypi.python.org/pypi/pylinac/
+.. image:: https://img.shields.io/pypi/v/pylinac.svg
+    :target: https://pypi.python.org/pypi/pylinac
     :alt: Latest Version
 
-.. image:: https://pypip.in/py_versions/pylinac/badge.svg?style=flat
-    :target: https://pypi.python.org/pypi/pylinac/
-    :alt: Supported Python versions
-
-.. image:: https://pypip.in/license/pylinac/badge.svg?style=flat
-    :target: https://pypi.python.org/pypi/pylinac/
-    :alt: License
+.. image:: https://travis-ci.org/jrkerns/pylinac.svg?branch=master
+    :target: https://travis-ci.org/jrkerns/pylinac
 
 .. image:: https://coveralls.io/repos/jrkerns/pylinac/badge.svg?branch=master
     :target: https://coveralls.io/r/jrkerns/pylinac
@@ -29,8 +24,8 @@ Below are the tools currently available; tools will be added one at a time as th
     the minimum circle that touches all the radiation spokes (wobble). Based on ideas from `Depuydt et al <http://iopscience.iop.org/0031-9155/57/10/2997>`_
     and `Gonzalez et al <http://dx.doi.org/10.1118/1.1755491>`_ and evolutionary optimization.
 * `VMAT QA <http://pylinac.readthedocs.org/en/latest/vmat_docs.html>`_ -
-    A module for analyzing EPID images after performing the `Jorgensen et al. <http://dx.doi.org/10.1118/1.3552922>`_ tests for VMAT QA, specifically the Dose Rate & Gantry Speed
-    (DRGS) and Dose Rate MLC (DRMLC) tests. Can load the open and MLC field images and calculate segment ratios as per the Jorgensen implementation.
+    A module for analyzing EPID images after performing the Varian RapidArc QA tests, specifically the Dose Rate & Gantry Speed
+    (DRGS) and MLC Speed (MLCS) tests. Can load the open and MLC field images and calculate segment ratios as per the Varian specs.
 * `CBCT QA <http://pylinac.readthedocs.org/en/latest/cbct_docs.html>`_ -
     A module to automatically analyze DICOM images of a CatPhan 504 delivered on a Varian linac. Corrects for yaw, pitch, roll
     and left-right, up-down displacement. Analysis is based on test descriptions in the
@@ -50,11 +45,15 @@ Documentation
 To get started, install, run the demos, view the API docs, and learn the module design, visit the
 `Full Documentation <http://pylinac.readthedocs.org/en/latest/index.html>`_ on Read The Docs.
 
+Discussion
+----------
+Have questions? Ask them here on the `pylinac forum <https://groups.google.com/forum/#!forum/pylinac>`_.
+
 Contributing
 ------------
 
 Contributions to pylinac can be many. The most useful things a non-programmer can contribute are images to analyze and bug reports. If
-you have VMAT images, starshot images, machine log files, CBCT DICOM files, or anything else you want analyzed, email or share them via Dropbox, Google Drive, etc.
+you have VMAT images, starshot images, machine log files, CBCT DICOM files, or anything else you want analyzed, email or share them via Dropbox, Google Drive, etc: jkerns at gmail.com
 
 
 

{pylinac-0.5.0.2 → pylinac-0.6.0.1}/pylinac/__init__.py

@@ -6,12 +6,6 @@ import sys
 if sys.version_info[0] < 3:
     raise ValueError("Pylinac is only supported on Python 3.x. It seems you are using Python 2; please use a different interpreter.")
 
-try:
-    import pandas
-except ImportError:
-    import warnings
-    warnings.warn("Future versions of pylinac will use the pandas package, but it is not installed", FutureWarning)
-
 DEBUG = False
 MEMORY_PROFILE = False
 

{pylinac-0.5.0.2 → pylinac-0.6.0.1}/pylinac/cbct.py

@@ -15,6 +15,7 @@ import shutil
 import zipfile
 import time
 import math
+from io import BytesIO
 
 import numpy as np
 from scipy import ndimage
@@ -86,7 +87,7 @@ class Algo_Data:
         """Determine the roll of the phantom by calculating the angle of the two
         air bubbles on the HU slice. Delegation method."""
         # TODO: need more efficient way of doing this w/o creating HU slice
-        HU = HU_Slice(self)
+        HU = HU_Slice(self, tolerance=40)
         return HU.determine_phantom_roll()
 
     @lazyproperty
@@ -325,17 +326,17 @@ class HU_Slice(Base_HU_Slice):
     """Class for analysis of the HU slice of the CBCT dicom data set."""
     dist2objs = 120  # radius in pixels to the centers of the HU objects
     object_radius = 9  # radius of the HU ROIs themselves
-    tolerance = 40  # standard tolerance of HU
+    # tolerance = 40  # standard tolerance of HU
     air_bubble_size = 450  #
 
 
-    def __init__(self, algo_data):
+    def __init__(self, algo_data, tolerance):
         super().__init__(algo_data)
         self.scale_by_FOV()
         self.image = Image(combine_surrounding_slices(self.algo_data.images, self.algo_data.HU_slice_num))
 
         HU_ROIp = partial(HU_ROI, slice_array=self.image.array, radius=self.object_radius, dist_from_center=self.dist2objs,
-                          tolerance=self.tolerance)
+                          tolerance=tolerance)
 
         air = HU_ROIp('Air', 90, -1000)
         pmp = HU_ROIp('PMP', 120, -200)
@@ -393,18 +394,17 @@ class UNIF_Slice(Base_HU_Slice):
     """Class for analysis of the Uniformity slice of the CBCT dicom data set."""
     dist2objs = 110
     obj_radius = 20
-    tolerance = 40
 
-    def __init__(self, algo_data):
+    def __init__(self, algo_data, tolerance):
         super().__init__(algo_data)
         self.scale_by_FOV()
         self.image = Image(combine_surrounding_slices(self.algo_data.images, self.algo_data.UN_slice_num))
 
-        HU_ROIp = partial(HU_ROI, slice_array=self.image.array, tolerance=self.tolerance, radius=self.obj_radius,
+        HU_ROIp = partial(HU_ROI, slice_array=self.image.array, tolerance=tolerance, radius=self.obj_radius,
                           dist_from_center=self.dist2objs)
 
         # center has distance of 0, thus doesn't use partial
-        center = HU_ROI('Center', 0, 0, self.image.array, self.obj_radius, dist_from_center=0, tolerance=self.tolerance)
+        center = HU_ROI('Center', 0, 0, self.image.array, self.obj_radius, dist_from_center=0, tolerance=tolerance)
         right = HU_ROIp('Right', 0, 0)
         top = HU_ROIp('Top', -90, 0)
         left = HU_ROIp('Left', 180, 0)
@@ -417,6 +417,7 @@ class UNIF_Slice(Base_HU_Slice):
         self.dist2objs /= self.algo_data.fov_ratio
         self.obj_radius /= self.algo_data.fov_ratio
 
+
 class Locon_Slice(Slice):
     """Class for analysis of the low contrast slice of the CBCT dicom data set."""
     # TODO: work on this
@@ -454,7 +455,7 @@ class SR_Slice(Slice):
         self.scale_by_FOV()
         self.image = Image(combine_surrounding_slices(self.algo_data.images, self.algo_data.SR_slice_num, mode='max'))
 
-        self.LP_MTF = {}  # holds lp:mtf data
+        self.LP_MTF = OrderedDict()  # holds lp:mtf data
         for idx, radius in enumerate(self.radius2profs):
             c = SR_Circle_ROI(idx, self.image.array, radius=radius)
             self.add_ROI(c)
@@ -704,10 +705,10 @@ class GEO_Slice(Slice):
     line_nominal_value = 50
     dist2objs = 72
     obj_radius = 20
-    tolerance = 1
 
-    def __init__(self, algo_data):
+    def __init__(self, algo_data, tolerance):
         super().__init__(algo_data)
+        self.tolerance = tolerance
         self.scale_by_FOV()
         self.image = Image(combine_surrounding_slices(self.algo_data.images, self.algo_data.HU_slice_num, mode='median'))
 
@@ -819,20 +820,21 @@ class CBCT:
         demo_zip = osp.join(cbct_demo_dir, 'High quality head.zip')
         demo_folder = osp.join(cbct_demo_dir, 'High quality head')
 
+        self.load_zip_file(demo_zip)
         # unpack demo folder if not already around
-        if not osp.isdir(demo_folder) or len(os.listdir(demo_folder)) == 0:
-            shutil.unpack_archive(demo_zip, cbct_demo_dir)
-
-        filelist = self._get_CT_filenames_from_folder(demo_folder)
-        self._load_files(filelist)
-        # delete the unpacked demo folder
-        if cleanup:
-            try:
-                shutil.rmtree(demo_folder)
-                time.sleep(0.1)  # sleep timer added because fast repeats of loading/dumping caused errors
-            except IOError:
-                print("Extracted demo images were not able to be deleted. You can manually delete them if you "
-                      "like from %s" % demo_folder)
+        # if not osp.isdir(demo_folder) or len(os.listdir(demo_folder)) == 0:
+        #     shutil.unpack_archive(demo_zip, cbct_demo_dir)
+        #
+        # filelist = self._get_CT_filenames_from_folder(demo_folder)
+        # self._load_files(filelist)
+        # # delete the unpacked demo folder
+        # if cleanup:
+        #     try:
+        #         shutil.rmtree(demo_folder)
+        #         time.sleep(0.1)  # sleep timer added because fast repeats of loading/dumping caused errors
+        #     except IOError:
+        #         print("Extracted demo images were not able to be deleted. You can manually delete them if you "
+        #               "like from %s" % demo_folder)
 
     def load_folder_UI(self):
         """Load the CT DICOM files from a folder using a UI."""
@@ -873,22 +875,20 @@ class CBCT:
         FileExistsError : If zip_file passed was not a legitimate zip file.
         FileNotFoundError : If no CT images are found in the folder
         """
-        zip_folder, _ = osp.splitext(zip_file)
-
         if not zipfile.is_zipfile(zip_file):
-            raise FileExistsError("Path given was not a valid zip file")
+            raise FileExistsError("Files given were not valid zip files")
         else:
-            shutil.unpack_archive(zip_file, osp.dirname(zip_file))
-
-            filelist = self._get_CT_filenames_from_folder(zip_folder)
-            self._load_files(filelist)
+            zfs = zipfile.ZipFile(zip_file)
+            # shutil.unpack_archive(zip_file, osp.dirname(zip_file))
+            filelist = self._get_CT_filenames_from_zip(zfs)
+            self._load_files(filelist, is_zip=True, zfiles=zfs)
 
         # delete the unpacked folder
-        try:
-            shutil.rmtree(zip_folder)
-        except IOError:
-            print("Extracted demo images were not able to be deleted. You can manually delete them if you "
-                  "like from %s" % zip_folder)
+        # try:
+        #     shutil.rmtree(zip_folder)
+        # except IOError:
+        #     print("Extracted demo images were not able to be deleted. You can manually delete them if you "
+        #           "like from %s" % zip_folder)
 
     def _get_CT_filenames_from_folder(self, folder):
         """Walk through a folder to find DICOM CT images.
@@ -908,7 +908,16 @@ class CBCT:
                 return filelist
         raise FileNotFoundError("CT images were not found in the specified folder.")
 
-    def _load_files(self, file_list, im_size=512):
+    def _get_CT_filenames_from_zip(self, zfile):
+        """Get the CT image file names from a zip file."""
+        allnames = zfile.namelist()
+        filelist = [item for item in allnames if os.path.basename(item).endswith('.dcm') and os.path.basename(item).startswith('CT')]
+        if filelist:
+            return filelist
+        raise FileNotFoundError("CT images were not found in the specified folder.")
+
+
+    def _load_files(self, file_list, im_size=512, is_zip=False, zfiles=None):
         """Load CT DICOM files given a list of image paths.
 
         Parameters
@@ -931,6 +940,8 @@ class CBCT:
         # load dicom files from list names and get the image slice position
         # TODO: figure out more memory-efficient way to sort images; maybe based on number of slices and slice thickness
         for idx, item in enumerate(file_list):
+            if is_zip:
+                item = BytesIO(zfiles.read(item))
             dcm = dicom.read_file(item)
             im_order[idx] = np.round(dcm.ImagePositionPatient[-1]/dcm.SliceThickness)
             # resize image if need be
@@ -946,7 +957,7 @@ class CBCT:
         sorted_images = self._sort_images(im_order, images)
 
         # determine settings needed for given CBCT.
-        self._get_settings(file_list[0], sorted_images)
+        self._get_settings(item, sorted_images)
         # convert images from CT# to HU using dicom tags
         self._convert2HU()
 
@@ -970,6 +981,10 @@ class CBCT:
         images : numpy.ndarray
             3D numpy array of the CT images.
         """
+        try:
+            dicom_file_path.seek(0)
+        except AttributeError:
+            pass
         dcm = dicom.read_file(dicom_file_path, stop_before_pixels=True)
         self.algo_data = Algo_Data(images, dcm)
 
@@ -978,23 +993,23 @@ class CBCT:
         self.algo_data.images *= self.algo_data.dicom_metadata.RescaleSlope
         self.algo_data.images += self.algo_data.dicom_metadata.RescaleIntercept
 
-    def construct_HU(self):
+    def construct_HU(self, tolerance):
         """Construct the Houndsfield Unit Slice and its ROIs."""
-        self.HU = HU_Slice(self.algo_data)
+        self.HU = HU_Slice(self.algo_data, tolerance)
 
     def construct_SR(self):
         """Construct the Spatial Resolution Slice and its ROIs so MTF can be calculated."""
         self.SR = SR_Slice(self.algo_data)
         self.SR.calc_MTF()
 
-    def construct_GEO(self):
+    def construct_GEO(self, tolerance):
         """Construct the Geometry Slice and find the node centers."""
-        self.GEO = GEO_Slice(self.algo_data)
+        self.GEO = GEO_Slice(self.algo_data, tolerance)
         self.GEO.calc_node_centers()
 
-    def construct_UNIF(self):
+    def construct_UNIF(self, tolerance):
         """Construct the Uniformity Slice and its ROIs."""
-        self.UN = UNIF_Slice(self.algo_data)
+        self.UN = UNIF_Slice(self.algo_data, tolerance)
 
     def construct_Locon(self):
         """Construct the Low Contrast Slice."""
@@ -1041,6 +1056,65 @@ class CBCT:
         if show:
             plt.show()
 
+    def save_analyzed_image(self, filename, **kwargs):
+        """Save the analyzed plot."""
+        self.plot_analyzed_image(show=False)
+        plt.savefig(filename, **kwargs)
+
+    def plot_analyzed_subimage(self, subimage='hu', show=True):
+        """Plot a specific component of the HU analysis."""
+        subimage = subimage.lower()
+        plt.clf()
+        plt.axis('off')
+
+        if subimage == 'hu':
+            # HU objects
+            plt.imshow(self.HU.image.array, cmap=plt.cm.Greys)
+            for roi in self.HU.ROIs.values():
+                color = roi.get_pass_fail_color()
+                roi.add_to_axes(plt.gca(), edgecolor=color)
+            # GEO objects
+            for line in self.GEO.lines.values():
+                line.add_to_axes(plt.gca(), color='blue')
+            # plt.title('HU & Geometric Slice')
+            plt.autoscale(tight=True)
+        elif subimage == 'unif':
+            plt.imshow(self.UN.image.array, cmap=plt.cm.Greys)
+            for roi in self.UN.ROIs.values():
+                color = roi.get_pass_fail_color()
+                roi.add_to_axes(plt.gca(), edgecolor=color)
+            plt.autoscale(tight=True)
+            # plt.title('Uniformity Slice')
+        elif subimage == 'sr':
+            # SR objects
+            plt.imshow(self.SR.image.array, cmap=plt.cm.Greys)
+            last_roi = len(self.SR.ROIs) - 1
+            for roi in [self.SR.ROIs[0], self.SR.ROIs[last_roi]]:
+                roi.add_to_axes(plt.gca(), edgecolor='blue')
+            plt.autoscale(tight=True)
+
+            # plt.title('Spatial Resolution Slice')
+        elif subimage == 'mtf':
+            plt.axis('on')
+            x = list(self.SR.LP_MTF.keys())
+            y = list(self.SR.LP_MTF.values())
+            plt.grid('on')
+            plt.plot(x, y, marker='o')
+            plt.ylim([0, 1.1])
+            plt.xlim([0.1, 1.3])
+            plt.xlabel('Line pairs / mm')
+            plt.ylabel('Relative MTF function')
+        else:
+            raise ValueError("Subimage parameter {} not understood".format(subimage))
+
+        if show:
+            plt.show()
+
+    def save_analyzed_subimage(self, filename, subimage='hu', **kwargs):
+        """Save a component image to file."""
+        self.plot_analyzed_subimage(subimage, show=False)
+        plt.savefig(filename, **kwargs)
+
     def return_results(self):
         """Return the results of the analysis as a string."""
         #TODO: make prettier
@@ -1056,13 +1130,13 @@ class CBCT:
                                                    self.GEO.get_line_lengths(), self.GEO.overall_passed)
         return string
 
-    def analyze(self):
+    def analyze(self, hu_tolerance=40, scaling_tolerance=1):
         """Single-method full analysis of CBCT DICOM files."""
         if not self.images_loaded:
             raise AttributeError("Images not yet loaded")
-        self.construct_HU()
-        self.construct_UNIF()
-        self.construct_GEO()
+        self.construct_HU(hu_tolerance)
+        self.construct_UNIF(hu_tolerance)
+        self.construct_GEO(scaling_tolerance)
         self.construct_SR()
         self.construct_Locon()
 
@@ -1116,12 +1190,13 @@ def combine_surrounding_slices(slice_array, nominal_slice_num, slices_plusminus=
 # CBCT Demo
 # ----------------------------------------
 if __name__ == '__main__':
-    CBCT().run_demo()
+    # CBCT().run_demo()
     # zip_file = r"D:\Users\James\Dropbox\Programming\Python\Projects\PyCharm Projects\pylinac\tests\test_files\CBCT\Varian\Low dose thorax.zip"
-    # cbct = CBCT()
+    cbct = CBCT()
     # cbct.load_zip_file(zip_file)
-    # cbct.load_demo_images()
+    cbct.load_demo_images()
     # cbct.algo_data.images = np.roll(cbct.algo_data.images, 30, axis=1)
-    # cbct.analyze()
-    # print(cbct.return_results())
-    # cbct.plot_analyzed_image()
+    cbct.analyze()
+    print(cbct.return_results())
+    cbct.plot_analyzed_subimage('mtf')
+    # cbct.save_analyzed_image('ttt.png')

{pylinac-0.5.0.2 → pylinac-0.6.0.1}/pylinac/core/geometry.py

@@ -53,6 +53,8 @@ class Point:
                 value = input_coords[4]
             except IndexError:
                 pass
+        # else:
+        #     raise TypeError("Point inputs not understood")
 
         if as_int:
             x = int(round(x))
@@ -105,15 +107,12 @@ class Circle:
         radius : float, optional
             Radius of the wobble circle.
         """
-
-        if center_point is not None:
-            if is_iterable(center_point):
-                # if iterable, convert to Point because Point will convert
-                center_point = Point(center_point)
-            elif not isinstance(center_point, Point):
-                raise TypeError("Circle center must be of type Point or iterable")
-        elif center_point is None:
+        if center_point is None:
             center_point = Point()
+        elif isinstance(center_point, Point) or is_iterable(center_point):
+            center_point = Point(center_point)
+        else:
+            raise TypeError("Circle center must be of type Point or iterable")
 
         self.center = center_point
         self.radius = radius

{pylinac-0.5.0.2 → pylinac-0.6.0.1}/pylinac/core/image.py

@@ -11,7 +11,7 @@ from scipy.misc import imresize
 
 from pylinac.core.decorators import type_accept
 from pylinac.core.geometry import Point
-from pylinac.core.io import get_filepath_UI
+from pylinac.core.io import get_filepath_UI, get_filenames_UI
 from pylinac.core.utilities import array2logical, typed_property
 
 
@@ -39,7 +39,8 @@ class Image:
     dpi : int, float
         The Dots-per-inch of the image.
     dpmm : int, float
-        The Dots-per-mm of the image.
+        The Dots-per-mm of the image, defined at isocenter. E.g. if an EPID image is taken at 150cm SID,
+        the dpmm will scale back to 100cm.
     SID : int, float
         The Source-to-Image distance in cm.
     im_type : {'DICOM', 'Image', 'Array'}
@@ -78,12 +79,16 @@ class Image:
             If True (default), will convert RGB and HSV type images to greyscale.
             If False, will not do any conversion.
         """
-        if isinstance(file_or_array, str):
+        try:
             self._load_file(file_or_array, to_gray)
-        elif isinstance(file_or_array, np.ndarray):
-            self._load_array(file_or_array)
-        else:
+        except (IOError, AttributeError):
+            try:
+                self._load_array(file_or_array)
+            except:
+                raise TypeError("Image input type not understood")
+        except:
             raise TypeError("Image input type not understood")
+
     # @property
     # def array(self):
     #     return self._array
@@ -148,6 +153,20 @@ class Image:
             obj = cls(file_path, to_gray)
             return obj
 
+    @classmethod
+    def open_multiple_UI(cls, caption='', to_gray=True):
+        """Load multiple images using a UI dialog.
+
+        .. versionadded:: 0.5.1
+
+        All files must be images, and must be the same size and shape.
+        Image metadata, e.g. DPI, is all based on the first image selected.
+        """
+        file_list = get_filenames_UI()
+        if file_list:
+            obj = cls.combine_multiples(file_list)
+            return obj
+
     def _load_array(self, array):
         """Load an array."""
         self.array = array
@@ -165,6 +184,10 @@ class Image:
 
     def _construct_image(self, file_path, to_gray):
         """Construct an object from an image file (TIF, JPEG, etc)."""
+        try:
+            file_path.seek(0)
+        except AttributeError:
+            pass
         img = pImage.open(file_path)
         if to_gray:
             if img.mode == 'RGB' or img.mode == 'HSV':
@@ -176,16 +199,20 @@ class Image:
         if 'dpi' in img.info:
             if len(img.info['dpi']) > 1:
                 if img.info['dpi'][0] != img.info['dpi'][1]:
-                    raise TypeError("Input image has different DPI ratios for horizontal and vertical")
+                    raise TypeError("Input image has different DPI values for horizontal and vertical")
                 self.dpi = img.info['dpi'][0]
             else:
                 self.dpi = img.info['dpi']
         else:
-            warnings.warn("Pixel distance information was not available. You can set the attributed"
+            warnings.warn("Pixel distance information was not available. You can set the attribute"
                           "explicitly if you know it.")
 
     def _construct_dicom(self, file_path):
         """Construct an object from a DICOM file (.dcm)."""
+        try:
+            file_path.seek(0)
+        except AttributeError:
+            pass
         dcm = dicom.read_file(file_path)
         self.array = dcm.pixel_array
         self.im_type = DICOM
@@ -301,7 +328,32 @@ class Image:
         self.array -= min_val
         return min_val
 
+    @classmethod
+    def combine_multiples(cls, image_file_list):
+        """Combine multiple image files into one superimposed image.
+
+        .. versionadded:: 0.5.1
+        """
+        # open first one to get initial settings
+        init_obj = cls(image_file_list[0])
+        concat_arr = init_obj.array
+        initial_shape = init_obj.shape
+        for img_file in image_file_list[1:]:
+            obj = cls(img_file)
+            if obj.shape != initial_shape:
+                 raise AttributeError("Images must be the same size when combining.")
+            concat_arr = np.dstack((concat_arr, obj.array))
+
+        # create new mean array
+        combined_arr = np.mean(concat_arr, axis=2)
+        # use the initial Image object and replace its array (thus keeping all the other properties)
+        init_obj.array = combined_arr
+        return init_obj
+
     def __getattr__(self, item):
         """Set the Attribute getter to grab from the array if possible (for things like .shape, .size, etc)."""
         return getattr(self.array, item)
 
+if __name__ == '__main__':
+    img = Image.open_multiple_UI()
+