Beispiel #1
0
    def arfi_lesions(self):
        """
        characterize all ARFI lesions and define ARFI index lesion
        """
        if self.arfi.values()[0] != 'no lesions read':
            try:
                from prostate27 import Prostate27
                p = Prostate27()

                index = {}
                for lesion in self.arfi['lesions']:
                    if lesion['index'] is True:
                        index['IOS'] = lesion['IOS']
                        index['region'] = lesion['region']
                        index['location'] = \
                            p.anterior_posterior([lesion['region']])
                        index['zone'] = p.zone(lesion['region'])
                        self.arfi['index'] = index
                        break
            except ValueError:
                self.arfi['index'] = None

            # specify location and zone for each lesion
            for n, lesion in enumerate(self.arfi['lesions']):
                self.arfi['lesions'][n].update({
                    'location':
                    p.anterior_posterior([lesion['region']]),
                    'zone':
                    p.zone(lesion['region'])
                })
Beispiel #2
0
    def check_hist_clin_sig_sensitivity(self):
        """
        check if ARFI detected clinically-significant lesions
        """
        from prostate27 import Prostate27
        p = Prostate27()

        self.clin_sig_sensitivity = []
        try:
            for lesion in self.histology['pca']:
                if lesion['Clinically Significant']:
                    nnset = p.nearest_neighbors([lesion['region']])
                    for arfi in self.arfi['lesions']:
                        lesion_region = arfi['region']
                        if ('index' not in lesion_region) and \
                           ('read' not in lesion_region):
                            if lesion_region in nnset:
                                self.clin_sig_sensitivity.append([
                                    True,
                                    p.anterior_posterior([lesion['region']])
                                ])
                            else:
                                self.clin_sig_sensitivity.append([
                                    False,
                                    p.anterior_posterior([lesion['region']])
                                ])
        except KeyError:
            self.clin_sig_sensitivity = None
Beispiel #3
0
    def check_benign_match(self):
        """
        check if atrophy or bph is present in the exact or nearest neighbor
        region to an ARFI lesion
        """
        from prostate27 import Prostate27
        p = Prostate27()

        self.benign_match = {}
        for benign in ['atrophy', 'bph']:
            try:
                if self.histology['index'] is None:
                    self.benign_match[benign] = False
                else:
                    benign_regions = self.histology[benign]['regions']
                    arfi_regions_nn = p.nearest_neighbors(
                        [x['region'] for x in self.arfi['lesions']])
                    if (any([x in benign_regions for x in arfi_regions_nn])) \
                        and (self.histology['index']['region'] not in
                             benign_regions):
                        self.benign_match[benign] = True
                    else:
                        self.benign_match[benign] = False
            except KeyError:
                self.benign_match[benign] = False
Beispiel #4
0
    def mri_lesions(self):
        """
        characterize all MRI lesions and define MRI index lesion
        """
        if self.mri.values()[0] != 'no lesions read':
            try:
                from prostate27 import Prostate27
                p = Prostate27()

                index = {}
                for lesion in self.mri['lesions']:
                    if lesion['index'] is True:
                        index['IOS'] = lesion['IOS']
                        index['region'] = lesion['region']
                        index['location'] = p.anterior_posterior(
                            [lesion['region']])
                        index['zone'] = p.zone(lesion['region'])
                        index['Gleason'] = lesion['Gleason']
                        index['diameter_mm'] = lesion['diameter_mm']
                        index['ECE'] = lesion['extracap']
                        index['lesion_number'] = lesion['lesion_number']
                        self.mri['index'] = index
                        break
            except ValueError:
                self.mri['index'] = None

            for n, lesion in enumerate(self.mri['lesions']):
                self.mri['lesions'][n].update({
                    'location':
                    p.anterior_posterior([lesion['region']]),
                    'zone':
                    p.zone(lesion['region'])
                })
Beispiel #5
0
 def test_location(self):
     """
     indices corresponding to region
     """
     p = Prostate27()
     self.assertTrue(p.location(['12a']) == (2, 1, 3))
     self.assertTrue(p.location(['1a']) == (0, 1, 1))
     self.assertTrue(p.location(['5a']) == (2, 1, 1))
Beispiel #6
0
 def test_anterior_posterior(self):
     """
     anterior / posterior assignment
     """
     p = Prostate27()
     self.assertTrue(p.anterior_posterior(['14as']) == 'anterior')
     self.assertTrue(p.anterior_posterior(['1p']) == 'posterior')
     self.assertTrue(p.anterior_posterior(['5a']) == 'anterior')
Beispiel #7
0
 def test_nn_ranges(self):
     """
     27 region index bounds not exceeded; AS regions pull all mid-gland
     """
     p = Prostate27()
     self.assertTrue(p.nn_ranges((1, 2, 3)) == [[0, 1, 2], [1, 2], [2, 3]])
     self.assertTrue(
         p.nn_ranges((0, 0, 0)) == [[0, 1], [0, 1], [0, 1, 2, 3]])
Beispiel #8
0
 def test_zone(self):
     """
     peripheral zone / central gland assignment
     """
     p = Prostate27()
     self.assertTrue(p.zone('9a') == 'central gland')
     self.assertTrue(p.zone('11a') == 'central gland')
     self.assertTrue(p.zone('4a') == 'peripheral zone')
     self.assertTrue(p.zone('14as') == 'peripheral zone')
Beispiel #9
0
    def histology_lesions(self):
        """
        characterize all histology lesions in dict, including index, nearest
        neighbors, clinical significance, location and zone
        """
        from prostate27 import Prostate27
        p = Prostate27()

        try:
            index = {}
            for lesion in self.histology['pca']:
                if lesion['index'] is True:
                    index['region'] = lesion['region']
                    index['Gleason'] = lesion['Gleason']
                    index['volume'] = lesion['volume_cc']
                    index['nn'] = p.nearest_neighbors([lesion['region']])
                    index['location'] = p.anterior_posterior(
                        [lesion['region']])
                    index['Staging'] = lesion['Staging']
                    index['ECE_extent'] = lesion['ECE_extent']
                    index['zone'] = p.zone(lesion['region'])
                    self.histology['index'] = index
                    break

            for n, les in enumerate(self.histology['pca']):
                if self.clin_sig(les['volume_cc'], les['Gleason']):
                    self.histology['pca'][n].update(
                        {'Clinically Significant': True})
                else:
                    self.histology['pca'][n].update(
                        {'Clinically Significant': False})
                    self.histology['pca'][n].update(
                        {'location': p.anterior_posterior([les['region']])})
                    self.histology['pca'][n].update(
                        {'zone': p.zone(les['region'])})

        except ValueError:
            print "No PCA lesion"
            self.histology['index'] = None

        if 'index' in self.histology:
            pass
        else:
            print "No Histology Index Lesion, P%i" % self.pnum
            self.histology['index'] = None
Beispiel #10
0
    def check_clin_sig_match(self):
        """
        check if ARFI reads are clinically-significant lesions
        """
        from prostate27 import Prostate27
        p = Prostate27()

        hist_nnset = set()
        histnonsigset = set()
        self.clin_sig_match = []

        # find histology nearest neighbors for all clinically sig lesions
        for i in self.histology['pca']:
            if i['Clinically Significant']:
                hist_nnset.update(p.nearest_neighbors([i['region']]))
            else:
                histnonsigset.update(p.nearest_neighbors([i['region']]))

        self.false_positive = []
        try:
            for lesion in self.arfi['lesions']:
                lesion_region = lesion['region']
                if lesion_region in hist_nnset:
                    self.clin_sig_match.append(
                        [True, lesion['location'], lesion['IOS']])
                else:
                    self.clin_sig_match.append(
                        [False, lesion['location'], lesion['IOS']])
                    # check if something else exists in this region, including:
                    # non-clinically significant PCA, atrophy, BPH
                    if lesion_region in histnonsigset:
                        self.false_positive.append('pca')
                    elif self.histology['atrophy']:
                        if lesion_region in self.histology['atrophy'][
                                'regions']:
                            self.false_positive.append('atrophy')
                    elif self.histology['bph']:
                        if lesion_region in self.histology['bph']['regions']:
                            self.false_positive.append('bph')
                    else:
                        self.false_positive.append('no lesion')
        except KeyError:
            self.clin_sig_match = None
            self.false_positive = None
Beispiel #11
0
 def test_nearest_neighbor(self):
     """
     nearest neighbors are found for individual or list of regions
     """
     p = Prostate27()
     self.assertIn('6a', p.nearest_neighbors(['5a']))