├── LICENSE ├── logs ├── space.04.log ├── space.iso1.log ├── rdf.tdepth5.log ├── pre.b1s0_r3.log ├── space.iso1.orig.log ├── space.iso2.orig.log ├── space.iso5_r2.orig.log ├── space.04.orig.log ├── space.04_r2.orig.log ├── origeval.iso1.original.log ├── space.08.orig.log ├── space.08_r2.orig.log ├── space.iso1_r2.orig.log ├── origeval.08.original.log ├── space.iso3.orig.log ├── space.iso4.orig.log ├── space.iso4_r2.orig.log ├── origeval.iso3.original.log ├── space.iso3_r2.orig.log ├── space.iso5.orig.log ├── space.iso3.sequ.log ├── origeval.iso3.sequence.log ├── eval.std.all.log ├── pre.b0s0.log ├── pre.b0s0_r3.log ├── pre.b1s0.log ├── sample.size100k.log ├── pre.b0s0_r2.log ├── pre.b1s0_r2.log ├── sample.size25k.log ├── sample.size300k.log ├── sample.size50k.log ├── sample.size10k.log ├── sample.size150k_r2.log ├── sample.size150k_r3.log ├── sample.size150k_r5.log ├── eval.pre.flair.allpluscd.log ├── eval.pre.flair.allpluscd_19.log ├── eval.pre.flair.lh11102030.log ├── eval.pre.flair.lh1120.log ├── eval.pre.flair.lh1130.log ├── eval.pre.flair.lh1110.log ├── eval.pre.flair.lmg357.log ├── eval.pre.flair.lmg3.log ├── eval.pre.flair.lmg5.log ├── eval.pre.flair.lmg7.log ├── pre.b0s1.log ├── pre.b1s1.log ├── rdf.tdepth25.log ├── pre.b0s1_r2.log ├── pre.b0s1_r3.log ├── pre.b1s1_r3.log ├── rdf.tdepth10.log ├── rdf.tdepth100.log ├── rdf.tdepth1000.log ├── rdf.tdepth1500.log ├── rdf.tdepth2000.log ├── rdf.tdepth50.log ├── rdf.tdepth500.log ├── rdf.tdepth75.log ├── sample.size200k.log ├── sample.size250k_r5.log ├── sample.size500k.log ├── eval.pre.flair.median7.log ├── rdf.tdepth500_r2.log ├── sample.size1000k.log ├── sample.size150k.log ├── sample.size150k_r4.log ├── sample.size2000k.log ├── sample.size250k.log ├── sample.size250k_r2.log ├── sample.size250k_r3.log ├── sample.size250k_r6.log ├── sample.size400k.log ├── space.04.sequ.log ├── space.08.sequ.log ├── space.iso1.sequ.log ├── space.iso1_r2.sequ.log ├── space.iso2.sequ.log ├── space.native.orig.log ├── space.native.sequ.log ├── eval.pre.flair.int.log ├── origeval.iso1.sequence.log ├── space.04_r2.sequ.log ├── space.08_r2.sequ.log └── eval.pre.flair.ggm5.log ├── README.md ├── documentation ├── description ├── Ideas.odt ├── imageflow.dia ├── imageflow.pdf ├── Brainextraction.odt ├── rdfsegmentation.dia ├── Biasfieldcorrection.odt ├── intersequenceregistration ├── UnivariateFeatureSelectionStatistics.odt ├── HemisphericDifferenceFeature_NotesOnEnhancements.odt ├── t2space ├── biasfieldcorrection └── stdspace ├── experiments ├── 00original ├── LesionMaskingInIsotropicFlair.odt ├── LesionMaskingInIsotropicFlair_exp01a.ods ├── 01sequencespace └── 05flairlesionsegmentation ├── 00original ├── IMAGESELECTION.ods ├── IMAGECHARACTERISTICS_COMBINED.ods ├── description └── GROUPINGS ├── log ├── scripts ├── clean.py ├── tofloat64.py ├── threshold.py ├── thresholdcondenseimage.py ├── invert.py ├── correct_sform.py ├── condenseoutliers.py ├── apply_binary_mask.py ├── brainmasksegmcutoff.py ├── pass_header.py ├── show.sh ├── remove_small_objects.py ├── compute_lesion_volumes.py ├── check_spm_normalize_estimate_log.py ├── evaluate_mi.py ├── info.py ├── align.py ├── make_spm_normalize_write.py ├── make_spm_normalize_write_mask.py ├── train_rdf.py ├── equalvs.py ├── make_spm_normalize_estimate.py └── niftimodifymetadata.py ├── evaluate.sh ├── eva_sequencespace.sh ├── roadmap.txt ├── pop_stdbiasfieldcorrected.sh ├── pop_sequencebiasfieldcorrected.sh ├── eva_stdspace.sh ├── evaluate_original.sh ├── metadata.py ├── pop_stdsegmentations.sh ├── .gitignore └── pop_stdfeatureimages.sh /LICENSE: -------------------------------------------------------------------------------- 1 | non-public repository 2 | -------------------------------------------------------------------------------- /logs/space.04.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | -------------------------------------------------------------------------------- /logs/space.iso1.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | neuropipeline 2 | ============= 3 | a saveguard 4 | -------------------------------------------------------------------------------- /documentation/description: -------------------------------------------------------------------------------- 1 | Contains the detailed descriptions of each of the pipelines steps. 2 | -------------------------------------------------------------------------------- /documentation/Ideas.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/Ideas.odt -------------------------------------------------------------------------------- /experiments/00original: -------------------------------------------------------------------------------- 1 | See 00original/GROUPINGS for more details on different configurations to try out. 2 | -------------------------------------------------------------------------------- /documentation/imageflow.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/imageflow.dia -------------------------------------------------------------------------------- /documentation/imageflow.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/imageflow.pdf -------------------------------------------------------------------------------- /00original/IMAGESELECTION.ods: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/00original/IMAGESELECTION.ods -------------------------------------------------------------------------------- /documentation/Brainextraction.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/Brainextraction.odt -------------------------------------------------------------------------------- /documentation/rdfsegmentation.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/rdfsegmentation.dia -------------------------------------------------------------------------------- /documentation/Biasfieldcorrection.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/Biasfieldcorrection.odt -------------------------------------------------------------------------------- /documentation/intersequenceregistration: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/intersequenceregistration -------------------------------------------------------------------------------- /00original/IMAGECHARACTERISTICS_COMBINED.ods: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/00original/IMAGECHARACTERISTICS_COMBINED.ods -------------------------------------------------------------------------------- /experiments/LesionMaskingInIsotropicFlair.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/experiments/LesionMaskingInIsotropicFlair.odt -------------------------------------------------------------------------------- /experiments/LesionMaskingInIsotropicFlair_exp01a.ods: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/experiments/LesionMaskingInIsotropicFlair_exp01a.ods -------------------------------------------------------------------------------- /documentation/UnivariateFeatureSelectionStatistics.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/UnivariateFeatureSelectionStatistics.odt -------------------------------------------------------------------------------- /documentation/HemisphericDifferenceFeature_NotesOnEnhancements.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loli/neuropipeline/master/documentation/HemisphericDifferenceFeature_NotesOnEnhancements.odt -------------------------------------------------------------------------------- /log: -------------------------------------------------------------------------------- 1 | INFO: Procesing case 03 2 | INFO: Unpacking sequencespace images to .nii format 3 | INFO: Create inverses of preliminary lesion mask in basesequence space 4 | INFO: Create and run SPM Normalize Estimate step 5 | -------------------------------------------------------------------------------- /experiments/01sequencespace: -------------------------------------------------------------------------------- 1 | FLAIR only: 2 | Using native spacing would be nice, but will not work for sequences from other machines! 3 | I have to fix the spacing for this. Lets say to 2x2x2. 4 | 5 | !TODO: Try pre-segmentation with other spacings too, such as 1x1x1 or 4x4x4. See how it affects the outcome! 6 | -------------------------------------------------------------------------------- /documentation/t2space: -------------------------------------------------------------------------------- 1 | All sequences are rigidly registered to the T2 volume. 2 | 3 | Since DW and ADC share the same space, only one of these spectra has to be registered. We empirically chose DW for the registration, as random samples have shown the ADC based registration to be severly off in some cases (e.g. 13). 4 | -------------------------------------------------------------------------------- /logs/rdf.tdepth5.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | INFO: Done. 8 | -------------------------------------------------------------------------------- /scripts/clean.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | # clean out nan and inf values in-place. 4 | # arg1: the image to clean 5 | 6 | import sys 7 | 8 | import numpy 9 | 10 | from medpy.io import load, save 11 | 12 | i, h = load(sys.argv[1]) 13 | 14 | i[numpy.isnan(i)] = 0 15 | i[numpy.isinf(i)] = 0 16 | 17 | i = i.copy() 18 | 19 | save(i, sys.argv[1], h) 20 | -------------------------------------------------------------------------------- /scripts/tofloat64.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Load the input image, convert its data to numpy.float64, then save it under output. 5 | """ 6 | 7 | import sys 8 | import numpy 9 | from medpy.io import load, save 10 | 11 | def main(): 12 | i, h = load(sys.argv[1]) 13 | save(i.astype(numpy.float64), sys.argv[2], h) 14 | 15 | if __name__ == "__main__": 16 | main() 17 | 18 | 19 | -------------------------------------------------------------------------------- /scripts/threshold.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Thresholds an image according to a value (True where intensity >= value). 5 | arg1: the input image 6 | arg2: the threshold 7 | arg3: the output image 8 | """ 9 | 10 | import sys 11 | import numpy 12 | 13 | from medpy.io import load, save 14 | 15 | def main(): 16 | i, h = load(sys.argv[1]) 17 | thr = float(sys.argv[2]) 18 | 19 | o = i >= thr 20 | 21 | save(o, sys.argv[3], h) 22 | 23 | if __name__ == "__main__": 24 | main() 25 | -------------------------------------------------------------------------------- /evaluate.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | #### 4 | # Evaluate the results of a segmentation 5 | #### 6 | 7 | # include shared information 8 | source $(dirname $0)/include.sh 9 | 10 | # main code 11 | log 2 "Compute overall evaluation" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 12 | runcond "${scripts}/evaluate_segmentations.py ${sequencelesionsegmentation}/{}/segmentation_post.${imgfiletype} ${sequencesegmentations}/{}.${imgfiletype} ${sequencebrainmasks}/{}.${imgfiletype} $(joinarr " " ${images[@]})" 13 | 14 | -------------------------------------------------------------------------------- /scripts/thresholdcondenseimage.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Apply a lower threshold to an image and condense all intensities below to the threshold value. 5 | .py 6 | """ 7 | 8 | import sys 9 | import numpy 10 | from medpy.io import load, save 11 | 12 | def main(): 13 | i, h = load(sys.argv[1]) 14 | thr = int(sys.argv[2]) 15 | i[i < thr] = thr 16 | save(i, sys.argv[3], h) 17 | 18 | if __name__ == "__main__": 19 | main() 20 | 21 | 22 | -------------------------------------------------------------------------------- /scripts/invert.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | #### 4 | # Inverts a binary image 5 | # arg1: the input image to invert 6 | # arg2: the inverted output image 7 | #### 8 | 9 | import sys 10 | 11 | import numpy 12 | 13 | from medpy.io import load, save 14 | 15 | def main(): 16 | infile = sys.argv[1] 17 | outfile = sys.argv[2] 18 | 19 | i, h = load(infile) 20 | i = i.astype(numpy.bool) 21 | h.set_sform(h.get_qform()) 22 | save(~i, outfile, h) 23 | 24 | if __name__ == "__main__": 25 | main() 26 | -------------------------------------------------------------------------------- /scripts/correct_sform.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Corrects a (possibly) wrong sform in a NifTi header by copying the qform to it, 5 | arg1: the image to correct 6 | arg2: the target output image 7 | """ 8 | 9 | import sys 10 | 11 | from medpy.io import load, save 12 | 13 | def main(): 14 | # load input image 15 | i, h = load(sys.argv[1]) 16 | 17 | # correct sfrom 18 | h.set_sform(h.get_qform()) 19 | 20 | # save 21 | save(i, sys.argv[2], h) 22 | 23 | if __name__ == "__main__": 24 | main() 25 | -------------------------------------------------------------------------------- /scripts/condenseoutliers.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Apply a percentile threshold to the image, condensing all outliers to the percentile values. 5 | .py 6 | """ 7 | 8 | import sys 9 | import numpy 10 | from medpy.io import load, save 11 | 12 | def main(): 13 | i, h = load(sys.argv[1]) 14 | li = numpy.percentile(i, (1, 99.9)) 15 | i[i < li[0]] = li[0] 16 | i[i > li[1]] = li[1] 17 | save(i, sys.argv[2], h) 18 | 19 | if __name__ == "__main__": 20 | main() 21 | 22 | 23 | -------------------------------------------------------------------------------- /scripts/apply_binary_mask.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Apply a binary mask to an image, keeping only the intensity values where the maks is True. 5 | All other are set to zero. 6 | .py 7 | """ 8 | 9 | import sys 10 | import numpy 11 | from medpy.io import load, save 12 | 13 | def main(): 14 | i, h = load(sys.argv[1]) 15 | m = load(sys.argv[2])[0].astype(numpy.bool) 16 | i[~m] = 0 17 | save(i, sys.argv[3], h) 18 | 19 | if __name__ == "__main__": 20 | main() 21 | 22 | 23 | -------------------------------------------------------------------------------- /scripts/brainmasksegmcutoff.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Takes a brain mask and a segmentation as input and checks, whether and if, how many voxel the brain mask cuts from the segmentation. 5 | """ 6 | 7 | import sys 8 | import numpy 9 | from medpy.io import load, save 10 | 11 | def main(): 12 | m = load(sys.argv[1])[0].astype(numpy.bool) 13 | s = load(sys.argv[2])[0].astype(numpy.bool) 14 | 15 | intc = numpy.count_nonzero(~m & s) 16 | 17 | print "Non-intersecting part of the segmentation:" 18 | print "{} out of {} voxels".format(intc, numpy.count_nonzero(s)) 19 | 20 | if __name__ == "__main__": 21 | main() 22 | 23 | 24 | -------------------------------------------------------------------------------- /scripts/pass_header.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Passes a header from one image file to another (with the usual adaptions of data type, etc. undetaken). 5 | arg1: the image to correct (in-place) 6 | arg2: the template image, whose header to take 7 | """ 8 | 9 | import sys 10 | import numpy 11 | 12 | from medpy.io import load, save 13 | 14 | def main(): 15 | # load input image 16 | i, _ = load(sys.argv[1]) 17 | 18 | # load template image 19 | _, h = load(sys.argv[2]) 20 | 21 | # save input image with adapted header in place 22 | j = i.copy() 23 | save(j, sys.argv[1], h) 24 | 25 | if __name__ == "__main__": 26 | main() 27 | 28 | -------------------------------------------------------------------------------- /scripts/show.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ###### 4 | # Displays the .nii.gz images in the supplied location with amide. 5 | ###### 6 | 7 | # changelog 8 | # 2013-11-11 created 9 | 10 | echo "Displaying images from ${i} with amide:" 11 | 12 | tmpdir=`mktemp -d` 13 | echo "Using temporary directory ${tmpdir}..." 14 | 15 | echo "Unpacking images..." 16 | for f in "${1}"/*.nii.gz; do 17 | fn=`basename $f .nii.gz` 18 | medpy_convert.py "${f}" "${tmpdir}/${fn}.nii" 19 | done 20 | 21 | echo "Displaying images..." 22 | amide ${tmpdir}/t2_sag_tse.nii ${tmpdir}/*.nii ${tmpdir}/*.nii 23 | 24 | echo "Cleaning up..." 25 | rm ${tmpdir}/* 26 | rmdir ${tmpdir} 27 | echo "done." 28 | 29 | -------------------------------------------------------------------------------- /00original/description: -------------------------------------------------------------------------------- 1 | Holds the original images, some as softlinks, other as real files. One sub-folder per 2 | case, each with a different number of image files. 3 | 4 | The cases come from two different sources, the HEOPKS and JGABLENTZ image collections, 5 | but they all depict ischemic stroke lesions (although sometimes with small hemorrhages 6 | included). 7 | 8 | Image characteristics are listed in "IMAGECHARACTERISTICS_COMBINED.ods". 9 | Selection of cases and the mapping from database to case id are in "IMAGESELECTION.ods". 10 | Groupings according to different selection criteria can be found in "GROUPINGS.ods". 11 | 12 | All image with their original size, spacing and datatype. 13 | -------------------------------------------------------------------------------- /eva_sequencespace.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ##### 4 | # Roughly evaluates the results of the registration to t2space. 5 | # This evaluation is not very informative, but might serve to detect failed registrations. 6 | ##### 7 | 8 | ## Changelog 9 | # 2013-11-11 created 10 | 11 | # include shared information 12 | source $(dirname $0)/include.sh 13 | 14 | # main code 15 | log 2 "Evaluating against T2" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 16 | for s in "${sequences[@]}"; do 17 | 18 | echo "image;mu" > ${t2space}/${s}.againstt2.eval.csv 19 | 20 | log 2 "Processing sequence ${s}" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 21 | for i in "${images[@]}"; do 22 | cmd="${scripts}/evaluate_mi.py ${t2space}/${i}/${s}.${imgfiletype} ${t2space}/${i}/t2_sag_tse.${imgfiletype}" 23 | $cmd >> ${t2space}/${s}.againstt2.eval.csv 24 | done 25 | done 26 | -------------------------------------------------------------------------------- /scripts/remove_small_objects.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Remove small binary objects from a binary mask. 5 | Note: Takes voxel-spacing into account. 6 | Note: Does not remove small objects if hte binary mask would be empty afterwards. 7 | .py 8 | """ 9 | 10 | import sys 11 | import numpy 12 | from medpy.io import load, save, header 13 | from medpy.filter import size_threshold 14 | 15 | def main(): 16 | thr = float(sys.argv[3]) 17 | i, h = load(sys.argv[1]) 18 | 19 | # adapt threshold by voxel spacing 20 | thr /= numpy.prod(header.get_pixel_spacing(h)) 21 | # threshold binary objects 22 | j = size_threshold(i, thr, 'lt') 23 | # reset if last object has been removed 24 | if 0 == numpy.count_nonzero(j): 25 | j = i 26 | 27 | save(j, sys.argv[2], h, True) 28 | 29 | if __name__ == "__main__": 30 | main() 31 | 32 | 33 | -------------------------------------------------------------------------------- /documentation/biasfieldcorrection: -------------------------------------------------------------------------------- 1 | 2 | Note: it seems that most tools (like imiLib and FSL) work better when the skull has been stripped before. 3 | 4 | Note: the bias fields produced by the tools differ greatly; how to determine the best one? 5 | 6 | Using CMTK 7 | ########## 8 | Tested on two T2 volumes (03 + 06) with skull present. 9 | The results are promising, with a long (20+min) runtime. 10 | 11 | Tested on two T2 volumes (04 + 12) with skull absent. 12 | The results are promising, with a long (20+min) runtime. 13 | 14 | Using imiLib 15 | ############ 16 | Tested on two T2 volumes (03 + 06) with skull present. 17 | The results are promising, with a medium runtime (~3min). 18 | 19 | Tested on two T2 volumes (04 + 12) with skull absent. 20 | The results are promising, with a medium runtime (~3min). 21 | 22 | Using FSL (FAST) 23 | ################ 24 | Tested on two T2 volumes (03 + 06) with skull present. 25 | The results are promising, with a long (20+min) runtime. 26 | -------------------------------------------------------------------------------- /roadmap.txt: -------------------------------------------------------------------------------- 1 | XXsmoothed 2 | ########## 3 | No smoothing of the image. It got decided to smooth the image as a pre-processing step where required but otherwise leave it as it is. 4 | 5 | 05t2lesionlocations 6 | ################### 7 | Extract features from the images in t2space. 8 | Use RFs trained on all other images (i.e. leave-one-out) to roughly detect the lesion locations. 9 | Postprocess the results with morphological operations. 10 | Visually check results and decide, whether some growing or shirinking of the lesion area will be required. 11 | 12 | Implement such, that the extracted features and the trained RFs can be re-used. 13 | 14 | Evalute segmentation results over all images, to have a statistical measure of the classifiers performance. 15 | 16 | Extracting features: 17 | #################### 18 | Use only a simple set of the most discriminating features. Check this using the example of 5 classifiers in the Playground. 19 | Features: 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /scripts/compute_lesion_volumes.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Computes the lesion volumes, once percentual to the brain volume and once in mm, and 5 | prints them to the stdout. 6 | 7 | arg1: the directory with the lesion mask images 8 | arg2: the directory with the brain mask images 9 | """ 10 | 11 | import os 12 | import sys 13 | 14 | import numpy 15 | 16 | from medpy.io import load, header 17 | 18 | def main(): 19 | print 'lesion\tvolume (%)\tvolume (mm)' 20 | 21 | files = [f for f in os.listdir('{}'.format(sys.argv[1])) if os.path.isfile('{}/{}'.format(sys.argv[1], f))] 22 | for f in files: 23 | l, h = load('{}/{}'.format(sys.argv[1], f)) 24 | m, _ = load('{}/{}'.format(sys.argv[2], f)) 25 | 26 | lesion_voxel = numpy.count_nonzero(l) 27 | total_voxel = numpy.count_nonzero(m) 28 | 29 | volume_mm = numpy.prod(header.get_pixel_spacing(h)) * lesion_voxel 30 | volume_percentage = lesion_voxel / float(total_voxel) 31 | 32 | print '{}\t{}\t{}\t'.format(f[:-7], volume_percentage, volume_mm) 33 | 34 | if __name__ == "__main__": 35 | main() 36 | 37 | 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /scripts/check_spm_normalize_estimate_log.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | #### 4 | # Checks a the output created by a SPM Normalize Estimate operation for potentially failed registrations. If detected, prints a warning. 5 | # arg1: the log file containing the output 6 | # arg2: the FWHM score threshold 7 | #### 8 | 9 | import sys 10 | 11 | def main(): 12 | logfile = sys.argv[1] 13 | fwhm_threshold = float(sys.argv[2]) 14 | 15 | with open(logfile, 'r') as f: 16 | fwhm_found = False 17 | for line in f.readlines(): 18 | line = line.strip() 19 | if 'FWHM' in line: 20 | fwhm_found = True 21 | segments = line.split('=') 22 | fwhm_value = float(segments[1].strip().split(' ')[0]) 23 | fwhm_std = float(segments[2].strip().split(' ')[0]) 24 | elif fwhm_found: 25 | print 'Registration terminated with FWHM {} +/- {}.'.format(fwhm_value, fwhm_std) 26 | if fwhm_value > fwhm_threshold: 27 | print 'WARNING: Registration terminated with a score FWHM value of {}, which is above the threshold {}.'.format(fwhm_value, fwhm_threshold) 28 | fwhm_found = False 29 | 30 | if __name__ == "__main__": 31 | main() 32 | -------------------------------------------------------------------------------- /pop_stdbiasfieldcorrected.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ##### 4 | # Removes intensity in-homogenities in the images. 5 | ##### 6 | 7 | ## Changelog 8 | # 2013-11-14 added a step to correct the nifti metadata 9 | # 2013-11-11 created 10 | 11 | # include shared information 12 | source $(dirname $0)/include.sh 13 | 14 | # main code 15 | log 2 "Correcting the bias fields" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 16 | for i in "${images[@]}"; do 17 | mkdircond ${stdbiasfieldcorrected}/${i} 18 | for s in "${sequences[@]}"; do 19 | 20 | echo ${stdbiasfieldcorrected}/${i}/${s}.${imgfiletype} 21 | # continue if target file already exists 22 | if [ -f "${stdbiasfieldcorrected}/${i}/${s}.${imgfiletype}" ]; then 23 | continue 24 | fi 25 | 26 | # esitmate and correct bias field 27 | cmd="cmtk mrbias --mask ${stdbrainmasks}/${i}.${imgfiletype} ${stdskullstripped}/${i}/${s}.${imgfiletype} ${stdbiasfieldcorrected}/${i}/${s}.${imgfiletype}" # note: already multitasking 28 | $cmd > /dev/null 29 | 30 | # correct nifit orientation metadata in-place 31 | cmd="${scripts}/niftimodifymetadata.py ${t2stdbiasfieldcorrected}/${i}/${s}.${imgfiletype} qf=aff sf=aff qfc=2 sfc=2" 32 | $cmd 33 | done 34 | done 35 | log 2 "Done." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 36 | -------------------------------------------------------------------------------- /scripts/evaluate_mi.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Mutual information evaluation. 5 | arg1: first image 6 | arg2: second image 7 | """ 8 | 9 | import sys 10 | 11 | import numpy 12 | 13 | from medpy.io import load, save 14 | from medpy.metric.image import mutual_information 15 | 16 | def main(): 17 | # load input images 18 | i1, h1 = load(sys.argv[1]) 19 | i2, h2 = load(sys.argv[2]) 20 | 21 | # clean images 22 | i1 = clean(i1) 23 | i2 = clean(i2) 24 | 25 | # smooth images 26 | #i1 = gauss(i1, h1, sigma=2) 27 | #i2 = gauss(i2, h2, sigma=2) 28 | 29 | # mutual information 30 | mu = mutual_information(i1[(i1 > 0) & (i2 > 0)], i2[(i1 > 0) & (i2 > 0)]) 31 | 32 | # print 33 | print '{};{};'.format(sys.argv[1], mu) 34 | 35 | def clean(i, cval = 0): 36 | """ 37 | Removes all nan and inf from the image and replace them with a constant value. 38 | """ 39 | i[numpy.isnan(i)] = 0 40 | i[numpy.isinf(i)] = 0 41 | return i 42 | 43 | def gauss(i, h, sigma=6): 44 | """ 45 | Applies a gaussian smoothing to the image with the supplied kernel size in mmm. 46 | """ 47 | sigmas = [sigma * ps for ps in header.get_pixel_spacing(h)] 48 | i = gaussian_filter(i, sigma=sigmas) 49 | return i 50 | 51 | if __name__ == "__main__": 52 | main() 53 | -------------------------------------------------------------------------------- /pop_sequencebiasfieldcorrected.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ##### 4 | # Removes intensity in-homogenities in the images. 5 | ##### 6 | 7 | ## Changelog 8 | # 2014-04-09 adapted to new style 9 | # 2013-11-14 added a step to correct the nifti metadata 10 | # 2013-11-04 imporved code 11 | # 2013-10-17 created 12 | 13 | # include shared information 14 | source $(dirname $0)/include.sh 15 | 16 | # main code 17 | log 2 "Correcting the bias fields" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 18 | for i in "${images[@]}"; do 19 | mkdircond ${sequencebiasfieldcorrected}/${i} 20 | for s in "${sequences[@]}"; do 21 | 22 | # continue if target file already exists 23 | if [ -f "${sequencebiasfieldcorrected}/${i}/${s}.${imgfiletype}" ]; then 24 | continue 25 | fi 26 | 27 | # esitmate and correct bias field 28 | runcond "cmtk mrbias --mask ${sequencebrainmasks}/${i}.${imgfiletype} ${sequenceskullstripped}/${i}/${s}.${imgfiletype} ${sequencebiasfieldcorrected}/${i}/${s}.${imgfiletype}" # note: already multitasking 29 | 30 | # correct nifit orientation metadata in-place 31 | runcond "${scripts}/niftimodifymetadata.py ${sequencebiasfieldcorrected}/${i}/${s}.${imgfiletype} qf=aff sf=aff qfc=1 sfc=1" 32 | done 33 | done 34 | log 2 "Done." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 35 | 36 | -------------------------------------------------------------------------------- /eva_stdspace.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ##### 4 | # Roughly evaluates the results of the registration to stdspace. 5 | # This evaluation is not very speaking, but might serve to detect failed registrations. 6 | ##### 7 | 8 | ## Changelog 9 | # 2013-11-07 created 10 | 11 | # include shared information 12 | source $(dirname $0)/include.sh 13 | 14 | # main code 15 | log 2 "Evaluating against std brain" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 16 | for s in "${sequences[@]}"; do 17 | 18 | echo "image;ssd;mu" > ${stdspace}/${s}.againststd.eval.csv 19 | 20 | log 2 "Processing sequence ${s}" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 21 | for i in "${images[@]}"; do 22 | cmd="${scripts}/evaluate_stdspace.py ${stdspace}/${i}/${s}.${imgfiletype} /home/maier/Applications/spm8/templates/T2.nii /home/maier/Applications/spm8/apriori/brainmask.nii" 23 | $cmd >> ${stdspace}/${s}.againststd.eval.csv 24 | done 25 | done 26 | 27 | log 2 "Evaluating against T2" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 28 | for s in "${sequences[@]}"; do 29 | 30 | echo "image;seq;mu" > ${stdspace}/${s}.againstt2.eval.csv 31 | 32 | log 2 "Processing sequence ${s}" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 33 | for i in "${images[@]}"; do 34 | cmd="${scripts}/evaluate_mi.py ${stdspace}/${i}/${s}.${imgfiletype} ${stdspace}/${i}/t2_sag_tse.${imgfiletype}" 35 | $cmd >> ${stdspace}/${s}.againstt2.eval.csv 36 | done 37 | done 38 | -------------------------------------------------------------------------------- /documentation/stdspace: -------------------------------------------------------------------------------- 1 | #### 2 | # Steps to register the Image to STD space 3 | #### 4 | 5 | 1. Convert all original images from 00original to .nii (as SPM can not read .nii.gz and performs better with skull present) 6 | 2. Create inverse of all t2space preliminary lesion masks (required by SPM) 7 | 3. Run SPM Normalize Estimate 8 | - input is the original T2 image 9 | - mask is the inversed lesion mask 10 | - template is the shipped ICBM T2 template 11 | - smoothing parameter for image is 8 12 | - smoothing parameter for template is 0 13 | => this creates a .mat matlab struct file with the same name (_sn.mat) as the original image and in the same place 14 | 4. Check log output of previous step, and give warning if FHWM value is >= 15 (possibly failed registration, but note that a value < 15 does not ensure a good registration, see case 14) 15 | 5. Create matlab .m scripts for each remaining sequence, with the following functionality 16 | - load and assemple the rigid transformation matrix from the elastic tranformation file 17 | - load the produced T2 _sn.mat struct 18 | - multiply the Affine transformation matric from that file with the rigid one produced before (affine * rigid - matrix multiplication) 19 | - saves the now modified struct as a _sn.mat file for the current sequence 20 | 6. Run the such produced matlab scripts 21 | 7. Run SPM Normalize Write / Warping for each sequence (including T2) to produce the respective image transformed to stdspace with a spacing of 1x1x1 22 | 23 | 24 | -------------------------------------------------------------------------------- /evaluate_original.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | #### 4 | # Evaluate a segmentation in the original space instead of the sequences space. 5 | #### 6 | 7 | # include shared information 8 | source $(dirname $0)/include.sh 9 | 10 | # main code 11 | tmpdir=`mktemp -d` 12 | 13 | function revert() 14 | { 15 | idx=$1 16 | vs=( $(voxelspacing "${segmentations}/${idx}.${imgfiletype}") ) 17 | vs2=$(joinarr " " ${vs[@]}) 18 | runcond "imiImageResample -I ${sequencelesionsegmentation}/${idx}/segmentation_post.${imgfiletype} -O ${tmpdir}/s${idx}.${imgfiletype} -R ${segmentations}/${idx}.${imgfiletype} -s ${vs2} -b" /dev/null 19 | runcond "imiImageResample -I ${sequencebrainmasks}/${idx}.${imgfiletype} -O ${tmpdir}/m${idx}.${imgfiletype} -R ${segmentations}/${idx}.${imgfiletype} -s ${vs2} -b" /dev/null 20 | } 21 | 22 | # revert segmentation to original space for evaluation 23 | log 2 "Reverting segmentations...." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 24 | parallelize revert ${threadcount} images[@] 25 | 26 | log 2 "Evaluating in original space..." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 27 | runcond "${scripts}/evaluate_segmentations.py ${tmpdir}/s{}.${imgfiletype} ${segmentations}/{}.${imgfiletype} ${tmpdir}/m{}.${imgfiletype} $(joinarr " " ${images[@]})" 28 | 29 | log 2 "Evaluating in sequence space.." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 30 | runcond "${scripts}/evaluate_segmentations.py ${sequencelesionsegmentation}/{}/segmentation_post.${imgfiletype} ${sequencesegmentations}/{}.${imgfiletype} ${sequencebrainmasks}/{}.${imgfiletype} $(joinarr " " ${images[@]})" 31 | 32 | emptydircond ${tmpdir} 33 | rmdircond "${tmpdir}" 34 | -------------------------------------------------------------------------------- /scripts/info.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | # Scans all image folders and creates a table with detailed information about each image. 4 | 5 | import os 6 | import sys 7 | from medpy.io import load, save, header 8 | 9 | DEBUG = True 10 | FILE_ENDING = 'nii.gz' 11 | 12 | def main(): 13 | srcdir = sys.argv[1] # the image folder contianing the case folders (e.g. data/) 14 | target = sys.argv[2] # the target file where to save the table (in csv format) 15 | 16 | if DEBUG: print 'INFO: Processing all cases in folder {} and saving table as {}.'.format(srcdir, target) 17 | 18 | # check if output file already exists 19 | if os.path.isfile(target): 20 | print 'ERROR: Target file {} already exists. Breaking.'.format(target) 21 | sys.exit(-1) 22 | 23 | # open output file and prepare table header 24 | with open(target, 'w') as f: 25 | f.write('case;image-type;X;Y;Z;Xres;Yres;Zres;data-type;mean;min;max\n') 26 | 27 | # iterate over all cases and add an according line to the table 28 | for root, dirs, files in os.walk(srcdir): 29 | for case in sorted(dirs): 30 | if DEBUG: print 'INFO: Processing case {}.'.format(case) 31 | for root, dirs, files in os.walk('{}/{}'.format(srcdir, case)): 32 | for file_ in files: 33 | if file_.endswith(FILE_ENDING): 34 | imgtype = file_[:-(len(FILE_ENDING) + 1)] 35 | i, h = load('{}/{}/{}'.format(srcdir, case, file_)) 36 | f.write('{};{};{};{};{};{};{};{}\n'.format(case, imgtype, ';'.join(map(str, i.shape)), ';'.join(map(str, header.get_pixel_spacing(h))), i.dtype, i.mean(), i.min(), i.max())) 37 | 38 | print 'Terminated.' 39 | 40 | if __name__ == "__main__": 41 | main() 42 | -------------------------------------------------------------------------------- /scripts/align.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Aligns the first input image to the second taking origin into account and assuming the same voxel spacing. 5 | Note: This might require the image to be truncated. 6 | arg1: the image to align 7 | arg2: the reference image 8 | arg3: the target output image 9 | """ 10 | 11 | import sys 12 | import numpy 13 | 14 | from medpy.io import load, save, header 15 | 16 | def main(): 17 | i1, h1 = load(sys.argv[1]) 18 | i2, h2 = load(sys.argv[2]) 19 | 20 | # shift image to align origins 21 | origin_h1 = numpy.sign(h1.get_qform()[0:3,0:3]).dot(header.get_offset(h1)) 22 | origin_h2 = numpy.sign(h2.get_qform()[0:3,0:3]).dot(header.get_offset(h2)) 23 | origin_difference_pixel = (origin_h1 - origin_h2) / numpy.asarray(header.get_pixel_spacing(h1)) 24 | # negative values: shift image 1 by this upon inserting (which is the smae as cutting the output image) 25 | # positive values: cut image 1 by this at inserting and also cut right side by length of output image plus this value 26 | o = numpy.zeros(i2.shape, i2.dtype) 27 | o_slicer = [] 28 | i_slicer = [] 29 | for j, p in enumerate(origin_difference_pixel): 30 | if p >= 0: 31 | i_slicer.append(slice(0, min(i1.shape[j], o.shape[j] - abs(p)))) 32 | o_slicer.append(slice(abs(p), min(i1.shape[j] + abs(p), o.shape[j]))) 33 | else: 34 | i_slicer.append(slice(abs(p), min(i1.shape[j], o.shape[j] + abs(p)))) 35 | o_slicer.append(slice(0, min(i1.shape[j] - abs(p), o.shape[j]))) 36 | 37 | o[o_slicer] = i1[i_slicer] 38 | header.set_offset(h1, header.get_offset(h2)) 39 | 40 | save(o, sys.argv[3], h1) 41 | 42 | if __name__ == "__main__": 43 | main() 44 | -------------------------------------------------------------------------------- /scripts/make_spm_normalize_write.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | #### 4 | # Creates a Matlab script to warp the different MRI sequences to std-space. 5 | # The method used is: SPM Normalize Write 6 | # arg1: the target matlab script to create 7 | # arg2: the SPM transformation struct containing the desired transformation 8 | # arg3+: the image to transform 9 | #### 10 | 11 | import sys 12 | 13 | def main(): 14 | target = sys.argv[1] 15 | spmstruct = sys.argv[2] 16 | 17 | combined_images = ' '.join(["'{},1'".format(img) for img in sys.argv[3:]]) 18 | script = script_template.format(combined_images, spmstruct, spmstruct, combined_images) 19 | 20 | with open(target, 'w') as f: 21 | f.write(script) 22 | 23 | script_template = """ 24 | % Script to warp the images {} to std-space using {}. 25 | 26 | addpath '/home/maier/Applications/spm8' 27 | 28 | matlabbatch{{1}}.spm.spatial.normalise.write.subj(1).matname = {{'{}'}}; 29 | matlabbatch{{1}}.spm.spatial.normalise.write.subj(1).resample = {{{}}}; 30 | 31 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.preserve = 0; 32 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.bb = [-78 -112 -50 33 | 78 76 85]; 34 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.vox = [1 1 1]; 35 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.interp = 7; 36 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.wrap = [0 0 0]; 37 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.prefix = 'w'; 38 | 39 | spm('defaults', 'FMRI'); 40 | spm_jobman('initcfg'); 41 | spm_jobman('serial', matlabbatch); 42 | 43 | exit; 44 | """ 45 | 46 | if __name__ == "__main__": 47 | main() 48 | -------------------------------------------------------------------------------- /metadata.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Prints out handy information about the metadata of an NifTi image, especially regarding the transformation to world coordinates. 5 | arg1: the image to check 6 | """ 7 | 8 | import sys 9 | 10 | import numpy 11 | 12 | from medpy.io import load, header 13 | 14 | def main(): 15 | i, h = load(sys.argv[1]) 16 | 17 | print 'Image:\t{}'.format(sys.argv[1]) 18 | print 'Shape:\t{}'.format(i.shape) 19 | print 'Spacing:{}'.format(header.get_pixel_spacing(h)) 20 | print 'Offset:\t{}'.format(header.get_offset(h)) 21 | 22 | if 0 == h.get_header()['qform_code']: 23 | method = 'ANALYZE 7.5 (old)' 24 | if h.get_header()['qform_code'] > 0: 25 | method = 'Normal (qform)' 26 | if h.get_header()['sform_code'] > 0: 27 | method = 'Special space (sform)' 28 | 29 | print 30 | print 'Orientation and location in space:' 31 | print 'Type:\t\t{}'.format(method) 32 | print 'qform_code:\t{}'.format(h.get_header()['qform_code']) 33 | print 'sform_code:\t{}'.format(h.get_header()['sform_code']) 34 | 35 | print 36 | print 'qform == sform?\t{} (max diff={})'.format(numpy.all(h.get_qform() == h.get_sform()), numpy.max(numpy.abs(h.get_qform() - h.get_sform()))) 37 | print 'affine = qform?\t{} (max diff={})'.format(numpy.all(h.get_affine() == h.get_qform()), numpy.max(numpy.abs(h.get_affine() - h.get_qform()))) 38 | print 'affine = sform?\t{} (max diff={})'.format(numpy.all(h.get_affine() == h.get_sform()), numpy.max(numpy.abs(h.get_affine() - h.get_sform()))) 39 | 40 | print 41 | print 'qform:' 42 | print h.get_qform() 43 | print 'sform:' 44 | print h.get_sform() 45 | print 'affine:' 46 | print h.get_affine() 47 | 48 | if __name__ == "__main__": 49 | main() 50 | -------------------------------------------------------------------------------- /logs/pre.b1s0_r3.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.780 28.983 4.173 0.906 0.684 4 | 04 0.641 82.511 13.334 0.511 0.860 5 | 05 0.733 20.591 4.742 0.932 0.605 6 | 06 0.550 26.382 5.236 0.952 0.387 7 | 07 0.833 15.620 2.367 0.942 0.746 8 | 08 0.691 27.495 4.903 0.912 0.557 9 | 09 0.404 15.362 3.326 0.965 0.255 10 | 10 0.557 46.000 6.695 0.975 0.390 11 | 11 0.709 65.635 6.065 0.716 0.702 12 | 12 0.427 43.543 7.719 0.995 0.272 13 | 13 0.777 24.083 3.155 0.922 0.671 14 | 15 0.822 14.967 1.883 0.836 0.808 15 | 17 0.734 27.785 3.358 0.957 0.595 16 | 18 0.807 16.125 2.021 0.974 0.689 17 | 19 0.189 100.975 25.035 0.106 0.888 18 | 20 0.870 8.246 1.537 0.816 0.931 19 | 21 0.741 92.671 13.487 0.740 0.742 20 | 22 0.292 28.705 7.207 0.245 0.361 21 | 23 0.611 30.067 3.894 0.885 0.467 22 | 25 0.622 27.785 3.382 0.679 0.573 23 | 26 0.656 29.120 2.764 0.792 0.561 24 | 28 0.779 28.142 2.943 0.865 0.708 25 | 29 0.679 75.551 7.813 0.613 0.762 26 | 30 0.501 57.723 6.182 0.856 0.354 27 | 31 0.182 33.106 7.410 0.973 0.100 28 | 32 0.321 25.377 7.647 0.829 0.199 29 | 33 0.354 66.363 14.536 0.224 0.851 30 | 34 0.633 41.280 6.263 0.810 0.519 31 | 35 0.318 26.981 7.820 0.997 0.189 32 | 36 0.441 22.091 3.986 0.941 0.288 33 | 37 0.000 49.437 29.365 0.000 0.000 34 | 39 0.000 inf inf 0.000 0.000 35 | 40 0.472 42.237 6.485 0.936 0.316 36 | 41 0.053 47.707 19.696 0.435 0.028 37 | 42 0.474 16.125 3.741 0.972 0.313 38 | 43 0.580 81.019 14.843 0.514 0.666 39 | 44 0.260 24.739 5.064 0.991 0.150 40 | 45 0.335 70.000 13.244 0.347 0.325 41 | DM average 0.521784683387 +/- 0.23909122849 42 | HD average inf +/- nan 43 | ASSD average inf +/- nan 44 | Prec. average 0.738349715299 +/- 0.292970516389 45 | Rec. average 0.487151581802 +/- 0.262767890231 46 | -------------------------------------------------------------------------------- /scripts/make_spm_normalize_write_mask.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | #### 4 | # Creates a Matlab script to warp the different MRI sequences to std-space. 5 | # This version is for warping binary files with a reduced bspline order. 6 | # The method used is: SPM Normalize Write 7 | # arg1: the target matlab script to create 8 | # arg2: the SPM transformation struct containing the desired transformation 9 | # arg3+: the image to transform 10 | #### 11 | 12 | import sys 13 | 14 | def main(): 15 | target = sys.argv[1] 16 | spmstruct = sys.argv[2] 17 | 18 | combined_images = ' '.join(["'{},1'".format(img) for img in sys.argv[3:]]) 19 | script = script_template.format(combined_images, spmstruct, spmstruct, combined_images) 20 | 21 | with open(target, 'w') as f: 22 | f.write(script) 23 | 24 | script_template = """ 25 | % Script to warp the images {} to std-space using {}. 26 | 27 | addpath '/home/maier/Applications/spm8' 28 | 29 | matlabbatch{{1}}.spm.spatial.normalise.write.subj(1).matname = {{'{}'}}; 30 | matlabbatch{{1}}.spm.spatial.normalise.write.subj(1).resample = {{{}}}; 31 | 32 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.preserve = 0; 33 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.bb = [-78 -112 -50 34 | 78 76 85]; 35 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.vox = [1 1 1]; 36 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.interp = 0; 37 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.wrap = [0 0 0]; 38 | matlabbatch{{1}}.spm.spatial.normalise.write.roptions.prefix = 'w'; 39 | 40 | spm('defaults', 'FMRI'); 41 | spm_jobman('initcfg'); 42 | spm_jobman('serial', matlabbatch); 43 | 44 | exit; 45 | """ 46 | 47 | if __name__ == "__main__": 48 | main() 49 | -------------------------------------------------------------------------------- /logs/space.iso1.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.668 31.486 5.645 0.966 0.510 4 | 04 0.728 62.950 5.647 0.713 0.743 5 | 05 0.287 30.641 10.689 0.999 0.168 6 | 06 0.729 19.473 3.091 0.946 0.593 7 | 07 0.838 17.141 2.212 0.969 0.738 8 | 08 0.716 22.416 4.450 0.984 0.563 9 | 09 0.515 76.649 9.568 0.390 0.760 10 | 10 0.542 37.211 7.714 0.992 0.373 11 | 11 0.705 24.133 2.275 0.877 0.589 12 | 12 0.802 17.496 2.921 0.966 0.685 13 | 13 0.789 24.868 2.788 0.928 0.687 14 | 15 0.786 13.212 1.884 0.781 0.791 15 | 17 0.808 17.576 1.813 0.861 0.761 16 | 18 0.805 14.891 2.000 0.797 0.812 17 | 19 0.437 73.614 10.717 0.307 0.753 18 | 20 0.841 8.259 1.193 0.795 0.893 19 | 21 0.846 15.880 1.424 0.896 0.801 20 | 22 0.341 31.825 6.242 0.239 0.598 21 | 23 0.498 95.386 13.607 0.438 0.578 22 | 25 0.554 31.868 4.537 0.459 0.701 23 | 26 0.714 20.417 1.931 0.636 0.813 24 | 28 0.831 27.273 2.034 0.819 0.843 25 | 29 0.745 38.292 3.221 0.801 0.695 26 | 30 0.455 25.080 5.204 0.966 0.297 27 | 31 0.783 12.087 1.345 0.827 0.744 28 | 32 0.506 73.119 12.689 0.417 0.645 29 | 33 0.523 45.475 5.987 0.732 0.407 30 | 34 0.571 63.493 10.226 0.455 0.766 31 | 35 0.717 15.020 3.478 0.958 0.573 32 | 36 0.832 11.113 1.363 0.789 0.880 33 | 37 0.000 63.763 33.096 0.000 0.000 34 | 39 0.522 60.653 4.929 0.426 0.676 35 | 40 0.277 44.674 8.177 0.972 0.162 36 | 41 0.059 60.469 26.983 0.480 0.032 37 | 42 0.599 14.817 2.261 0.872 0.456 38 | 43 0.669 69.214 6.711 0.928 0.523 39 | 44 0.411 22.051 2.847 0.933 0.264 40 | 45 0.393 66.475 9.312 0.560 0.303 41 | DM average 0.601153339218 +/- 0.21263285666 42 | HD average 36.8541878554 +/- 23.1145187831 43 | ASSD average 6.37404038079 +/- 6.56319106052 44 | Prec. average 0.733451939504 +/- 0.252498775587 45 | Rec. average 0.583596663727 +/- 0.233176429312 46 | -------------------------------------------------------------------------------- /logs/space.iso2.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.638 32.295 6.307 0.973 0.474 4 | 04 0.646 67.383 9.135 0.587 0.718 5 | 05 0.335 36.769 10.658 0.996 0.201 6 | 06 0.788 19.067 2.604 0.905 0.697 7 | 07 0.877 12.236 1.445 0.948 0.817 8 | 08 0.703 24.412 5.266 0.992 0.544 9 | 09 0.528 74.906 7.683 0.416 0.724 10 | 10 0.488 26.452 7.822 0.995 0.323 11 | 11 0.583 43.183 5.170 0.940 0.423 12 | 12 0.825 15.416 2.566 0.965 0.720 13 | 13 0.794 24.705 2.886 0.885 0.721 14 | 15 0.793 15.882 1.693 0.801 0.785 15 | 17 0.810 16.610 2.038 0.775 0.848 16 | 18 0.747 17.461 2.689 0.809 0.695 17 | 19 0.514 71.317 7.646 0.403 0.708 18 | 20 0.791 70.247 8.883 0.751 0.836 19 | 21 0.835 18.192 1.390 0.944 0.748 20 | 22 0.310 21.832 6.241 0.239 0.441 21 | 23 0.410 97.688 17.297 0.293 0.680 22 | 25 0.571 78.994 6.821 0.475 0.715 23 | 26 0.702 20.058 2.205 0.591 0.864 24 | 28 0.821 26.019 2.205 0.813 0.830 25 | 29 0.738 43.084 3.522 0.833 0.662 26 | 30 0.502 22.000 5.026 0.963 0.340 27 | 31 0.751 15.429 1.495 0.852 0.672 28 | 32 0.544 67.726 12.301 0.480 0.628 29 | 33 0.578 46.397 5.402 0.779 0.459 30 | 34 0.690 37.772 5.744 0.625 0.772 31 | 35 0.813 12.578 2.335 0.960 0.705 32 | 36 0.828 10.967 1.443 0.797 0.861 33 | 37 0.000 56.770 32.422 0.000 0.000 34 | 39 0.599 12.910 2.281 0.599 0.599 35 | 40 0.163 50.444 10.417 0.972 0.089 36 | 41 0.064 56.054 14.508 0.937 0.033 37 | 42 0.586 14.960 2.276 0.898 0.435 38 | 43 0.759 67.007 3.994 0.961 0.628 39 | 44 0.081 25.468 5.788 1.000 0.042 40 | 45 0.440 19.725 5.905 0.589 0.351 41 | DM average 0.595915402992 +/- 0.229567097696 42 | HD average 36.5898219059 +/- 23.2645381821 43 | ASSD average 6.19759786177 +/- 5.7341162197 44 | Prec. average 0.756332515262 +/- 0.245542444808 45 | Rec. average 0.573329465592 +/- 0.245163060648 46 | -------------------------------------------------------------------------------- /logs/space.iso5_r2.orig.log: -------------------------------------------------------------------------------- 1 | 03 0.561 35.869 7.109 0.970 0.395 2 | 04 0.639 13.617 2.810 0.714 0.579 3 | 05 0.287 35.597 12.236 0.999 0.168 4 | 06 0.717 21.976 3.661 0.901 0.596 5 | 07 0.828 12.505 2.209 0.915 0.757 6 | 08 0.714 33.675 6.071 0.954 0.571 7 | 09 0.130 25.379 5.688 0.537 0.074 8 | 10 0.296 35.390 11.157 0.997 0.174 9 | 11 0.510 24.547 3.845 0.924 0.353 10 | 12 0.738 17.884 3.711 0.977 0.593 11 | 13 0.689 21.542 3.903 0.940 0.544 12 | 15 0.744 20.344 1.911 0.851 0.662 13 | 17 0.691 55.275 5.518 0.786 0.616 14 | 18 0.228 47.095 12.742 0.226 0.229 15 | 19 0.510 15.932 3.018 0.611 0.438 16 | 20 0.730 11.325 2.339 0.849 0.640 17 | 21 0.801 18.450 2.060 0.898 0.722 18 | 22 0.087 25.897 9.131 0.108 0.072 19 | 23 0.514 24.541 3.435 0.734 0.395 20 | 25 0.350 74.329 15.795 0.510 0.266 21 | 26 0.641 20.486 3.076 0.536 0.798 22 | 28 0.775 27.980 2.980 0.809 0.744 23 | 29 0.603 42.409 4.723 0.808 0.481 24 | 30 0.068 91.856 19.332 0.988 0.035 25 | 31 0.051 42.464 9.615 0.669 0.027 26 | 32 0.689 19.254 3.537 0.606 0.799 27 | 33 0.667 23.029 2.866 0.780 0.583 28 | 34 0.773 10.762 1.393 0.853 0.707 29 | 35 0.774 17.070 3.051 0.930 0.663 30 | 36 0.771 16.176 1.871 0.841 0.711 31 | 37 0.000 69.065 47.571 0.000 0.000 32 | 39 0.000 inf inf 0.000 0.000 33 | 40 0.309 47.908 9.867 0.994 0.183 34 | 41 0.062 45.145 13.727 0.996 0.032 35 | 42 0.000 inf inf 0.000 0.000 36 | 43 0.605 23.752 5.297 0.936 0.447 37 | 44 0.000 inf inf 0.000 0.000 38 | 45 0.324 26.443 7.677 0.462 0.250 39 | WARNING: Average values only computed on 35 of 38 cases! 40 | DM average 0.510809772938 +/- 0.258844429831 41 | HD average 31.2848097545 +/- 18.4586699534 42 | ASSD average 7.28373214429 +/- 8.18549867172 43 | Prec. average 0.760326380365 +/- 0.251868226585 44 | Rec. average 0.437195569115 +/- 0.253995042359 45 | -------------------------------------------------------------------------------- /logs/space.04.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.582 33.893 6.061 0.976 0.414 4 | 04 0.635 80.376 11.810 0.554 0.744 5 | 05 0.304 26.019 9.491 1.000 0.179 6 | 06 0.658 22.609 3.659 0.977 0.496 7 | 07 0.703 17.224 3.368 0.976 0.549 8 | 08 0.764 24.086 3.708 0.976 0.627 9 | 09 0.371 14.141 2.240 0.804 0.241 10 | 10 0.506 24.037 6.780 0.996 0.339 11 | 11 0.585 24.216 2.535 0.903 0.433 12 | 12 0.747 17.448 3.292 0.977 0.605 13 | 13 0.774 28.979 2.915 0.904 0.676 14 | 15 0.738 18.070 1.876 0.836 0.661 15 | 17 0.771 66.070 4.264 0.842 0.710 16 | 18 0.801 14.169 1.423 0.925 0.707 17 | 19 0.182 98.765 22.562 0.405 0.118 18 | 20 0.685 115.108 13.402 0.666 0.704 19 | 21 0.805 17.374 2.076 0.880 0.742 20 | 22 0.252 42.580 7.452 0.165 0.528 21 | 23 0.511 93.492 8.734 0.484 0.542 22 | 25 0.464 91.093 6.618 0.335 0.756 23 | 26 0.677 22.000 2.439 0.650 0.707 24 | 28 0.795 23.392 2.021 0.871 0.731 25 | 29 0.681 63.737 7.078 0.726 0.641 26 | 30 0.348 32.088 6.500 0.960 0.213 27 | 31 0.492 31.577 4.973 0.956 0.331 28 | 32 0.500 67.887 11.648 0.501 0.499 29 | 33 0.483 23.385 3.955 0.911 0.328 30 | 34 0.660 12.220 2.031 0.871 0.532 31 | 35 0.641 16.500 4.322 0.968 0.479 32 | 36 0.826 12.136 1.622 0.806 0.847 33 | 37 0.012 64.897 21.740 0.006 0.078 34 | 39 0.388 33.000 4.829 0.472 0.329 35 | 40 0.242 40.522 8.624 0.914 0.139 36 | 41 0.107 61.414 16.412 0.706 0.058 37 | 42 0.397 67.304 18.554 0.489 0.334 38 | 43 0.660 21.299 4.071 0.979 0.498 39 | 44 0.000 83.378 69.648 0.000 0.000 40 | 45 0.271 29.565 9.064 0.401 0.205 41 | DM average 0.526774727116 +/- 0.228306958755 42 | HD average 41.4750661668 +/- 28.2073040392 43 | ASSD average 8.52101922227 +/- 11.4157609516 44 | Prec. average 0.730819290916 +/- 0.278981090722 45 | Rec. average 0.466314971691 +/- 0.228693343772 46 | -------------------------------------------------------------------------------- /logs/space.04_r2.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.591 34.130 6.128 0.973 0.424 4 | 04 0.622 84.333 12.880 0.540 0.733 5 | 05 0.310 26.765 9.404 0.999 0.184 6 | 06 0.659 21.773 3.648 0.971 0.498 7 | 07 0.706 16.788 3.358 0.977 0.553 8 | 08 0.761 23.858 3.926 0.975 0.624 9 | 09 0.317 14.205 2.482 0.792 0.198 10 | 10 0.501 24.525 6.800 0.996 0.335 11 | 11 0.587 25.132 2.579 0.890 0.437 12 | 12 0.740 18.173 3.462 0.980 0.594 13 | 13 0.773 28.228 2.895 0.904 0.675 14 | 15 0.732 18.330 1.988 0.824 0.658 15 | 17 0.770 65.879 4.014 0.860 0.698 16 | 18 0.803 14.055 1.383 0.914 0.717 17 | 19 0.176 98.818 29.962 0.312 0.123 18 | 20 0.682 115.046 13.574 0.665 0.700 19 | 21 0.810 17.805 2.101 0.871 0.756 20 | 22 0.257 46.094 7.578 0.167 0.552 21 | 23 0.498 93.272 9.245 0.480 0.517 22 | 25 0.446 95.212 8.586 0.316 0.760 23 | 26 0.674 22.000 2.622 0.642 0.710 24 | 28 0.802 23.533 1.848 0.883 0.735 25 | 29 0.691 44.474 5.349 0.755 0.638 26 | 30 0.353 30.160 6.347 0.955 0.217 27 | 31 0.509 32.555 4.531 0.949 0.348 28 | 32 0.503 69.424 11.587 0.495 0.511 29 | 33 0.503 24.719 3.747 0.903 0.349 30 | 34 0.658 12.220 2.082 0.875 0.527 31 | 35 0.651 15.522 4.040 0.968 0.491 32 | 36 0.823 12.457 1.638 0.808 0.839 33 | 37 0.014 64.716 20.741 0.008 0.088 34 | 39 0.373 31.661 4.681 0.457 0.315 35 | 40 0.226 40.522 8.964 0.912 0.129 36 | 41 0.118 49.747 12.669 0.814 0.064 37 | 42 0.397 67.401 19.329 0.455 0.352 38 | 43 0.651 20.829 4.134 0.982 0.487 39 | 44 0.000 83.596 67.538 0.000 0.000 40 | 45 0.236 63.529 12.354 0.342 0.181 41 | DM average 0.524284886324 +/- 0.230412656421 42 | HD average 41.8812432183 +/- 28.3667430669 43 | ASSD average 8.68930024832 +/- 11.3973472322 44 | Prec. average 0.726516382675 +/- 0.286012038286 45 | Rec. average 0.466180255938 +/- 0.228976133204 46 | -------------------------------------------------------------------------------- /logs/origeval.iso1.original.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.668 31.486 5.645 0.966 0.510 4 | 04 0.728 62.950 5.647 0.713 0.743 5 | 05 0.287 30.641 10.689 0.999 0.168 6 | 06 0.729 19.473 3.091 0.946 0.593 7 | 07 0.838 17.141 2.212 0.969 0.738 8 | 08 0.716 22.416 4.450 0.984 0.563 9 | 09 0.515 76.649 9.568 0.390 0.760 10 | 10 0.542 37.211 7.714 0.992 0.373 11 | 11 0.705 24.133 2.275 0.877 0.589 12 | 12 0.802 17.496 2.921 0.966 0.685 13 | 13 0.789 24.868 2.788 0.928 0.687 14 | 15 0.786 13.212 1.884 0.781 0.791 15 | 17 0.808 17.576 1.813 0.861 0.761 16 | 18 0.805 14.891 2.000 0.797 0.812 17 | 19 0.437 73.614 10.717 0.307 0.753 18 | 20 0.841 8.259 1.193 0.795 0.893 19 | 21 0.846 15.880 1.424 0.896 0.801 20 | 22 0.341 31.825 6.242 0.239 0.598 21 | 23 0.498 95.386 13.607 0.438 0.578 22 | 25 0.554 31.868 4.537 0.459 0.701 23 | 26 0.714 20.417 1.931 0.636 0.813 24 | 28 0.831 27.273 2.034 0.819 0.843 25 | 29 0.745 38.292 3.221 0.801 0.695 26 | 30 0.455 25.080 5.204 0.966 0.297 27 | 31 0.783 12.087 1.345 0.827 0.744 28 | 32 0.506 73.119 12.689 0.417 0.645 29 | 33 0.523 45.475 5.987 0.732 0.407 30 | 34 0.571 63.493 10.226 0.455 0.766 31 | 35 0.717 15.020 3.478 0.958 0.573 32 | 36 0.832 11.113 1.363 0.789 0.880 33 | 37 0.000 63.763 33.096 0.000 0.000 34 | 39 0.522 60.653 4.929 0.426 0.676 35 | 40 0.277 44.674 8.177 0.972 0.162 36 | 41 0.059 60.469 26.983 0.480 0.032 37 | 42 0.599 14.817 2.261 0.872 0.456 38 | 43 0.669 69.214 6.711 0.928 0.523 39 | 44 0.411 22.051 2.847 0.933 0.264 40 | 45 0.393 66.475 9.312 0.560 0.303 41 | DM average 0.601153339218 +/- 0.21263285666 42 | HD average 36.8541878554 +/- 23.1145187831 43 | ASSD average 6.37404038079 +/- 6.56319106052 44 | Prec. average 0.733451939504 +/- 0.252498775587 45 | Rec. average 0.583596663727 +/- 0.233176429312 46 | -------------------------------------------------------------------------------- /logs/space.08.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.579 34.565 6.316 0.980 0.411 4 | 04 0.594 83.688 13.832 0.489 0.757 5 | 05 0.316 36.122 10.191 0.999 0.188 6 | 06 0.672 17.594 3.474 0.977 0.512 7 | 07 0.790 15.416 2.445 0.957 0.672 8 | 08 0.763 24.127 3.948 0.973 0.628 9 | 09 0.118 75.330 11.973 0.583 0.066 10 | 10 0.530 23.894 6.501 0.994 0.361 11 | 11 0.506 46.304 6.115 0.973 0.342 12 | 12 0.732 17.558 3.587 0.983 0.583 13 | 13 0.791 27.474 2.791 0.895 0.708 14 | 15 0.769 18.291 1.677 0.842 0.708 15 | 17 0.790 49.948 3.251 0.847 0.740 16 | 18 0.778 15.913 1.691 0.943 0.662 17 | 19 0.000 123.165 98.647 0.000 0.000 18 | 20 0.661 113.573 19.840 0.622 0.704 19 | 21 0.806 16.729 2.163 0.881 0.743 20 | 22 0.240 30.577 7.174 0.171 0.405 21 | 23 0.556 95.495 10.552 0.515 0.605 22 | 25 0.441 94.891 8.168 0.310 0.762 23 | 26 0.648 27.665 3.219 0.568 0.754 24 | 28 0.801 26.771 2.069 0.888 0.729 25 | 29 0.675 61.932 8.851 0.718 0.638 26 | 30 0.365 32.139 6.439 0.971 0.225 27 | 31 0.463 33.692 5.505 0.944 0.307 28 | 32 0.455 66.628 12.703 0.446 0.464 29 | 33 0.553 22.416 3.578 0.913 0.396 30 | 34 0.660 11.130 2.071 0.893 0.524 31 | 35 0.690 15.100 3.732 0.961 0.539 32 | 36 0.814 13.714 1.782 0.795 0.833 33 | 37 0.000 68.686 25.893 0.000 0.000 34 | 39 0.369 58.829 8.826 0.365 0.373 35 | 40 0.199 40.625 9.443 0.902 0.112 36 | 41 0.117 59.375 15.823 0.735 0.063 37 | 42 0.301 67.188 21.466 0.314 0.289 38 | 43 0.682 24.235 4.180 0.948 0.533 39 | 44 0.000 83.414 66.834 0.000 0.000 40 | 45 0.316 30.952 8.325 0.492 0.233 41 | DM average 0.514273572456 +/- 0.250000947191 42 | HD average 44.8721854355 +/- 29.6470974046 43 | ASSD average 11.449298919 +/- 18.1142785613 44 | Prec. average 0.704952446442 +/- 0.308418267326 45 | Rec. average 0.462352030648 +/- 0.249288195111 46 | 47 | -------------------------------------------------------------------------------- /logs/space.08_r2.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.574 35.339 6.445 0.981 0.406 4 | 04 0.586 81.771 14.102 0.482 0.749 5 | 05 0.308 35.966 10.257 1.000 0.182 6 | 06 0.672 21.479 3.579 0.976 0.512 7 | 07 0.780 15.723 2.555 0.960 0.656 8 | 08 0.766 23.362 3.953 0.974 0.631 9 | 09 0.145 25.318 9.004 0.408 0.088 10 | 10 0.526 23.684 6.542 0.995 0.358 11 | 11 0.518 46.270 6.027 0.973 0.353 12 | 12 0.737 17.087 3.451 0.981 0.591 13 | 13 0.792 26.925 2.799 0.900 0.706 14 | 15 0.767 19.877 1.672 0.846 0.702 15 | 17 0.782 50.037 3.400 0.834 0.737 16 | 18 0.777 15.133 1.705 0.941 0.661 17 | 19 0.000 123.410 98.722 0.000 0.000 18 | 20 0.643 114.320 22.685 0.586 0.712 19 | 21 0.815 17.553 2.027 0.891 0.751 20 | 22 0.247 30.577 6.954 0.175 0.418 21 | 23 0.528 95.997 12.550 0.500 0.559 22 | 25 0.438 94.656 9.588 0.304 0.781 23 | 26 0.651 23.925 3.144 0.576 0.748 24 | 28 0.796 27.471 2.138 0.885 0.723 25 | 29 0.676 61.818 8.692 0.727 0.631 26 | 30 0.356 30.735 6.800 0.974 0.218 27 | 31 0.448 33.720 5.535 0.955 0.292 28 | 32 0.456 67.223 12.856 0.477 0.437 29 | 33 0.545 22.541 3.641 0.911 0.389 30 | 34 0.683 11.000 1.971 0.888 0.554 31 | 35 0.692 16.209 3.724 0.958 0.542 32 | 36 0.817 14.099 1.744 0.800 0.833 33 | 37 0.000 69.183 26.020 0.000 0.000 34 | 39 0.341 59.096 9.385 0.345 0.337 35 | 40 0.206 40.522 9.325 0.921 0.116 36 | 41 0.117 58.727 16.561 0.710 0.064 37 | 42 0.308 67.206 21.553 0.329 0.289 38 | 43 0.671 24.713 4.424 0.945 0.520 39 | 44 0.000 83.327 67.140 0.000 0.000 40 | 45 0.293 30.360 8.049 0.504 0.207 41 | DM average 0.511998539238 +/- 0.249378135159 42 | HD average 43.5883402749 +/- 29.3310528752 43 | ASSD average 11.597865466 +/- 18.1935600386 44 | Prec. average 0.700354988111 +/- 0.311967341888 45 | Rec. average 0.459315295944 +/- 0.249245810722 46 | -------------------------------------------------------------------------------- /logs/space.iso1_r2.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.684 31.418 5.584 0.963 0.530 4 | 04 0.731 63.810 6.020 0.723 0.740 5 | 05 0.278 32.520 10.890 0.998 0.161 6 | 06 0.729 19.218 3.082 0.946 0.593 7 | 07 0.830 16.535 2.293 0.969 0.726 8 | 08 0.725 22.635 4.324 0.990 0.572 9 | 09 0.505 76.858 9.255 0.380 0.755 10 | 10 0.536 34.620 7.743 0.989 0.368 11 | 11 0.692 22.651 2.069 0.889 0.566 12 | 12 0.800 18.336 2.899 0.956 0.687 13 | 13 0.788 25.291 2.790 0.923 0.688 14 | 15 0.786 14.298 1.833 0.780 0.792 15 | 17 0.801 18.385 1.989 0.860 0.750 16 | 18 0.813 15.280 1.940 0.804 0.822 17 | 19 0.458 73.795 10.503 0.331 0.744 18 | 20 0.849 8.440 1.084 0.797 0.910 19 | 21 0.848 15.778 1.405 0.899 0.802 20 | 22 0.352 25.132 6.026 0.250 0.598 21 | 23 0.452 95.228 15.185 0.400 0.519 22 | 25 0.550 32.939 4.635 0.457 0.692 23 | 26 0.723 20.924 1.815 0.656 0.806 24 | 28 0.833 27.273 2.001 0.831 0.835 25 | 29 0.740 39.570 3.345 0.791 0.694 26 | 30 0.448 24.274 4.974 0.951 0.293 27 | 31 0.789 12.220 1.268 0.830 0.752 28 | 32 0.503 72.643 12.857 0.413 0.644 29 | 33 0.507 45.118 6.302 0.708 0.396 30 | 34 0.584 63.493 10.048 0.468 0.778 31 | 35 0.707 15.728 3.602 0.963 0.559 32 | 36 0.839 10.781 1.289 0.799 0.883 33 | 37 0.000 64.173 32.875 0.000 0.000 34 | 39 0.551 22.740 3.037 0.480 0.648 35 | 40 0.268 44.881 8.375 0.963 0.156 36 | 41 0.064 59.744 24.511 0.512 0.034 37 | 42 0.589 14.817 2.307 0.870 0.445 38 | 43 0.664 68.749 6.786 0.926 0.517 39 | 44 0.469 21.858 2.514 0.907 0.316 40 | 45 0.392 66.015 10.288 0.558 0.302 41 | DM average 0.602093755268 +/- 0.212685010561 42 | HD average 35.7412207525 +/- 22.8521182807 43 | ASSD average 6.30904246899 +/- 6.43961207099 44 | Prec. average 0.73502271977 +/- 0.248950907434 45 | Rec. average 0.580859324864 +/- 0.232636696213 46 | 47 | -------------------------------------------------------------------------------- /logs/origeval.08.original.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.579 34.565 6.316 0.980 0.411 4 | 04 0.594 83.688 13.832 0.489 0.757 5 | 05 0.316 36.122 10.191 0.999 0.188 6 | 06 0.672 17.594 3.474 0.977 0.512 7 | 07 0.790 15.416 2.445 0.957 0.672 8 | 08 0.763 24.127 3.948 0.973 0.628 9 | 09 0.118 75.330 11.973 0.583 0.066 10 | 10 0.530 23.894 6.501 0.994 0.361 11 | 11 0.506 46.304 6.115 0.973 0.342 12 | 12 0.732 17.558 3.587 0.983 0.583 13 | 13 0.791 27.474 2.791 0.895 0.708 14 | 15 0.769 18.291 1.677 0.842 0.708 15 | 17 0.790 49.948 3.251 0.847 0.740 16 | 18 0.778 15.913 1.691 0.943 0.662 17 | 19 0.000 123.165 98.647 0.000 0.000 18 | 20 0.661 113.573 19.840 0.622 0.704 19 | 21 0.806 16.729 2.163 0.881 0.743 20 | 22 0.240 30.577 7.174 0.171 0.405 21 | 23 0.556 95.495 10.552 0.515 0.605 22 | 25 0.441 94.891 8.168 0.310 0.762 23 | 26 0.648 27.665 3.219 0.568 0.754 24 | 28 0.801 26.771 2.069 0.888 0.729 25 | 29 0.675 61.932 8.851 0.718 0.638 26 | 30 0.365 32.139 6.439 0.971 0.225 27 | 31 0.463 33.692 5.505 0.944 0.307 28 | 32 0.455 66.628 12.703 0.446 0.464 29 | 33 0.553 22.416 3.578 0.913 0.396 30 | 34 0.660 11.130 2.071 0.893 0.524 31 | 35 0.690 15.100 3.732 0.961 0.539 32 | 36 0.814 13.714 1.782 0.795 0.833 33 | 37 0.000 68.686 25.893 0.000 0.000 34 | 39 0.369 58.829 8.826 0.365 0.373 35 | 40 0.199 40.625 9.443 0.902 0.112 36 | 41 0.117 59.375 15.823 0.735 0.063 37 | 42 0.301 67.188 21.466 0.314 0.289 38 | 43 0.682 24.235 4.180 0.948 0.533 39 | 44 0.000 83.414 66.834 0.000 0.000 40 | 45 0.316 30.952 8.325 0.492 0.233 41 | DM average 0.514273572456 +/- 0.250000947191 42 | HD average 44.8721854355 +/- 29.6470974046 43 | ASSD average 11.449298919 +/- 18.1142785613 44 | Prec. average 0.704952446442 +/- 0.308418267326 45 | Rec. average 0.462352030648 +/- 0.249288195111 46 | 47 | -------------------------------------------------------------------------------- /pop_stdsegmentations.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ##### 4 | # Tranform all segmentation binary images to basesequence space. 5 | ##### 6 | 7 | ## Changelog 8 | # 2013-11-15 created 9 | 10 | # include shared information 11 | source $(dirname $0)/include.sh 12 | 13 | # main code 14 | tmpdir=`mktemp -d` 15 | for i in "${images[@]}"; do 16 | log 2 "Tranforming expert segmentation of case ${i} to std space" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 17 | 18 | # continue if target file already exists 19 | if [ -f "${stdsegmentations}/${i}.${imgfiletype}" ]; then 20 | continue 21 | fi 22 | 23 | # correct sfrom / header of sequencesegmentations in place 24 | runcond "${scripts}/pass_header.py ${sequencesegmentations}/${i}.${imgfiletype} ${sequencespace}/${i}/${basesequence}.${imgfiletype}" 25 | 26 | #log 2 "Unpacking original mask image to .nii format" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 27 | runcond "medpy_convert.py ${sequencesegmentations}/${i}.${imgfiletype} ${tmpdir}/${i}.nii" 28 | 29 | #log 2 "Create and run SPM Normalize Write / Warp step" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 30 | runcond "${scripts}/make_spm_normalize_write_mask.py ${tmpdir}/warp.m ${stdspace}/${i}/${basesequence}.mat ${tmpdir}/${i}.nii" 31 | /usr/local/software/matlabR2014a/bin/matlab -nodisplay -nosplash -nodesktop -r "addpath '${tmpdir}'; warp;" > ${tmpdir}/log #/dev/null 32 | 33 | #log 2 "Move created mask to the target directory" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 34 | runcond "medpy_convert.py ${tmpdir}/w${i}.nii ${stdsegmentations}/${i}.${imgfiletype}" 35 | 36 | #log 2 "Clean created mask" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 37 | runcond "${scripts}/clean.py ${stdsegmentations}/${i}.${imgfiletype}" 38 | 39 | emptydircond ${tmpdir} 40 | done 41 | rmdircond ${tmpdir} 42 | log 2 "Done." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 43 | -------------------------------------------------------------------------------- /scripts/train_rdf.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Train a decision forest on a training set. 5 | arg1: the training set file (.features.npy) 6 | arg2: the decision forest target file 7 | """ 8 | 9 | import sys 10 | import pickle 11 | import numpy 12 | 13 | from sklearn.ensemble.forest import ExtraTreesClassifier 14 | 15 | # constants 16 | n_jobs = 6 17 | 18 | def main(): 19 | # catch parameters 20 | training_set_features = sys.argv[1] 21 | training_set_classes = training_set_features.replace('features', 'classes') 22 | forest_file = sys.argv[2] 23 | 24 | # loading training features 25 | with open(training_set_features, 'r') as f: 26 | training_feature_vector = numpy.load(f) 27 | if 1 == training_feature_vector.ndim: 28 | training_feature_vector = numpy.expand_dims(training_feature_vector, -1) 29 | with open(training_set_classes , 'r') as f: 30 | training_class_vector = numpy.load(f) 31 | 32 | 33 | # prepare and train the decision forest 34 | forest = ExtraTreesClassifier(n_estimators=200, 35 | criterion = 'entropy', 36 | max_features = None, 37 | min_samples_split = 2, 38 | min_samples_leaf = 1, 39 | max_depth = 500, 40 | bootstrap = True, 41 | oob_score = False, 42 | random_state=0, 43 | n_jobs=n_jobs, 44 | compute_importances=True) 45 | forest.fit(training_feature_vector, training_class_vector) 46 | 47 | # saving the decision forest 48 | with open(forest_file, 'wb') as f: 49 | pickle.dump(forest, f) 50 | 51 | if __name__ == "__main__": 52 | main() 53 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # workflow files # 2 | ################## 3 | todo.txt 4 | *.csv 5 | 6 | # Local files to exclude # 7 | ########################## 8 | 01t2space/show.sh 9 | 06stdspace/show.sh 10 | 11 | # Pickle Python classes and NumpPy arrays # 12 | ########################################### 13 | *.pkl 14 | *.npy 15 | 16 | # Images # 17 | ########## 18 | *.dcm 19 | *.nii.gz 20 | *.nii 21 | *.mha 22 | *.mhd 23 | *.raw 24 | 25 | # Only locally used, temporary .py scripts. # 26 | ############################################# 27 | _*.py 28 | !__init__.py 29 | 30 | # Compiled source # 31 | ################### 32 | *.com 33 | *.class 34 | *.dll 35 | *.exe 36 | *.o 37 | *.so 38 | *.pyc 39 | *.pyo 40 | 41 | # Packages # 42 | ############ 43 | # it's better to unpack these files and commit the raw source 44 | # git has its own built in compression methods 45 | *.7z 46 | *.dmg 47 | *.gz 48 | *.iso 49 | *.jar 50 | *.rar 51 | *.tar 52 | *.zip 53 | 54 | # Logs and databases # 55 | ###################### 56 | *.log 57 | *.sql 58 | *.sqlite 59 | 60 | # OS generated files # 61 | ###################### 62 | .DS_Store* 63 | ehthumbs.db 64 | Icon? 65 | Thumbs.db 66 | *~ 67 | 68 | # Eclipse and PyDev project files # 69 | ################################### 70 | .project 71 | .pydevproject 72 | .settings/ 73 | 74 | # Suggestions by GitHub for Python projects # 75 | ############################################# 76 | # Packages 77 | *.egg 78 | *.egg-info 79 | dist 80 | build 81 | eggs 82 | parts 83 | var 84 | sdist 85 | develop-eggs 86 | .installed.cfg 87 | 88 | # Installer logs 89 | pip-log.txt 90 | 91 | # Unit test / coverage reports 92 | .coverage 93 | .tox 94 | 95 | #Translations 96 | *.mo 97 | 98 | #Mr Developer 99 | .mr.developer.cfg 100 | -------------------------------------------------------------------------------- /logs/space.iso3.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.646 34.032 6.463 0.973 0.484 4 | 04 0.699 11.944 2.789 0.722 0.676 5 | 05 0.360 32.748 11.086 1.000 0.219 6 | 06 0.780 18.198 2.769 0.871 0.707 7 | 07 0.871 12.537 1.437 0.924 0.823 8 | 08 0.723 21.596 5.148 0.979 0.573 9 | 09 0.603 73.442 6.395 0.571 0.638 10 | 10 0.515 28.560 7.565 0.987 0.348 11 | 11 0.533 28.361 3.803 0.922 0.375 12 | 12 0.818 18.465 2.444 0.966 0.710 13 | 13 0.784 23.959 2.909 0.856 0.723 14 | 15 0.772 17.507 2.012 0.807 0.739 15 | 17 0.779 16.621 2.738 0.729 0.838 16 | 18 0.782 16.500 1.898 0.851 0.724 17 | 19 0.651 16.854 2.571 0.652 0.650 18 | 20 0.812 7.073 1.230 0.831 0.793 19 | 21 0.823 17.759 1.598 0.936 0.734 20 | 22 0.307 19.441 5.885 0.240 0.426 21 | 23 0.556 94.838 11.834 0.542 0.571 22 | 25 0.567 45.412 4.263 0.474 0.707 23 | 26 0.659 20.491 2.681 0.553 0.814 24 | 28 0.807 25.321 2.309 0.819 0.796 25 | 29 0.695 43.189 3.912 0.806 0.611 26 | 30 0.681 18.886 4.071 0.975 0.524 27 | 31 0.573 20.387 3.022 0.813 0.442 28 | 32 0.661 61.014 4.740 0.677 0.647 29 | 33 0.704 18.081 2.349 0.918 0.571 30 | 34 0.757 12.103 1.680 0.840 0.689 31 | 35 0.823 16.598 2.302 0.952 0.725 32 | 36 0.823 11.680 1.298 0.822 0.824 33 | 37 0.000 56.063 45.936 0.000 0.000 34 | 39 0.467 20.387 2.587 0.842 0.323 35 | 40 0.352 44.456 8.581 0.983 0.215 36 | 41 0.100 56.151 12.588 0.962 0.053 37 | 42 0.471 54.012 11.609 0.561 0.406 38 | 43 0.731 19.734 3.311 0.965 0.588 39 | 44 0.000 inf inf 0.000 0.000 40 | 45 0.426 36.670 8.114 0.345 0.557 41 | WARNING: Average values only computed on 37 of 38 cases! 42 | DM average 0.62466211469 +/- 0.201126477243 43 | HD average 29.4884624082 +/- 19.2198421134 44 | ASSD average 5.61968303221 +/- 7.42113442851 45 | Prec. average 0.774769168868 +/- 0.22736950741 46 | Rec. average 0.574119163991 +/- 0.211285805498 47 | -------------------------------------------------------------------------------- /logs/space.iso4.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.658 31.147 6.250 0.949 0.503 4 | 04 0.657 11.918 3.485 0.680 0.635 5 | 05 0.332 30.598 11.660 0.999 0.199 6 | 06 0.752 17.692 3.063 0.886 0.653 7 | 07 0.859 12.054 1.577 0.931 0.797 8 | 08 0.740 27.188 5.132 0.959 0.602 9 | 09 0.106 68.236 14.304 0.110 0.102 10 | 10 0.473 34.281 8.128 0.994 0.310 11 | 11 0.540 25.471 3.081 0.920 0.382 12 | 12 0.784 20.459 3.036 0.964 0.660 13 | 13 0.751 22.015 3.362 0.769 0.735 14 | 15 0.777 18.341 1.843 0.815 0.742 15 | 17 0.780 49.887 3.946 0.812 0.750 16 | 18 0.754 11.000 1.838 0.865 0.668 17 | 19 0.567 15.353 2.477 0.690 0.481 18 | 20 0.759 8.790 1.619 0.817 0.709 19 | 21 0.818 17.703 1.779 0.892 0.756 20 | 22 0.350 35.302 5.884 0.257 0.551 21 | 23 0.466 18.684 4.284 0.434 0.503 22 | 25 0.502 48.213 5.861 0.478 0.529 23 | 26 0.657 21.793 2.406 0.614 0.706 24 | 28 0.785 28.160 2.745 0.804 0.766 25 | 29 0.656 42.302 4.025 0.821 0.547 26 | 30 0.291 35.541 8.131 0.997 0.170 27 | 31 0.440 31.220 5.331 0.840 0.298 28 | 32 0.674 61.232 6.552 0.597 0.774 29 | 33 0.753 21.683 2.035 0.821 0.694 30 | 34 0.739 11.867 1.594 0.830 0.667 31 | 35 0.784 17.105 2.946 0.929 0.677 32 | 36 0.792 13.097 1.728 0.774 0.811 33 | 37 0.000 59.119 46.788 0.000 0.000 34 | 39 0.542 18.489 2.260 0.689 0.447 35 | 40 0.224 52.453 11.539 0.985 0.126 36 | 41 0.183 45.574 11.459 0.961 0.101 37 | 42 0.000 81.555 34.974 0.000 0.000 38 | 43 0.714 19.237 3.750 0.941 0.575 39 | 44 0.000 inf inf 0.000 0.000 40 | 45 0.477 29.338 6.212 0.467 0.488 41 | WARNING: Average values only computed on 37 of 38 cases! 42 | DM average 0.571155368097 +/- 0.236867840685 43 | HD average 30.1107125206 +/- 17.4310462579 44 | ASSD average 6.67787748103 +/- 8.87978623546 45 | Prec. average 0.737491079628 +/- 0.270862372556 46 | Rec. average 0.516627998177 +/- 0.238963696663 47 | -------------------------------------------------------------------------------- /logs/space.iso4_r2.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.664 33.280 6.169 0.948 0.511 4 | 04 0.663 11.918 3.130 0.668 0.658 5 | 05 0.338 30.203 11.144 0.999 0.204 6 | 06 0.757 17.913 3.005 0.884 0.662 7 | 07 0.855 10.865 1.623 0.936 0.787 8 | 08 0.743 27.318 5.093 0.960 0.606 9 | 09 0.073 31.469 12.805 0.090 0.061 10 | 10 0.487 29.679 7.884 0.993 0.323 11 | 11 0.509 28.907 4.027 0.927 0.351 12 | 12 0.786 23.007 2.993 0.963 0.663 13 | 13 0.758 22.015 3.276 0.783 0.735 14 | 15 0.782 19.560 1.831 0.801 0.763 15 | 17 0.767 49.887 4.113 0.799 0.737 16 | 18 0.762 11.082 1.872 0.840 0.697 17 | 19 0.555 12.910 2.435 0.717 0.453 18 | 20 0.758 8.790 1.615 0.830 0.697 19 | 21 0.824 17.703 1.655 0.890 0.767 20 | 22 0.373 31.754 5.191 0.276 0.574 21 | 23 0.503 18.446 3.747 0.501 0.506 22 | 25 0.485 73.888 8.790 0.489 0.481 23 | 26 0.660 21.793 2.399 0.626 0.697 24 | 28 0.783 28.395 2.802 0.796 0.771 25 | 29 0.666 40.540 3.824 0.831 0.556 26 | 30 0.291 35.514 8.114 0.998 0.170 27 | 31 0.433 31.220 5.491 0.830 0.293 28 | 32 0.690 64.830 6.358 0.618 0.780 29 | 33 0.741 21.356 2.136 0.819 0.676 30 | 34 0.724 11.867 1.685 0.833 0.641 31 | 35 0.786 17.047 2.935 0.930 0.681 32 | 36 0.800 12.551 1.613 0.778 0.822 33 | 37 0.000 59.119 47.858 0.000 0.000 34 | 39 0.544 17.662 2.256 0.688 0.449 35 | 40 0.213 49.986 11.348 0.990 0.119 36 | 41 0.187 46.830 11.331 0.969 0.103 37 | 42 0.000 79.226 35.987 0.000 0.000 38 | 43 0.717 19.237 3.605 0.931 0.583 39 | 44 0.000 inf inf 0.000 0.000 40 | 45 0.487 29.720 6.396 0.477 0.497 41 | WARNING: Average values only computed on 37 of 38 cases! 42 | DM average 0.571877259594 +/- 0.23863135774 43 | HD average 29.661892183 +/- 17.4844473944 44 | ASSD average 6.71719107366 +/- 9.06492118543 45 | Prec. average 0.740751744349 +/- 0.2684175755 46 | Rec. average 0.515464650859 +/- 0.242624456199 47 | -------------------------------------------------------------------------------- /logs/origeval.iso3.original.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.646 34.032 6.463 0.973 0.484 4 | 04 0.699 11.944 2.789 0.722 0.676 5 | 05 0.360 32.748 11.086 1.000 0.219 6 | 06 0.780 18.198 2.769 0.871 0.707 7 | 07 0.871 12.537 1.437 0.924 0.823 8 | 08 0.723 21.596 5.148 0.979 0.573 9 | 09 0.603 73.442 6.395 0.571 0.638 10 | 10 0.515 28.560 7.565 0.987 0.348 11 | 11 0.533 28.361 3.803 0.922 0.375 12 | 12 0.818 18.465 2.444 0.966 0.710 13 | 13 0.784 23.959 2.909 0.856 0.723 14 | 15 0.772 17.507 2.012 0.807 0.739 15 | 17 0.779 16.621 2.738 0.729 0.838 16 | 18 0.782 16.500 1.898 0.851 0.724 17 | 19 0.651 16.854 2.571 0.652 0.650 18 | 20 0.812 7.073 1.230 0.831 0.793 19 | 21 0.823 17.759 1.598 0.936 0.734 20 | 22 0.307 19.441 5.885 0.240 0.426 21 | 23 0.556 94.838 11.834 0.542 0.571 22 | 25 0.567 45.412 4.263 0.474 0.707 23 | 26 0.659 20.491 2.681 0.553 0.814 24 | 28 0.807 25.321 2.309 0.819 0.796 25 | 29 0.695 43.189 3.912 0.806 0.611 26 | 30 0.681 18.886 4.071 0.975 0.524 27 | 31 0.573 20.387 3.022 0.813 0.442 28 | 32 0.661 61.014 4.740 0.677 0.647 29 | 33 0.704 18.081 2.349 0.918 0.571 30 | 34 0.757 12.103 1.680 0.840 0.689 31 | 35 0.823 16.598 2.302 0.952 0.725 32 | 36 0.823 11.680 1.298 0.822 0.824 33 | 37 0.000 56.063 45.936 0.000 0.000 34 | 39 0.467 20.387 2.587 0.842 0.323 35 | 40 0.352 44.456 8.581 0.983 0.215 36 | 41 0.100 56.151 12.588 0.962 0.053 37 | 42 0.471 54.012 11.609 0.561 0.406 38 | 43 0.731 19.734 3.311 0.965 0.588 39 | 44 0.000 inf inf 0.000 0.000 40 | 45 0.426 36.670 8.114 0.345 0.557 41 | WARNING: Average values only computed on 37 of 38 cases! 42 | DM average 0.62466211469 +/- 0.201126477243 43 | HD average 29.4884624082 +/- 19.2198421134 44 | ASSD average 5.61968303221 +/- 7.42113442851 45 | Prec. average 0.774769168868 +/- 0.22736950741 46 | Rec. average 0.574119163991 +/- 0.211285805498 47 | -------------------------------------------------------------------------------- /logs/space.iso3_r2.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.636 33.110 6.539 0.964 0.475 4 | 04 0.708 12.261 2.747 0.744 0.675 5 | 05 0.353 32.665 11.119 1.000 0.214 6 | 06 0.778 18.424 2.721 0.886 0.694 7 | 07 0.868 12.537 1.555 0.916 0.825 8 | 08 0.713 23.472 5.452 0.980 0.560 9 | 09 0.625 11.986 1.828 0.622 0.628 10 | 10 0.504 28.441 7.816 0.992 0.338 11 | 11 0.537 29.587 4.025 0.911 0.381 12 | 12 0.819 22.673 2.634 0.967 0.711 13 | 13 0.784 23.620 2.950 0.848 0.729 14 | 15 0.779 17.507 1.959 0.816 0.745 15 | 17 0.779 16.604 2.724 0.729 0.836 16 | 18 0.781 11.119 1.852 0.852 0.722 17 | 19 0.654 17.456 2.483 0.675 0.634 18 | 20 0.819 7.623 1.104 0.848 0.793 19 | 21 0.814 16.886 1.610 0.943 0.716 20 | 22 0.290 23.749 6.336 0.221 0.422 21 | 23 0.578 94.838 10.701 0.547 0.612 22 | 25 0.570 26.378 3.411 0.481 0.700 23 | 26 0.652 20.153 2.723 0.538 0.826 24 | 28 0.811 27.752 2.295 0.818 0.805 25 | 29 0.693 43.189 3.983 0.822 0.599 26 | 30 0.683 18.886 3.991 0.971 0.527 27 | 31 0.576 20.369 3.527 0.809 0.447 28 | 32 0.650 60.251 5.247 0.675 0.628 29 | 33 0.670 17.720 2.612 0.907 0.532 30 | 34 0.767 12.103 1.587 0.834 0.710 31 | 35 0.824 16.500 2.328 0.953 0.727 32 | 36 0.826 11.680 1.305 0.830 0.823 33 | 37 0.000 56.293 45.854 0.000 0.000 34 | 39 0.563 20.327 2.154 0.801 0.435 35 | 40 0.349 44.311 8.835 0.985 0.212 36 | 41 0.073 57.346 13.386 0.954 0.038 37 | 42 0.417 80.011 15.969 0.444 0.393 38 | 43 0.726 18.192 3.324 0.971 0.580 39 | 44 0.000 inf inf 0.000 0.000 40 | 45 0.421 35.336 7.893 0.342 0.547 41 | WARNING: Average values only computed on 37 of 38 cases! 42 | DM average 0.624151574558 +/- 0.203990616509 43 | HD average 28.1447525624 +/- 19.2341048861 44 | ASSD average 5.63728956185 +/- 7.567117849 45 | Prec. average 0.772822824286 +/- 0.23075294728 46 | Rec. average 0.573986105582 +/- 0.210693863058 47 | 48 | -------------------------------------------------------------------------------- /logs/space.iso5.orig.log: -------------------------------------------------------------------------------- 1 | Metrics: 2 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 3 | 03 0.586 35.869 7.016 0.966 0.420 4 | 04 0.647 13.617 2.729 0.700 0.601 5 | 05 0.287 35.597 12.474 0.999 0.168 6 | 06 0.717 21.976 3.624 0.910 0.591 7 | 07 0.831 12.505 2.179 0.920 0.758 8 | 08 0.714 33.675 6.020 0.954 0.570 9 | 09 0.057 29.886 7.213 0.629 0.030 10 | 10 0.298 35.390 10.893 0.998 0.175 11 | 11 0.497 24.547 3.802 0.931 0.339 12 | 12 0.732 16.203 3.783 0.979 0.584 13 | 13 0.689 21.542 3.928 0.936 0.545 14 | 15 0.758 20.344 1.812 0.852 0.683 15 | 17 0.690 55.275 5.500 0.792 0.612 16 | 18 0.207 46.791 12.694 0.198 0.217 17 | 19 0.477 16.627 3.187 0.562 0.414 18 | 20 0.743 11.164 2.156 0.860 0.654 19 | 21 0.800 18.191 2.036 0.897 0.723 20 | 22 0.136 25.101 7.016 0.199 0.103 21 | 23 0.465 24.896 3.664 0.728 0.341 22 | 25 0.350 74.329 15.721 0.508 0.266 23 | 26 0.668 19.189 2.736 0.570 0.806 24 | 28 0.770 28.395 3.099 0.804 0.738 25 | 29 0.601 41.223 4.518 0.825 0.473 26 | 30 0.059 91.856 19.364 0.963 0.030 27 | 31 0.037 51.082 11.309 0.642 0.019 28 | 32 0.679 19.254 3.585 0.594 0.792 29 | 33 0.690 23.029 2.714 0.785 0.615 30 | 34 0.765 11.000 1.552 0.843 0.700 31 | 35 0.769 17.070 3.204 0.927 0.656 32 | 36 0.769 13.318 1.885 0.826 0.720 33 | 37 0.000 69.065 48.382 0.000 0.000 34 | 39 0.038 27.338 5.451 1.000 0.020 35 | 40 0.337 47.272 9.746 0.987 0.203 36 | 41 0.042 48.631 14.283 0.957 0.022 37 | 42 0.000 109.682 73.736 0.000 0.000 38 | 43 0.600 23.173 5.267 0.934 0.442 39 | 44 0.000 inf inf 0.000 0.000 40 | 45 0.351 26.443 7.277 0.473 0.279 41 | WARNING: Average values only computed on 37 of 38 cases! 42 | DM average 0.482593983346 +/- 0.278564374364 43 | HD average 33.5282338126 +/- 22.2723655048 44 | ASSD average 9.06911010532 +/- 13.4823331604 45 | Prec. average 0.747302911801 +/- 0.271062291089 46 | Rec. average 0.41382559651 +/- 0.2677210248t 47 | 48 | -------------------------------------------------------------------------------- /scripts/equalvs.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | # Checks whether the (equally named) images in two folders have the same voxel spacing 4 | # You can additionally supply a "-i" switch at the end to treat the second folder as flat structure (e.g. the ones containing masks or segmentations) 5 | 6 | import os 7 | import sys 8 | import numpy 9 | from medpy.io import load, save, header 10 | 11 | DEBUG = True 12 | FILE_ENDING = 'nii.gz' 13 | 14 | def main(): 15 | onedir = sys.argv[1] # the first folder containing case folders 16 | twodir = sys.argv[2] # the second folder containing case folders 17 | nocase = (len(sys.argv) > 3 and sys.argv[3] == '-i') 18 | 19 | if DEBUG: print 'INFO: Comparing all cases in folders {} and {}.'.format(onedir, twodir) 20 | 21 | # iterate over first folder and compare voxel spacings with equivalent image in second folder 22 | print "Case\tvs same\tshape same" 23 | for root, dirs, files in os.walk(onedir): 24 | for case in sorted(dirs): 25 | for root, dirs, files in os.walk('{}/{}'.format(onedir, case)): 26 | for file_ in files: 27 | if file_.endswith(FILE_ENDING): 28 | i, hi = load('{}/{}/{}'.format(onedir, case, file_)) 29 | if nocase: 30 | j, hj = load('{}/{}.{}'.format(twodir, case, FILE_ENDING)) 31 | else: 32 | j, hj = load('{}/{}/{}'.format(twodir, case, file_)) 33 | vs_same = numpy.array_equal(header.get_pixel_spacing(hi), header.get_pixel_spacing(hj)) 34 | shape_same = numpy.array_equal(i.shape, j.shape) 35 | print '{}\t{}\t{}'.format(case, vs_same, shape_same) 36 | if not vs_same: 37 | print "\t{} vs {}".format(header.get_pixel_spacing(hi), header.get_pixel_spacing(hj)) 38 | if not shape_same: 39 | print "\t{} vs {}".format(i.shape, j.shape) 40 | print 'Terminated.' 41 | 42 | if __name__ == "__main__": 43 | main() 44 | -------------------------------------------------------------------------------- /scripts/make_spm_normalize_estimate.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | #### 4 | # Creates a Matlab script to register a FLAIR image to the std-space FLAIR template using a lesion mask to mask out pathological areas. 5 | # The method used is: SPM Normalize Estimate 6 | # arg1: the FLAIR image to register to std-space 7 | # arg2: the associated lesion mask (note: must contain zeros in places of pathological tissue) 8 | # arg3: the target matlab script file 9 | #### 10 | 11 | import sys 12 | 13 | def main(): 14 | flairfile = sys.argv[1] 15 | lmask = sys.argv[2] 16 | target = sys.argv[3] 17 | 18 | script = script_template.format(flairfile, lmask, flairfile, lmask) 19 | 20 | with open(target, 'w') as f: 21 | f.write(script) 22 | 23 | script_template = """ 24 | % Script to register the image {} to the std-space, taking into account the lesion mask {}. 25 | 26 | addpath '/home/maier/Applications/spm8' 27 | 28 | matlabbatch{{1}}.spm.spatial.normalise.est.subj(1).source = {{'{},1'}}; 29 | matlabbatch{{1}}.spm.spatial.normalise.est.subj(1).wtsrc = {{'{},1'}}; 30 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.template = {{'/home/maier/Applications/spm8/templates/GG-366-FLAIR-1.0mm.nii,1'}}; 31 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.weight = ''; 32 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.smosrc = 8; 33 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.smoref = 8; 34 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.regtype = 'mni'; 35 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.cutoff = 25; 36 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.nits = 16; 37 | matlabbatch{{1}}.spm.spatial.normalise.est.eoptions.reg = 1; 38 | 39 | spm('defaults', 'FMRI'); 40 | spm_jobman('initcfg'); 41 | spm_jobman('serial', matlabbatch); 42 | 43 | exit; 44 | """ 45 | 46 | if __name__ == "__main__": 47 | main() 48 | -------------------------------------------------------------------------------- /experiments/05flairlesionsegmentation: -------------------------------------------------------------------------------- 1 | Some remarks: 2 | - Keep in mind, that the goal is actually not to find the lesion, but all white matter hyperintensities! 3 | - Large lesions and WMI should be found, smaller ones are rather irrelevant. 4 | - Skull and meninges should rather not be excluded. 5 | 6 | ! Morphological operations, except hole closing, switched off in apply_rdf.py ! 7 | 8 | 1. FLAIR & intensity only performance 9 | @results: logs/eval.pre.flair.int.log 10 | Visual examination: 11 | Horrible. Lesion is encountered to some extend reliably, but there 12 | are huge amounts of false positives all over the brain matter and 13 | especially in the skull and meninges where missed by the skull strip. 14 | Conclusion: 15 | => Like this not suitable at all for masking out the lesions during registration. 16 | 17 | 2. FLAIR & feature combination performance 18 | @results: logs/eval.pre.flair.int_lmg3_lh1111.log 19 | @results: logs/eval.pre.flair.int_[...] 20 | Visual examination: 21 | A92gKwq4 22 | 23 | Conclusion: 24 | => 25 | 26 | 3. Best sampling size for best feature combo from (2) 27 | @results: logs/eval.pre.sampling.Xk.log 28 | Runtimes: 29 | 30 | Visual examination: 31 | 32 | Conclusion: 33 | => 34 | 35 | 4. Add DW as additional sequence 36 | @results: logs/eval.pre.flair_dw.int_[...].log 37 | Visual examination: 38 | 39 | Conclusion: 40 | => 41 | 42 | 5. Intensity normalization (with best of (1)-(4)) 43 | Strategies: 44 | a) disable 45 | b) intensity normalization (Oskar) 46 | c) intensity normalization (Nils) 47 | e) simple percentile (0.5, 99.5) => [0, 1] 48 | 49 | 6. Enable bias correction on best result 50 | Does it increase the results? 51 | Keep the remarks on top of this file in mind! 52 | 53 | 7. Register to std-brain and check visually the results 54 | Should be good in ALL cases! 55 | 56 | 57 | -------------------------------------------------------------------------------- /logs/space.iso3.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Compute overall evaluation 2 | Metrics: 3 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 4 | 03 0.657 35.369 6.457 0.970 0.496 5 | 04 0.769 13.416 2.571 0.773 0.766 6 | 05 0.368 34.073 10.796 0.999 0.225 7 | 06 0.816 19.442 2.846 0.893 0.752 8 | 07 0.882 11.225 1.886 0.908 0.857 9 | 08 0.743 22.450 4.631 0.983 0.597 10 | 09 0.642 76.191 7.075 0.588 0.707 11 | 10 0.528 28.460 6.758 0.987 0.361 12 | 11 0.566 29.547 4.107 0.968 0.400 13 | 12 0.833 17.234 2.422 0.962 0.735 14 | 13 0.817 24.920 2.922 0.866 0.773 15 | 15 0.804 13.748 2.123 0.826 0.784 16 | 17 0.789 16.155 3.161 0.725 0.866 17 | 18 0.853 15.000 1.643 0.905 0.806 18 | 19 0.697 17.234 2.882 0.689 0.705 19 | 20 0.877 8.485 1.469 0.883 0.871 20 | 21 0.834 17.234 2.199 0.925 0.759 21 | 22 0.278 19.209 7.088 0.212 0.403 22 | 23 0.541 96.979 13.470 0.513 0.572 23 | 25 0.602 47.812 4.713 0.494 0.773 24 | 26 0.701 20.125 3.144 0.578 0.890 25 | 28 0.831 26.153 2.657 0.823 0.838 26 | 29 0.731 43.474 4.103 0.849 0.642 27 | 30 0.686 18.000 4.437 0.958 0.534 28 | 31 0.615 19.209 3.183 0.846 0.483 29 | 32 0.657 61.919 5.582 0.651 0.664 30 | 33 0.711 15.297 3.012 0.908 0.585 31 | 34 0.806 12.728 1.823 0.868 0.753 32 | 35 0.842 15.588 2.408 0.955 0.753 33 | 36 0.855 13.748 1.942 0.843 0.867 34 | 37 0.000 55.723 46.268 0.000 0.000 35 | 39 0.464 19.442 3.397 0.836 0.321 36 | 40 0.354 45.497 8.581 0.964 0.217 37 | 41 0.108 53.498 12.660 0.972 0.057 38 | 42 0.485 57.784 11.928 0.575 0.419 39 | 43 0.735 19.209 3.703 0.955 0.597 40 | 44 0.000 inf inf 0.000 0.000 41 | 45 0.431 34.337 7.393 0.340 0.590 42 | WARNING: Average values only computed on 37 of 38 cases! 43 | DM average 0.646191716782 +/- 0.212028335823 44 | HD average 29.6193536278 +/- 19.8526150192 45 | ASSD average 5.87671677221 +/- 7.43814285123 46 | Prec. average 0.783457005151 +/- 0.229708853015 47 | Rec. average 0.605886566218 +/- 0.229212903253 48 | -------------------------------------------------------------------------------- /logs/origeval.iso3.sequence.log: -------------------------------------------------------------------------------- 1 | INFO: Compute overall evaluation 2 | Metrics: 3 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 4 | 03 0.657 35.369 6.457 0.970 0.496 5 | 04 0.769 13.416 2.571 0.773 0.766 6 | 05 0.368 34.073 10.796 0.999 0.225 7 | 06 0.816 19.442 2.846 0.893 0.752 8 | 07 0.882 11.225 1.886 0.908 0.857 9 | 08 0.743 22.450 4.631 0.983 0.597 10 | 09 0.642 76.191 7.075 0.588 0.707 11 | 10 0.528 28.460 6.758 0.987 0.361 12 | 11 0.566 29.547 4.107 0.968 0.400 13 | 12 0.833 17.234 2.422 0.962 0.735 14 | 13 0.817 24.920 2.922 0.866 0.773 15 | 15 0.804 13.748 2.123 0.826 0.784 16 | 17 0.789 16.155 3.161 0.725 0.866 17 | 18 0.853 15.000 1.643 0.905 0.806 18 | 19 0.697 17.234 2.882 0.689 0.705 19 | 20 0.877 8.485 1.469 0.883 0.871 20 | 21 0.834 17.234 2.199 0.925 0.759 21 | 22 0.278 19.209 7.088 0.212 0.403 22 | 23 0.541 96.979 13.470 0.513 0.572 23 | 25 0.602 47.812 4.713 0.494 0.773 24 | 26 0.701 20.125 3.144 0.578 0.890 25 | 28 0.831 26.153 2.657 0.823 0.838 26 | 29 0.731 43.474 4.103 0.849 0.642 27 | 30 0.686 18.000 4.437 0.958 0.534 28 | 31 0.615 19.209 3.183 0.846 0.483 29 | 32 0.657 61.919 5.582 0.651 0.664 30 | 33 0.711 15.297 3.012 0.908 0.585 31 | 34 0.806 12.728 1.823 0.868 0.753 32 | 35 0.842 15.588 2.408 0.955 0.753 33 | 36 0.855 13.748 1.942 0.843 0.867 34 | 37 0.000 55.723 46.268 0.000 0.000 35 | 39 0.464 19.442 3.397 0.836 0.321 36 | 40 0.354 45.497 8.581 0.964 0.217 37 | 41 0.108 53.498 12.660 0.972 0.057 38 | 42 0.485 57.784 11.928 0.575 0.419 39 | 43 0.735 19.209 3.703 0.955 0.597 40 | 44 0.000 inf inf 0.000 0.000 41 | 45 0.431 34.337 7.393 0.340 0.590 42 | WARNING: Average values only computed on 37 of 38 cases! 43 | DM average 0.646191716782 +/- 0.212028335823 44 | HD average 29.6193536278 +/- 19.8526150192 45 | ASSD average 5.87671677221 +/- 7.43814285123 46 | Prec. average 0.783457005151 +/- 0.229708853015 47 | Rec. average 0.605886566218 +/- 0.229212903253 48 | -------------------------------------------------------------------------------- /logs/eval.std.all.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Morphological post-processing 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.560 39.205 7.780 0.973 0.393 9 | 04 0.851 38.197 2.488 0.810 0.895 10 | 05 0.350 26.325 8.582 0.993 0.212 11 | 06 0.696 21.471 4.314 0.985 0.538 12 | 07 0.858 13.928 1.844 0.925 0.800 13 | 08 0.837 26.306 3.074 0.979 0.730 14 | 09 0.767 11.446 1.494 0.803 0.735 15 | 10 0.364 25.318 7.494 0.995 0.222 16 | 11 0.752 18.466 2.067 0.711 0.798 17 | 12 0.656 24.739 4.513 0.984 0.492 18 | 13 0.740 47.518 6.475 0.700 0.785 19 | 15 0.808 13.153 1.807 0.830 0.787 20 | 17 0.804 76.616 6.373 0.842 0.769 21 | 18 0.841 10.677 1.693 0.864 0.818 22 | 19 0.673 19.698 3.195 0.754 0.608 23 | 20 0.848 9.165 1.776 0.778 0.933 24 | 21 0.857 16.340 1.841 0.905 0.814 25 | 22 0.435 38.393 6.880 0.289 0.881 26 | 23 0.633 98.051 10.444 0.607 0.662 27 | 25 0.585 35.143 4.415 0.452 0.829 28 | 26 0.668 76.105 5.330 0.538 0.883 29 | 28 0.830 28.089 2.542 0.847 0.814 30 | 29 0.763 20.833 2.452 0.784 0.743 31 | 30 0.405 91.859 15.258 0.797 0.271 32 | 32 0.504 65.406 9.645 0.549 0.466 33 | 33 0.721 17.000 2.978 0.818 0.645 34 | 34 0.651 15.524 2.749 0.922 0.503 35 | 35 0.680 20.273 4.121 0.967 0.524 36 | 36 0.863 11.790 1.574 0.856 0.870 37 | 37 0.000 78.396 27.054 0.000 0.000 38 | 39 0.337 70.178 13.236 0.304 0.380 39 | 40 0.203 49.254 9.193 0.980 0.113 40 | 41 0.078 76.322 28.959 0.232 0.047 41 | 42 0.755 11.180 2.089 0.870 0.666 42 | 43 0.572 75.053 8.015 0.943 0.410 43 | 44 0.685 9.434 1.472 0.764 0.621 44 | 45 0.517 30.480 5.588 0.825 0.377 45 | DM average 0.625574264751 +/- 0.220054443292 46 | HD average 36.6846132239 +/- 26.1770730338 47 | ASSD average 6.23793989939 +/- 6.21956810091 48 | Prec. average 0.761452807507 +/- 0.236756164065 49 | Rec. average 0.595577567464 +/- 0.254381368504 50 | INFO: Done. 51 | -------------------------------------------------------------------------------- /scripts/niftimodifymetadata.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | """ 4 | Modifies a NifTi file's metadata in place. 5 | arg1: the image to modify 6 | arg2+: the changes to make in order of appearance 7 | qfc=x : set qform_code = x 8 | sfc=x : set sform_code = x 9 | qfc=sfc : set sform_code = qform_code 10 | sfc=qfc : set sform_code = qform_code 11 | qf=dia : set qform = diag(spacing) 12 | sf=dia : set sform = diag(spacing) 13 | qf=sf : set qform = sform 14 | sf=qf : set sform = qform 15 | qf=aff : set qform = affine 16 | sf=aff : set sform = affine 17 | """ 18 | 19 | import sys 20 | 21 | import numpy 22 | 23 | from medpy.io import load, save, header 24 | 25 | def main(): 26 | i, h = load(sys.argv[1]) 27 | 28 | tasks = sys.argv[2:] 29 | 30 | for task in sys.argv[2:]: 31 | s, g = task.split('=') 32 | if g in GETTER: 33 | SETTER[s](h, GETTER[g](h)) 34 | else: 35 | SETTER[s](h, int(g)) 36 | 37 | save(i.copy(), sys.argv[1], h) 38 | 39 | def __set_qform_code(h, v): 40 | h.get_header()['qform_code'] = v 41 | 42 | def __set_sform_code(h, v): 43 | h.get_header()['sform_code'] = v 44 | 45 | def __set_qform(h, v): 46 | h.set_qform(v) 47 | 48 | def __set_sform(h, v): 49 | h.set_sform(v) 50 | 51 | def __get_qform_code(h): 52 | return h.get_header()['qform_code'] 53 | 54 | def __get_sform_code(h): 55 | return h.get_header()['sform_code'] 56 | 57 | def __get_affine(h): 58 | return h.get_affine() 59 | 60 | def __get_qform(h): 61 | return h.get_qform() 62 | 63 | def __get_sform(h): 64 | return h.get_sform() 65 | 66 | def __get_diagonal(h): 67 | return numpy.diag(list(header.get_pixel_spacing(h)) + [1]) 68 | 69 | SETTER = { 70 | 'qfc' : __set_qform_code, 71 | 'sfc' : __set_sform_code, 72 | 'qf' : __set_qform, 73 | 'sf' : __set_sform} 74 | GETTER = { 75 | 'qfc' : __get_qform_code, 76 | 'sfc' : __get_sform_code, 77 | 'aff' : __get_affine, 78 | 'qf' : __get_qform, 79 | 'sf' : __get_sform, 80 | 'dia' : __get_diagonal} 81 | 82 | if __name__ == "__main__": 83 | main() 84 | -------------------------------------------------------------------------------- /pop_stdfeatureimages.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ##### 4 | # Segments the matters from the T2 brain images and creates hemispheric difference version of different smoothing parameters of the images. 5 | ##### 6 | 7 | ## Changelog 8 | # 2013-11-25 removed part to extract hemispheric difference features, as these features are directly computed \wo intermediate image 9 | # 2013-11-14 created 10 | 11 | # include shared information 12 | source $(dirname $0)/include.sh 13 | 14 | # constants 15 | active_sigmas=(0 1) 16 | reference_sigmas=(0 1) 17 | 18 | # main code 19 | tmpdir=`mktemp -d` 20 | 21 | log 2 "Segment brain tissues from T2 images" "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 22 | for i in "${images[@]}"; do 23 | mkdircond ${stdfeatureimages}/${i} 24 | # proceed only if not yet existant (assuming from white probability map to others) 25 | if [ ! -f "${stdfeatureimages}/${i}/tissue_probability_white.${imgfiletype}" ]; then 26 | # convert required images to .nii fromat for SPM to be able to read it 27 | cmd="medpy_convert.py ${stdintensitrangestandardization}/${i}/t2_sag_tse.${imgfiletype} ${tmpdir}/t2.nii" 28 | $cmd 29 | cmd="medpy_convert.py ${stdbrainmasks}/${i}.${imgfiletype} ${tmpdir}/mask.nii" 30 | $cmd 31 | # prepare matlab script 32 | cmd="${scripts}/make_spm_segment.py ${tmpdir}/t2.nii ${tmpdir}/mask.nii ${tmpdir}/segment.m" 33 | $cmd 34 | # run matlab script 35 | matlab -nodisplay -nosplash -nodesktop -r "addpath '${tmpdir}'; segment;" > ${tmpdir}/log 36 | # copy results to target location 37 | cmd="medpy_convert.py ${tmpdir}/c1* ${stdfeatureimages}/${i}/tissue_probability_white.${imgfiletype}" 38 | $cmd 39 | cmd="medpy_convert.py ${tmpdir}/c2* ${stdfeatureimages}/${i}/tissue_probability_gray.${imgfiletype}" 40 | $cmd 41 | cmd="medpy_convert.py ${tmpdir}/c3* ${stdfeatureimages}/${i}/tissue_probability_csf.${imgfiletype}" 42 | $cmd 43 | fi 44 | emptydircond ${tmpdir} 45 | done 46 | rmdircond ${tmpdir} 47 | 48 | log 2 "Done." "[$BASH_SOURCE:$FUNCNAME:$LINENO]" 49 | 50 | -------------------------------------------------------------------------------- /00original/GROUPINGS: -------------------------------------------------------------------------------- 1 | BASE SET: 2 | 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17, 18, 19, 20, 21, 22, 23, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40, 41, 42, 43, 44, 45 3 | (has FLAIR & mostly ischemic & is ground truth) 4 | 5 | T2 SET: 6 | (BASE SET & suitable T2 sequence) 7 | => Influence of T2 sequence 8 | 9 | DW SET: 10 | (BASE SET & DW1000 mean sequence present) 11 | => Influence of DW sequence (especially in conjunction with DISTRACTION SET) 12 | 13 | FLIPPED SET: 14 | (BASET SET \w half of the lesions flipped) 15 | => Influence of lesion hemisphere on results) 16 | 17 | CONNECTED SET: 18 | (BASE SET & ground truth completely connected in 3D) 19 | => Allows to enable largest connected component preprocessing 20 | 21 | GOOD GROUND TRUTH SET: 22 | (BASE SET & no negative ground truth remarks) 23 | => Influence of ground truth quality on results 24 | 25 | GOOD SCAN SET: 26 | (BASE SET & no imaging artifacts) 27 | => Influence of image quality on results 28 | 29 | DISTRACTION SET: 30 | (BASE SET & lesion similar hyperintensities (LSH) >= middle) 31 | => Influence of LSH occurences 32 | 33 | ISCHEMIC SET: 34 | (BASE SET & has ischemic stroke only) 35 | => Influence of hemorrhage ocurrence on results 36 | 37 | HEMORRHAGIC SET: 38 | (BASE SET & has hemorrhage) 39 | => Influence of hemorrhage ocurrence on results 40 | 41 | HEOPKS SET: 42 | (BASE SET & HEOPKS database) 43 | => Compare single vs. two sets 44 | 45 | JGABLENTZ SET: 46 | (BASE SET & JGABLENTZ database) 47 | => Compare single vs. two sets 48 | 49 | LESION LOAD SETS: 50 | (BASE SET & a) lesion size > median size resp. b) lesion size <= median size) 51 | => Check inlfuence of lesion size dedicated detectors 52 | 53 | LESION AGE SETS: 54 | (BASE SET & a) lesion age > median age resp b) lesion age <= median age) 55 | => Check quality of lesion age dedicated detectors 56 | 57 | NIHSS SETS: 58 | (BASE SET & a) nihss score > median score resp. b) nihss score <= median score) 59 | => Check inlfuence of stroke serverity on results 60 | 61 | -------------------------------------------------------------------------------- /logs/pre.b0s0.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.759 29.120 4.493 0.879 0.668 10 | 04 0.744 57.723 5.360 0.691 0.806 11 | 05 0.795 48.990 5.265 0.881 0.724 12 | 06 0.537 25.140 5.581 0.986 0.369 13 | 07 0.862 11.832 2.064 0.931 0.802 14 | 08 0.823 22.000 3.381 0.907 0.753 15 | 09 0.695 8.246 1.985 0.694 0.695 16 | 10 0.512 23.749 6.729 0.979 0.347 17 | 11 0.775 28.914 3.265 0.734 0.820 18 | 12 0.573 34.059 6.205 0.997 0.402 19 | 13 0.841 23.152 2.404 0.884 0.801 20 | 15 0.820 14.967 1.967 0.809 0.832 21 | 17 0.704 27.785 3.704 0.950 0.559 22 | 18 0.870 12.166 1.427 0.929 0.818 23 | 19 0.048 101.941 27.734 0.024 0.962 24 | 20 0.199 23.495 6.770 1.000 0.111 25 | 21 0.317 49.396 8.410 0.874 0.194 26 | 22 0.235 112.765 20.367 0.228 0.242 27 | 23 0.414 62.322 11.147 0.702 0.294 28 | 25 0.184 34.699 7.430 0.918 0.103 29 | 26 0.084 68.498 14.251 1.000 0.044 30 | 28 0.371 37.789 7.475 0.986 0.228 31 | 29 0.753 36.056 3.510 0.739 0.768 32 | 30 0.769 19.079 3.417 0.963 0.640 33 | 31 0.187 38.053 8.655 0.989 0.103 34 | 32 0.564 27.568 5.227 0.819 0.430 35 | 33 0.192 88.499 21.869 0.106 0.954 36 | 34 0.320 16.613 4.996 0.998 0.190 37 | 35 0.629 17.550 4.293 0.993 0.460 38 | 36 0.497 18.868 4.142 0.967 0.334 39 | 37 0.000 50.675 26.479 0.000 0.000 40 | 39 0.339 14.000 3.542 0.716 0.222 41 | 40 0.658 50.990 6.329 0.983 0.495 42 | 41 0.524 31.686 5.478 0.959 0.360 43 | 42 0.332 55.606 13.299 0.624 0.226 44 | 43 0.800 82.024 4.481 0.708 0.920 45 | 44 0.000 inf inf 0.000 0.000 46 | 45 0.465 62.418 8.530 0.429 0.509 47 | DM average 0.504987930272 +/- 0.267278766405 48 | HD average inf +/- nan 49 | ASSD average inf +/- nan 50 | Prec. average 0.762622881038 +/- 0.299754915987 51 | Rec. average 0.478549777115 +/- 0.292334538156 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b0s0_r3.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.761 31.559 4.690 0.884 0.668 10 | 04 0.762 22.361 2.605 0.726 0.800 11 | 05 0.784 48.580 6.001 0.895 0.697 12 | 06 0.554 27.129 5.346 0.978 0.387 13 | 07 0.858 53.292 2.697 0.911 0.810 14 | 08 0.832 22.000 3.277 0.904 0.771 15 | 09 0.700 8.246 1.950 0.714 0.688 16 | 10 0.520 24.331 6.578 0.982 0.353 17 | 11 0.772 30.594 3.372 0.733 0.815 18 | 12 0.565 34.059 6.268 0.995 0.395 19 | 13 0.842 23.664 2.422 0.882 0.807 20 | 15 0.821 14.967 1.928 0.818 0.824 21 | 17 0.708 27.495 3.643 0.942 0.567 22 | 18 0.871 9.798 1.428 0.918 0.827 23 | 19 0.047 101.469 27.627 0.024 0.956 24 | 20 0.207 22.091 6.253 1.000 0.115 25 | 21 0.307 49.031 8.503 0.880 0.186 26 | 22 0.246 23.152 6.482 0.314 0.203 27 | 23 0.384 62.322 11.403 0.738 0.260 28 | 25 0.107 37.417 8.299 0.823 0.057 29 | 26 0.061 68.935 14.359 1.000 0.032 30 | 28 0.352 37.789 7.977 0.988 0.214 31 | 29 0.749 37.417 3.578 0.744 0.754 32 | 30 0.766 20.100 3.460 0.965 0.636 33 | 31 0.220 37.363 8.293 0.990 0.124 34 | 32 0.538 28.000 5.360 0.818 0.401 35 | 33 0.199 88.634 21.784 0.111 0.936 36 | 34 0.342 19.698 4.876 0.988 0.207 37 | 35 0.593 16.613 4.292 0.974 0.426 38 | 36 0.495 19.079 4.153 0.978 0.332 39 | 37 0.000 44.900 26.965 0.000 0.000 40 | 39 0.285 13.416 3.757 0.726 0.178 41 | 40 0.655 51.342 6.387 0.985 0.491 42 | 41 0.525 30.659 5.442 0.963 0.361 43 | 42 0.291 56.604 14.542 0.546 0.199 44 | 43 0.805 14.142 3.064 0.715 0.921 45 | 44 0.000 inf inf 0.000 0.000 46 | 45 0.454 62.897 8.730 0.437 0.473 47 | DM average 0.499479243603 +/- 0.271466489311 48 | HD average inf +/- nan 49 | ASSD average inf +/- nan 50 | Prec. average 0.762839138439 +/- 0.294699589381 51 | Rec. average 0.470267608246 +/- 0.295550942192 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b1s0.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.777 28.983 4.171 0.907 0.680 10 | 04 0.598 81.240 15.047 0.457 0.866 11 | 05 0.733 21.448 4.741 0.934 0.603 12 | 06 0.541 26.153 5.402 0.947 0.379 13 | 07 0.838 14.697 2.304 0.945 0.752 14 | 08 0.693 27.495 4.821 0.929 0.553 15 | 09 0.397 16.492 3.439 0.957 0.251 16 | 10 0.560 47.455 6.747 0.973 0.393 17 | 11 0.673 66.783 6.890 0.702 0.646 18 | 12 0.436 44.091 7.575 0.995 0.279 19 | 13 0.785 24.083 3.101 0.914 0.688 20 | 15 0.823 14.967 1.885 0.833 0.813 21 | 17 0.733 27.928 3.295 0.959 0.593 22 | 18 0.813 16.248 1.986 0.967 0.701 23 | 19 0.180 100.598 24.919 0.100 0.900 24 | 20 0.868 74.431 3.759 0.817 0.927 25 | 21 0.731 91.782 10.720 0.745 0.718 26 | 22 0.330 22.000 6.343 0.295 0.375 27 | 23 0.592 30.067 4.056 0.896 0.442 28 | 25 0.626 28.705 3.406 0.712 0.559 29 | 26 0.671 26.382 2.618 0.793 0.581 30 | 28 0.783 28.071 2.928 0.829 0.742 31 | 29 0.681 75.419 8.120 0.610 0.771 32 | 30 0.506 22.091 5.164 0.908 0.351 33 | 31 0.153 33.106 7.878 0.957 0.083 34 | 32 0.317 26.077 7.550 0.831 0.196 35 | 33 0.375 67.320 14.352 0.239 0.872 36 | 34 0.622 39.497 6.068 0.835 0.495 37 | 35 0.326 26.907 7.500 0.997 0.195 38 | 36 0.552 18.868 3.466 0.924 0.393 39 | 37 0.000 54.736 30.119 0.000 0.000 40 | 39 0.000 inf inf 0.000 0.000 41 | 40 0.473 42.426 6.569 0.949 0.315 42 | 41 0.043 58.447 23.548 0.404 0.023 43 | 42 0.442 16.613 4.066 0.979 0.285 44 | 43 0.570 78.460 14.899 0.495 0.670 45 | 44 0.343 24.000 4.454 0.913 0.211 46 | 45 0.379 65.177 10.872 0.408 0.355 47 | DM average 0.525397132088 +/- 0.235944644322 48 | HD average inf +/- nan 49 | ASSD average inf +/- nan 50 | Prec. average 0.73831246806 +/- 0.289828950916 51 | Rec. average 0.490970223266 +/- 0.261793219692 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size100k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.698 29.732 5.518 0.952 0.550 9 | 04 0.747 63.624 4.618 0.697 0.805 10 | 05 0.627 33.764 6.696 0.988 0.460 11 | 06 0.791 19.596 3.145 0.876 0.721 12 | 07 0.865 10.770 1.975 0.929 0.810 13 | 08 0.760 36.715 4.843 0.983 0.620 14 | 09 0.651 48.744 2.821 0.594 0.720 15 | 10 0.646 22.000 5.156 0.986 0.480 16 | 11 0.657 24.495 3.180 0.944 0.504 17 | 12 0.818 18.868 2.664 0.963 0.710 18 | 13 0.822 25.768 2.772 0.893 0.761 19 | 15 0.799 13.565 2.124 0.819 0.780 20 | 17 0.811 17.205 2.498 0.811 0.811 21 | 18 0.851 16.613 1.753 0.903 0.804 22 | 19 0.712 14.000 2.273 0.739 0.687 23 | 20 0.193 82.244 13.172 0.611 0.115 24 | 21 0.607 96.187 8.802 0.893 0.459 25 | 22 0.015 107.815 39.598 0.011 0.022 26 | 23 0.445 55.714 11.118 0.744 0.318 27 | 25 0.174 96.850 37.548 0.187 0.162 28 | 26 0.429 70.767 5.835 0.826 0.290 29 | 28 0.565 76.026 7.010 0.941 0.404 30 | 29 0.715 25.456 3.190 0.877 0.603 31 | 30 0.757 20.976 3.483 0.978 0.618 32 | 31 0.701 18.439 2.470 0.846 0.598 33 | 32 0.601 68.059 9.522 0.526 0.702 34 | 33 0.612 46.690 6.534 0.652 0.576 35 | 34 0.692 59.632 7.600 0.585 0.846 36 | 35 0.851 16.000 2.233 0.943 0.775 37 | 36 0.854 43.174 1.918 0.863 0.845 38 | 37 0.000 73.457 28.412 0.000 0.000 39 | 39 0.496 18.547 3.322 0.946 0.336 40 | 40 0.468 44.766 7.804 0.985 0.307 41 | 41 0.316 28.284 7.154 0.881 0.192 42 | 42 0.656 90.111 6.855 0.855 0.532 43 | 43 0.814 16.125 2.720 0.914 0.734 44 | 44 0.534 66.513 3.759 0.659 0.449 45 | 45 0.419 62.000 8.570 0.364 0.493 46 | DM average 0.609694949286 +/- 0.22409556627 47 | HD average 44.1919088513 +/- 27.7018227117 48 | ASSD average 7.3859204029 +/- 8.6988919897 49 | Prec. average 0.7675484093 +/- 0.25314623854 50 | Rec. average 0.542093792607 +/- 0.23474442037 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/pre.b0s0_r2.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.758 30.594 4.532 0.886 0.663 10 | 04 0.755 57.061 4.475 0.719 0.796 11 | 05 0.794 52.498 5.525 0.890 0.717 12 | 06 0.528 27.129 5.810 0.995 0.359 13 | 07 0.861 53.104 2.733 0.914 0.814 14 | 08 0.815 22.450 3.506 0.906 0.740 15 | 09 0.685 8.246 2.086 0.673 0.698 16 | 10 0.523 24.658 6.627 0.981 0.357 17 | 11 0.763 30.067 3.764 0.713 0.821 18 | 12 0.596 32.311 5.952 0.993 0.426 19 | 13 0.841 23.152 2.412 0.877 0.807 20 | 15 0.821 14.967 1.923 0.821 0.821 21 | 17 0.698 27.928 3.833 0.955 0.549 22 | 18 0.879 9.798 1.342 0.914 0.847 23 | 19 0.048 100.896 27.676 0.025 0.963 24 | 20 0.190 99.318 15.133 0.791 0.108 25 | 21 0.297 49.031 8.703 0.871 0.179 26 | 22 0.218 107.070 17.874 0.247 0.195 27 | 23 0.404 63.561 12.080 0.694 0.285 28 | 25 0.111 36.986 8.226 0.888 0.059 29 | 26 0.075 68.293 14.356 1.000 0.039 30 | 28 0.333 37.736 7.975 0.989 0.201 31 | 29 0.752 37.630 3.654 0.734 0.770 32 | 30 0.764 19.287 3.510 0.963 0.633 33 | 31 0.222 38.678 8.286 0.990 0.125 34 | 32 0.549 36.986 6.035 0.775 0.426 35 | 33 0.190 88.499 21.971 0.106 0.926 36 | 34 0.312 19.287 4.996 0.984 0.185 37 | 35 0.690 16.733 3.872 0.984 0.532 38 | 36 0.512 19.391 3.935 0.959 0.349 39 | 37 0.000 48.456 28.625 0.000 0.000 40 | 39 0.267 18.111 4.013 0.774 0.161 41 | 40 0.659 50.990 6.320 0.982 0.496 42 | 41 0.523 31.686 5.314 0.950 0.361 43 | 42 0.272 55.570 13.064 0.606 0.175 44 | 43 0.806 14.697 3.027 0.714 0.925 45 | 44 0.000 inf inf 0.000 0.000 46 | 45 0.463 36.770 6.880 0.454 0.474 47 | DM average 0.499376008925 +/- 0.27436788915 48 | HD average inf +/- nan 49 | ASSD average inf +/- nan 50 | Prec. average 0.755700179556 +/- 0.294575711459 51 | Rec. average 0.473214619608 +/- 0.297640398423 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b1s0_r2.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.783 29.732 4.147 0.908 0.687 10 | 04 0.590 80.747 15.094 0.448 0.862 11 | 05 0.719 19.391 4.971 0.942 0.581 12 | 06 0.550 27.203 5.176 0.948 0.388 13 | 07 0.838 15.748 2.304 0.938 0.757 14 | 08 0.686 27.203 4.906 0.912 0.550 15 | 09 0.447 14.560 3.079 0.960 0.291 16 | 10 0.546 47.371 7.186 0.970 0.380 17 | 11 0.687 65.513 6.105 0.722 0.654 18 | 12 0.453 40.150 7.017 0.995 0.293 19 | 13 0.776 24.083 3.186 0.914 0.674 20 | 15 0.819 14.967 1.917 0.841 0.797 21 | 17 0.726 27.785 3.416 0.965 0.582 22 | 18 0.808 14.142 2.008 0.973 0.690 23 | 19 0.192 100.896 25.476 0.108 0.874 24 | 20 0.867 8.485 1.561 0.823 0.916 25 | 21 0.719 92.477 11.443 0.724 0.714 26 | 22 0.313 111.247 11.341 0.257 0.401 27 | 23 0.609 30.067 3.898 0.896 0.462 28 | 25 0.618 27.495 3.492 0.661 0.581 29 | 26 0.663 31.048 2.809 0.793 0.569 30 | 28 0.779 27.495 2.855 0.828 0.735 31 | 29 0.699 75.472 7.984 0.633 0.779 32 | 30 0.520 20.100 5.051 0.900 0.366 33 | 31 0.167 33.045 7.580 0.950 0.092 34 | 32 0.308 25.923 7.557 0.819 0.189 35 | 33 0.358 67.320 14.176 0.225 0.875 36 | 34 0.632 14.283 2.938 0.957 0.472 37 | 35 0.317 27.276 7.922 0.996 0.188 38 | 36 0.558 18.974 3.402 0.930 0.399 39 | 37 0.000 49.880 29.723 0.000 0.000 40 | 39 0.000 inf inf 0.000 0.000 41 | 40 0.457 42.426 6.745 0.956 0.300 42 | 41 0.034 56.675 23.916 0.361 0.018 43 | 42 0.507 16.248 3.613 0.964 0.344 44 | 43 0.567 79.044 14.466 0.497 0.660 45 | 44 0.266 24.739 4.910 0.935 0.155 46 | 45 0.364 65.177 11.203 0.400 0.334 47 | DM average 0.524702992777 +/- 0.236810548198 48 | HD average inf +/- nan 49 | ASSD average inf +/- nan 50 | Prec. average 0.738170482725 +/- 0.295113870867 51 | Rec. average 0.489705166737 +/- 0.259058232274 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size25k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.650 35.496 6.651 0.970 0.488 9 | 04 0.756 62.322 3.454 0.739 0.773 10 | 05 0.631 34.641 7.146 0.978 0.466 11 | 06 0.776 20.976 3.319 0.893 0.687 12 | 07 0.846 12.649 2.214 0.941 0.769 13 | 08 0.739 32.619 5.120 0.985 0.591 14 | 09 0.655 52.953 3.478 0.601 0.720 15 | 10 0.606 25.612 5.888 0.987 0.438 16 | 11 0.660 21.726 2.965 0.922 0.514 17 | 12 0.810 21.633 2.796 0.961 0.700 18 | 13 0.812 26.306 2.899 0.902 0.738 19 | 15 0.798 17.205 2.196 0.808 0.788 20 | 17 0.800 18.000 2.670 0.811 0.790 21 | 18 0.833 15.748 1.859 0.901 0.775 22 | 19 0.658 64.094 2.782 0.756 0.582 23 | 20 0.159 81.927 15.359 0.570 0.093 24 | 21 0.576 94.932 8.648 0.886 0.427 25 | 22 0.007 107.070 40.999 0.005 0.010 26 | 23 0.354 54.369 10.162 0.793 0.228 27 | 25 0.181 95.603 37.197 0.194 0.169 28 | 26 0.370 66.091 5.820 0.929 0.231 29 | 28 0.534 76.158 9.042 0.928 0.375 30 | 29 0.713 30.332 3.448 0.863 0.608 31 | 30 0.726 21.354 3.916 0.976 0.578 32 | 31 0.654 18.330 2.957 0.844 0.533 33 | 32 0.592 68.235 10.505 0.527 0.675 34 | 33 0.555 46.690 7.307 0.648 0.485 35 | 34 0.661 41.280 7.404 0.551 0.824 36 | 35 0.817 16.248 2.668 0.952 0.716 37 | 36 0.849 14.422 1.876 0.878 0.822 38 | 37 0.000 79.649 30.124 0.000 0.000 39 | 39 0.506 14.283 3.146 0.777 0.375 40 | 40 0.397 46.733 8.847 0.993 0.248 41 | 41 0.272 29.052 7.355 0.857 0.162 42 | 42 0.611 83.259 3.494 0.899 0.463 43 | 43 0.796 16.125 2.886 0.922 0.700 44 | 44 0.480 23.495 3.754 0.810 0.341 45 | 45 0.410 61.123 8.618 0.365 0.467 46 | DM average 0.585550915499 +/- 0.226892228526 47 | HD average 43.3878488378 +/- 27.0344778806 48 | ASSD average 7.65713939613 +/- 8.93569047206 49 | Prec. average 0.771590939605 +/- 0.253711697301 50 | Rec. average 0.509230748901 +/- 0.23430578686 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/sample.size300k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.690 30.199 5.773 0.956 0.539 9 | 04 0.719 73.348 6.777 0.639 0.823 10 | 05 0.643 33.226 6.659 0.984 0.478 11 | 06 0.791 19.900 3.124 0.877 0.720 12 | 07 0.875 11.314 1.855 0.922 0.833 13 | 08 0.785 32.619 4.285 0.976 0.656 14 | 09 0.627 31.113 2.888 0.565 0.704 15 | 10 0.654 22.716 4.986 0.986 0.489 16 | 11 0.689 28.071 3.093 0.913 0.553 17 | 12 0.832 18.868 2.490 0.956 0.736 18 | 13 0.831 25.768 2.647 0.905 0.769 19 | 15 0.805 14.967 2.104 0.807 0.803 20 | 17 0.817 15.362 2.412 0.819 0.815 21 | 18 0.868 16.971 1.566 0.918 0.822 22 | 19 0.732 46.690 2.084 0.718 0.747 23 | 20 0.250 81.535 12.668 0.697 0.152 24 | 21 0.666 96.354 8.066 0.898 0.529 25 | 22 0.017 107.070 38.750 0.013 0.025 26 | 23 0.540 53.141 5.930 0.835 0.399 27 | 25 0.206 97.755 37.351 0.194 0.219 28 | 26 0.401 68.147 5.991 0.879 0.260 29 | 28 0.598 76.968 7.556 0.927 0.441 30 | 29 0.732 24.413 3.008 0.871 0.630 31 | 30 0.771 22.181 3.274 0.973 0.638 32 | 31 0.700 18.974 2.560 0.862 0.589 33 | 32 0.572 70.314 11.383 0.472 0.727 34 | 33 0.605 46.690 7.027 0.636 0.577 35 | 34 0.684 45.519 7.166 0.577 0.840 36 | 35 0.860 16.125 2.115 0.946 0.788 37 | 36 0.857 43.174 1.916 0.854 0.860 38 | 37 0.000 77.201 28.797 0.000 0.000 39 | 39 0.538 16.613 2.827 0.939 0.377 40 | 40 0.493 44.766 7.248 0.989 0.328 41 | 41 0.324 28.142 6.897 0.867 0.199 42 | 42 0.634 91.148 5.796 0.824 0.515 43 | 43 0.825 16.000 2.549 0.907 0.757 44 | 44 0.507 70.682 4.788 0.665 0.410 45 | 45 0.424 61.221 8.284 0.368 0.498 46 | DM average 0.61997490217 +/- 0.221181601213 47 | HD average 44.6122643758 +/- 27.6378568349 48 | ASSD average 7.22869366913 +/- 8.62462163087 49 | Prec. average 0.766705816971 +/- 0.25380000667 50 | Rec. average 0.559101748499 +/- 0.233542279231 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/sample.size50k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.690 31.623 5.755 0.959 0.539 9 | 04 0.747 63.844 3.986 0.719 0.776 10 | 05 0.612 34.409 7.212 0.989 0.443 11 | 06 0.781 19.799 3.278 0.884 0.699 12 | 07 0.860 11.832 2.078 0.932 0.798 13 | 08 0.762 33.226 4.701 0.985 0.621 14 | 09 0.657 47.244 3.001 0.616 0.703 15 | 10 0.637 22.716 5.309 0.986 0.471 16 | 11 0.690 23.580 2.741 0.903 0.558 17 | 12 0.815 20.100 2.768 0.950 0.713 18 | 13 0.827 25.768 2.691 0.909 0.760 19 | 15 0.814 14.000 1.979 0.816 0.812 20 | 17 0.800 15.748 2.672 0.799 0.801 21 | 18 0.849 16.492 1.757 0.890 0.812 22 | 19 0.655 15.748 2.492 0.769 0.571 23 | 20 0.192 72.829 13.581 0.674 0.112 24 | 21 0.597 94.064 8.020 0.914 0.443 25 | 22 0.023 107.815 38.637 0.018 0.032 26 | 23 0.492 53.292 7.123 0.795 0.356 27 | 25 0.172 91.695 37.419 0.195 0.153 28 | 26 0.385 66.873 6.036 0.875 0.247 29 | 28 0.541 76.994 8.566 0.928 0.382 30 | 29 0.715 40.841 4.010 0.881 0.602 31 | 30 0.742 24.413 3.715 0.979 0.598 32 | 31 0.666 19.900 2.815 0.893 0.532 33 | 32 0.581 67.052 10.899 0.514 0.668 34 | 33 0.588 46.690 6.589 0.668 0.525 35 | 34 0.676 40.100 6.944 0.560 0.852 36 | 35 0.846 16.125 2.303 0.941 0.769 37 | 36 0.848 44.407 2.040 0.869 0.828 38 | 37 0.000 73.783 31.691 0.000 0.000 39 | 39 0.531 20.785 3.449 0.853 0.385 40 | 40 0.474 46.690 8.142 0.987 0.312 41 | 41 0.303 28.914 7.325 0.876 0.183 42 | 42 0.643 87.636 5.228 0.845 0.519 43 | 43 0.801 16.733 2.876 0.914 0.712 44 | 44 0.484 23.495 3.515 0.821 0.344 45 | 45 0.416 61.644 8.660 0.366 0.482 46 | DM average 0.602952394444 +/- 0.222758867285 47 | HD average 42.6025659847 +/- 26.1910049432 48 | ASSD average 7.42105991399 +/- 8.80264991659 49 | Prec. average 0.775692883826 +/- 0.249850801311 50 | Rec. average 0.529245840194 +/- 0.232467911129 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/sample.size10k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.619 33.106 7.081 0.962 0.456 9 | 04 0.737 18.439 2.621 0.775 0.702 10 | 05 0.619 34.409 7.214 0.987 0.451 11 | 06 0.779 20.100 3.254 0.899 0.686 12 | 07 0.818 15.748 2.624 0.952 0.717 13 | 08 0.716 35.889 5.674 0.986 0.562 14 | 09 0.661 10.000 2.380 0.619 0.708 15 | 10 0.560 24.413 6.300 0.990 0.390 16 | 11 0.677 26.077 2.900 0.923 0.535 17 | 12 0.774 27.129 3.538 0.978 0.641 18 | 13 0.819 26.306 2.833 0.910 0.744 19 | 15 0.811 15.748 2.111 0.798 0.825 20 | 17 0.794 18.547 2.682 0.840 0.753 21 | 18 0.792 15.748 2.273 0.868 0.728 22 | 19 0.639 13.416 2.475 0.771 0.545 23 | 20 0.108 71.218 16.121 0.483 0.061 24 | 21 0.434 94.064 10.217 0.904 0.286 25 | 22 0.003 105.470 42.698 0.002 0.005 26 | 23 0.218 60.266 19.531 0.203 0.237 27 | 25 0.109 93.851 39.926 0.131 0.093 28 | 26 0.389 69.426 5.933 0.875 0.250 29 | 28 0.497 62.642 6.863 0.959 0.335 30 | 29 0.634 39.799 4.381 0.861 0.502 31 | 30 0.713 18.111 4.121 0.966 0.564 32 | 31 0.651 21.260 2.973 0.895 0.512 33 | 32 0.566 68.235 10.191 0.550 0.582 34 | 33 0.533 46.174 6.683 0.704 0.428 35 | 34 0.653 40.299 7.315 0.550 0.801 36 | 35 0.835 16.000 2.420 0.955 0.742 37 | 36 0.837 15.748 2.004 0.873 0.805 38 | 37 0.000 74.833 29.135 0.000 0.000 39 | 39 0.538 19.079 3.813 0.623 0.473 40 | 40 0.371 49.031 9.566 0.985 0.229 41 | 41 0.296 33.045 7.740 0.836 0.180 42 | 42 0.537 24.413 3.720 0.932 0.377 43 | 43 0.793 16.613 2.963 0.917 0.698 44 | 44 0.537 23.495 3.530 0.727 0.426 45 | 45 0.369 62.578 10.342 0.314 0.448 46 | DM average 0.564085670762 +/- 0.234257166115 47 | HD average 38.4401498679 +/- 25.4131572683 48 | ASSD average 8.10909247658 +/- 9.48150906591 49 | Prec. average 0.750108972508 +/- 0.277910166631 50 | Rec. average 0.486286990045 +/- 0.231725598722 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/sample.size150k_r2.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.697 31.048 5.677 0.957 0.548 9 | 04 0.742 61.123 5.001 0.688 0.805 10 | 05 0.633 33.226 6.572 0.985 0.466 11 | 06 0.788 20.591 3.176 0.880 0.713 12 | 07 0.867 10.770 1.953 0.928 0.814 13 | 08 0.776 36.824 4.540 0.980 0.643 14 | 09 0.633 50.517 3.851 0.568 0.715 15 | 10 0.639 23.409 5.232 0.987 0.472 16 | 11 0.671 28.000 2.901 0.927 0.525 17 | 12 0.827 18.868 2.544 0.956 0.728 18 | 13 0.831 25.768 2.646 0.895 0.776 19 | 15 0.806 14.967 2.122 0.801 0.811 20 | 17 0.808 17.088 2.543 0.807 0.809 21 | 18 0.861 17.889 1.650 0.919 0.810 22 | 19 0.728 16.248 2.183 0.734 0.722 23 | 20 0.177 81.731 13.875 0.617 0.103 24 | 21 0.628 94.932 9.011 0.894 0.484 25 | 22 0.019 107.201 39.356 0.014 0.027 26 | 23 0.473 53.516 8.253 0.792 0.337 27 | 25 0.185 95.352 37.133 0.194 0.177 28 | 26 0.439 69.311 5.987 0.868 0.294 29 | 28 0.567 77.820 8.548 0.927 0.408 30 | 29 0.720 39.799 3.889 0.880 0.609 31 | 30 0.766 17.205 3.322 0.974 0.631 32 | 31 0.682 18.547 2.656 0.854 0.568 33 | 32 0.587 68.293 10.596 0.500 0.711 34 | 33 0.616 46.733 6.368 0.648 0.587 35 | 34 0.662 57.166 8.431 0.539 0.857 36 | 35 0.853 16.125 2.227 0.950 0.773 37 | 36 0.860 44.407 1.964 0.859 0.861 38 | 37 0.000 73.892 29.479 0.000 0.000 39 | 39 0.549 14.697 2.758 0.937 0.389 40 | 40 0.477 46.217 7.915 0.991 0.314 41 | 41 0.326 27.928 7.042 0.872 0.201 42 | 42 0.619 89.331 8.349 0.838 0.491 43 | 43 0.817 16.492 2.683 0.907 0.744 44 | 44 0.529 21.541 3.569 0.698 0.426 45 | 45 0.442 62.418 8.626 0.390 0.509 46 | DM average 0.613142001213 +/- 0.223130178201 47 | HD average 43.3419129844 +/- 27.1914198912 48 | ASSD average 7.49017233147 +/- 8.71009887768 49 | Prec. average 0.767200927488 +/- 0.2528197945 50 | Rec. average 0.548935334632 +/- 0.235994263661 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/sample.size150k_r3.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.694 29.732 5.616 0.955 0.545 9 | 04 0.747 63.624 4.732 0.691 0.812 10 | 05 0.649 33.764 6.519 0.986 0.484 11 | 06 0.788 19.799 3.160 0.877 0.715 12 | 07 0.866 11.314 1.982 0.932 0.809 13 | 08 0.770 34.234 4.548 0.979 0.634 14 | 09 0.652 51.147 2.684 0.601 0.712 15 | 10 0.639 22.978 5.224 0.987 0.472 16 | 11 0.698 30.000 2.993 0.918 0.564 17 | 12 0.837 18.868 2.413 0.959 0.742 18 | 13 0.831 25.768 2.630 0.906 0.767 19 | 15 0.805 14.697 2.125 0.800 0.811 20 | 17 0.813 15.748 2.460 0.818 0.807 21 | 18 0.867 16.971 1.572 0.900 0.836 22 | 19 0.696 16.125 2.459 0.702 0.691 23 | 20 0.304 80.250 11.101 0.757 0.190 24 | 21 0.629 98.020 8.730 0.890 0.487 25 | 22 0.011 110.887 40.521 0.009 0.017 26 | 23 0.442 53.591 10.504 0.719 0.319 27 | 25 0.198 96.850 37.632 0.202 0.195 28 | 26 0.436 69.311 5.998 0.867 0.291 29 | 28 0.565 76.968 8.026 0.928 0.406 30 | 29 0.719 24.083 3.011 0.893 0.602 31 | 30 0.757 23.152 3.483 0.977 0.617 32 | 31 0.687 18.974 2.664 0.869 0.568 33 | 32 0.595 68.469 10.678 0.505 0.723 34 | 33 0.637 46.690 6.174 0.690 0.591 35 | 34 0.660 58.992 7.602 0.548 0.828 36 | 35 0.854 16.125 2.187 0.946 0.778 37 | 36 0.856 45.651 2.145 0.854 0.858 38 | 37 0.000 77.201 27.303 0.000 0.000 39 | 39 0.555 18.547 2.849 0.853 0.411 40 | 40 0.471 44.766 7.785 0.991 0.309 41 | 41 0.312 27.928 7.072 0.877 0.190 42 | 42 0.615 86.856 5.913 0.883 0.472 43 | 43 0.819 16.125 2.636 0.911 0.744 44 | 44 0.552 23.495 3.552 0.710 0.452 45 | 45 0.408 61.644 8.458 0.358 0.474 46 | DM average 0.616653861727 +/- 0.219336797847 47 | HD average 43.4037582325 +/- 27.6197504225 48 | ASSD average 7.29315188164 +/- 8.72263139602 49 | Prec. average 0.769669813191 +/- 0.251123962487 50 | Rec. average 0.550602814195 +/- 0.231933210763 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/sample.size150k_r5.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.692 30.199 5.695 0.959 0.541 9 | 04 0.743 65.788 4.720 0.682 0.816 10 | 05 0.642 30.854 6.465 0.985 0.476 11 | 06 0.796 19.799 3.054 0.891 0.718 12 | 07 0.865 11.314 2.013 0.916 0.820 13 | 08 0.778 32.619 4.423 0.976 0.647 14 | 09 0.642 8.944 2.522 0.578 0.723 15 | 10 0.644 23.152 5.138 0.988 0.478 16 | 11 0.685 25.612 2.941 0.909 0.549 17 | 12 0.830 19.799 2.531 0.954 0.735 18 | 13 0.827 24.900 2.694 0.904 0.762 19 | 15 0.805 14.967 2.131 0.800 0.809 20 | 17 0.809 16.371 2.507 0.814 0.804 21 | 18 0.856 16.492 1.699 0.903 0.814 22 | 19 0.723 16.492 2.079 0.726 0.719 23 | 20 0.128 81.019 15.157 0.506 0.073 24 | 21 0.649 96.354 8.441 0.887 0.512 25 | 22 0.009 107.201 40.825 0.007 0.014 26 | 23 0.456 53.442 9.830 0.765 0.325 27 | 25 0.163 96.664 38.740 0.172 0.154 28 | 26 0.452 67.882 4.790 0.870 0.305 29 | 28 0.582 76.968 7.611 0.933 0.423 30 | 29 0.724 40.645 3.833 0.896 0.607 31 | 30 0.766 23.324 3.439 0.975 0.631 32 | 31 0.709 18.974 2.513 0.860 0.603 33 | 32 0.589 68.235 10.821 0.505 0.705 34 | 33 0.590 46.174 6.486 0.655 0.537 35 | 34 0.650 53.963 7.843 0.531 0.838 36 | 35 0.857 15.100 2.151 0.948 0.782 37 | 36 0.855 44.677 2.116 0.848 0.861 38 | 37 0.000 77.201 25.623 0.000 0.000 39 | 39 0.535 19.079 3.420 0.832 0.394 40 | 40 0.473 45.122 7.868 0.989 0.310 41 | 41 0.316 28.705 7.185 0.868 0.193 42 | 42 0.631 86.279 4.982 0.867 0.496 43 | 43 0.814 16.248 2.738 0.904 0.740 44 | 44 0.548 23.495 3.391 0.752 0.430 45 | 45 0.419 61.188 8.225 0.360 0.501 46 | DM average 0.611862305232 +/- 0.228720315394 47 | HD average 42.2431012286 +/- 27.6375865095 48 | ASSD average 7.33262502445 +/- 8.82758623625 49 | Prec. average 0.760941714308 +/- 0.256359422117 50 | Rec. average 0.548647764901 +/- 0.238866109005 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.allpluscd.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.701 31.048 5.428 0.954 0.554 9 | 04 0.622 104.192 13.792 0.525 0.763 10 | 05 0.581 34.986 7.274 0.989 0.412 11 | 06 0.778 52.991 3.741 0.849 0.718 12 | 07 0.847 12.000 2.221 0.916 0.787 13 | 08 0.742 38.000 5.294 0.984 0.595 14 | 09 0.597 51.575 5.394 0.479 0.793 15 | 10 0.606 23.664 5.544 0.991 0.437 16 | 11 0.688 27.276 2.623 0.939 0.543 17 | 12 0.817 19.799 2.631 0.954 0.714 18 | 13 0.820 24.900 2.730 0.912 0.744 19 | 15 0.823 14.967 1.905 0.816 0.830 20 | 17 0.826 17.205 2.214 0.863 0.793 21 | 18 0.866 18.439 1.607 0.908 0.827 22 | 19 0.614 18.000 3.394 0.705 0.544 23 | 20 0.484 87.818 22.953 0.481 0.488 24 | 21 0.626 100.499 11.147 0.867 0.490 25 | 22 0.038 105.925 31.078 0.037 0.039 26 | 23 0.545 26.608 4.328 0.864 0.398 27 | 25 0.141 91.782 38.571 0.214 0.105 28 | 26 0.626 67.882 5.043 0.829 0.502 29 | 28 0.607 78.791 9.205 0.899 0.458 30 | 29 0.764 39.243 3.377 0.892 0.669 31 | 30 0.743 16.971 3.492 0.978 0.599 32 | 31 0.665 14.142 2.640 0.899 0.527 33 | 32 0.563 71.049 11.783 0.479 0.681 34 | 33 0.587 47.707 7.052 0.615 0.561 35 | 34 0.642 44.452 7.916 0.513 0.858 36 | 35 0.848 15.100 2.234 0.947 0.767 37 | 36 0.847 43.909 2.267 0.845 0.849 38 | 37 0.000 71.021 35.442 0.000 0.000 39 | 39 0.355 68.029 10.447 0.691 0.239 40 | 40 0.424 44.766 8.182 0.981 0.271 41 | 41 0.306 28.355 6.795 0.865 0.186 42 | 42 0.582 93.915 6.615 0.840 0.445 43 | 43 0.796 16.125 2.810 0.913 0.706 44 | 44 0.560 82.000 4.783 0.639 0.499 45 | 45 0.416 62.418 8.621 0.358 0.496 46 | DM average 0.607730731085 +/- 0.213351378523 47 | HD average 47.5670712549 +/- 29.1385988469 48 | ASSD average 8.22558965912 +/- 8.89250470132 49 | Prec. average 0.748177801287 +/- 0.259869806599 50 | Rec. average 0.549701021832 +/- 0.224754654818 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.allpluscd_19.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.672 33.526 6.220 0.963 0.516 9 | 04 0.684 33.106 3.575 0.562 0.874 10 | 05 0.622 39.446 6.986 0.935 0.466 11 | 06 0.796 17.088 3.063 0.781 0.813 12 | 07 0.793 17.664 3.123 0.857 0.739 13 | 08 0.699 26.382 5.742 0.957 0.551 14 | 09 0.640 31.686 2.644 0.573 0.723 15 | 10 0.643 23.152 5.136 0.989 0.476 16 | 11 0.646 27.928 3.286 0.931 0.495 17 | 12 0.824 21.633 2.654 0.959 0.723 18 | 13 0.815 26.683 2.858 0.910 0.738 19 | 15 0.801 14.560 2.071 0.829 0.775 20 | 17 0.803 17.205 2.567 0.840 0.769 21 | 18 0.864 17.550 1.608 0.910 0.823 22 | 19 0.731 84.214 2.780 0.725 0.738 23 | 20 0.044 83.403 25.397 0.198 0.025 24 | 21 0.591 96.726 8.959 0.877 0.445 25 | 22 0.006 108.536 42.011 0.005 0.009 26 | 23 0.501 54.443 10.241 0.744 0.378 27 | 25 0.182 95.184 36.699 0.199 0.167 28 | 26 0.362 31.305 4.247 0.897 0.227 29 | 28 0.558 76.158 7.241 0.941 0.396 30 | 29 0.717 40.249 3.951 0.891 0.599 31 | 30 0.726 25.456 3.909 0.982 0.576 32 | 31 0.685 18.547 2.671 0.870 0.565 33 | 32 0.597 68.411 10.439 0.511 0.719 34 | 33 0.634 46.174 6.171 0.680 0.594 35 | 34 0.674 59.363 8.780 0.560 0.844 36 | 35 0.851 16.000 2.244 0.949 0.771 37 | 36 0.848 44.989 2.338 0.853 0.843 38 | 37 0.000 71.414 35.106 0.000 0.000 39 | 39 0.438 19.698 3.840 0.972 0.283 40 | 40 0.469 46.433 7.820 0.988 0.308 41 | 41 0.289 29.052 7.391 0.882 0.173 42 | 42 0.598 85.463 6.920 0.875 0.454 43 | 43 0.820 16.125 2.617 0.909 0.746 44 | 44 0.529 84.238 4.258 0.783 0.400 45 | 45 0.429 60.696 7.957 0.384 0.487 46 | DM average 0.594245875046 +/- 0.230752428646 47 | HD average 44.9969440718 +/- 27.3863445225 48 | ASSD average 8.03997024584 +/- 9.6801097703 49 | Prec. average 0.754474771219 +/- 0.268291624706 50 | Rec. average 0.532288269417 +/- 0.246390368868 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lh11102030.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.597 33.347 6.879 0.954 0.435 9 | 04 0.481 99.156 15.256 0.493 0.470 10 | 05 0.519 35.496 7.774 0.983 0.352 11 | 06 0.669 54.553 6.122 0.821 0.565 12 | 07 0.750 16.613 3.279 0.948 0.620 13 | 08 0.565 36.277 7.747 0.982 0.396 14 | 09 0.347 76.131 10.592 0.226 0.748 15 | 10 0.443 57.026 7.687 0.965 0.288 16 | 11 0.690 19.391 2.568 0.898 0.560 17 | 12 0.693 35.440 4.402 0.970 0.540 18 | 13 0.761 64.560 3.543 0.891 0.664 19 | 15 0.766 82.438 3.432 0.748 0.786 20 | 17 0.768 41.761 3.107 0.762 0.774 21 | 18 0.567 29.799 3.982 0.864 0.422 22 | 19 0.219 15.748 4.493 0.787 0.127 23 | 20 0.182 121.557 36.590 0.120 0.376 24 | 21 0.571 103.325 11.103 0.785 0.448 25 | 22 0.000 108.977 41.248 0.000 0.000 26 | 23 0.288 73.457 20.861 0.258 0.325 27 | 25 0.105 125.634 44.104 0.114 0.098 28 | 26 0.567 69.742 4.446 0.754 0.454 29 | 28 0.509 76.968 9.675 0.890 0.356 30 | 29 0.527 43.681 7.427 0.810 0.391 31 | 30 0.603 31.875 5.318 0.948 0.443 32 | 31 0.348 34.583 6.743 0.881 0.217 33 | 32 0.492 65.177 9.243 0.589 0.423 34 | 33 0.349 51.730 9.981 0.500 0.268 35 | 34 0.522 47.032 9.580 0.386 0.806 36 | 35 0.795 28.142 2.913 0.918 0.701 37 | 36 0.754 58.788 3.530 0.881 0.659 38 | 37 0.000 74.027 31.728 0.000 0.000 39 | 39 0.439 70.285 14.686 0.317 0.712 40 | 40 0.234 52.650 10.950 0.991 0.132 41 | 41 0.225 27.857 7.601 0.740 0.133 42 | 42 0.555 74.027 15.635 0.529 0.584 43 | 43 0.771 26.382 4.307 0.754 0.789 44 | 44 0.192 86.209 28.010 0.123 0.444 45 | 45 0.312 62.833 10.273 0.432 0.245 46 | DM average 0.47835702303 +/- 0.221254567239 47 | HD average 58.2282824086 +/- 28.460383756 48 | ASSD average 11.495140975 +/- 10.6768871773 49 | Prec. average 0.658198901657 +/- 0.31074197354 50 | Rec. average 0.440821451487 +/- 0.222764755158 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lh1120.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.524 25.534 7.427 0.952 0.361 9 | 04 0.427 83.642 10.553 0.528 0.358 10 | 05 0.499 44.900 7.775 0.977 0.335 11 | 06 0.614 68.147 6.229 0.816 0.493 12 | 07 0.699 74.913 3.888 0.938 0.557 13 | 08 0.535 59.262 7.135 0.965 0.370 14 | 09 0.319 87.338 10.977 0.214 0.631 15 | 10 0.400 55.534 7.660 0.940 0.254 16 | 11 0.620 65.605 3.765 0.797 0.507 17 | 12 0.618 44.227 4.636 0.956 0.456 18 | 13 0.686 68.381 7.595 0.840 0.580 19 | 15 0.641 84.404 11.275 0.653 0.629 20 | 17 0.713 67.052 4.611 0.750 0.680 21 | 18 0.526 39.345 4.431 0.751 0.405 22 | 19 0.093 68.673 7.156 0.332 0.054 23 | 20 0.142 124.290 32.615 0.098 0.261 24 | 21 0.455 100.499 17.365 0.601 0.366 25 | 22 0.006 109.745 37.044 0.005 0.006 26 | 23 0.263 95.833 20.757 0.262 0.264 27 | 25 0.019 125.634 43.596 0.015 0.027 28 | 26 0.439 79.725 12.200 0.491 0.397 29 | 28 0.440 79.950 15.279 0.728 0.316 30 | 29 0.507 62.097 6.859 0.746 0.384 31 | 30 0.520 22.891 5.053 0.939 0.359 32 | 31 0.328 39.446 4.885 0.895 0.201 33 | 32 0.431 68.000 12.648 0.475 0.395 34 | 33 0.403 67.557 8.839 0.566 0.313 35 | 34 0.444 74.108 11.087 0.314 0.755 36 | 35 0.720 40.792 3.747 0.923 0.590 37 | 36 0.726 62.514 3.456 0.863 0.627 38 | 37 0.000 78.791 31.550 0.000 0.000 39 | 39 0.346 69.426 15.013 0.227 0.727 40 | 40 0.205 54.000 10.939 0.961 0.115 41 | 41 0.201 61.384 11.274 0.575 0.122 42 | 42 0.419 108.480 21.728 0.342 0.540 43 | 43 0.710 95.708 5.560 0.779 0.652 44 | 44 0.146 90.598 26.970 0.084 0.555 45 | 45 0.326 63.403 12.223 0.381 0.285 46 | DM average 0.42394195262 +/- 0.208370732382 47 | HD average 71.363941655 +/- 23.9523307269 48 | ASSD average 12.5209759558 +/- 9.79818385567 49 | Prec. average 0.59681345272 +/- 0.316297847903 50 | Rec. average 0.392805084609 +/- 0.20268264641 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lh1130.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.591 72.498 6.086 0.891 0.442 9 | 04 0.444 105.792 14.962 0.571 0.363 10 | 05 0.528 62.032 6.727 0.947 0.366 11 | 06 0.564 69.426 6.387 0.874 0.417 12 | 07 0.503 79.750 5.687 0.883 0.352 13 | 08 0.586 77.820 6.279 0.955 0.423 14 | 09 0.346 70.257 11.928 0.323 0.372 15 | 10 0.308 69.455 7.441 0.932 0.185 16 | 11 0.401 83.259 11.363 0.657 0.288 17 | 12 0.542 72.719 6.511 0.902 0.387 18 | 13 0.660 65.970 4.965 0.862 0.535 19 | 15 0.643 79.649 7.646 0.684 0.607 20 | 17 0.652 77.382 6.215 0.831 0.536 21 | 18 0.778 72.250 3.308 0.789 0.766 22 | 19 0.181 90.200 9.412 0.182 0.181 23 | 20 0.002 113.208 46.909 0.002 0.004 24 | 21 0.283 99.156 23.033 0.562 0.189 25 | 22 0.003 104.938 43.717 0.002 0.006 26 | 23 0.061 111.176 25.473 0.048 0.082 27 | 25 0.001 118.017 50.256 0.001 0.002 28 | 26 0.095 83.833 25.658 0.092 0.098 29 | 28 0.300 84.923 24.960 0.415 0.235 30 | 29 0.545 78.740 8.527 0.596 0.502 31 | 30 0.429 69.080 6.225 0.947 0.277 32 | 31 0.567 75.260 3.804 0.747 0.457 33 | 32 0.394 83.618 13.852 0.390 0.397 34 | 33 0.546 78.740 4.728 0.583 0.513 35 | 34 0.520 70.228 10.485 0.423 0.674 36 | 35 0.598 64.529 4.716 0.928 0.441 37 | 36 0.780 74.860 6.526 0.773 0.787 38 | 37 0.001 110.941 27.108 0.000 0.005 39 | 39 0.073 80.150 23.348 0.079 0.067 40 | 40 0.389 51.029 5.845 0.961 0.244 41 | 41 0.110 79.524 14.861 0.370 0.065 42 | 42 0.057 100.519 27.165 0.058 0.056 43 | 43 0.564 88.295 6.842 0.870 0.418 44 | 44 0.096 84.971 23.772 0.085 0.110 45 | 45 0.229 85.135 14.220 0.173 0.336 46 | DM average 0.378106299844 +/- 0.235855846288 47 | HD average 82.6138970014 +/- 15.3416125251 48 | ASSD average 14.656540744 +/- 12.081073764 49 | Prec. average 0.536599249518 +/- 0.348303141567 50 | Rec. average 0.320578642912 +/- 0.211673945034 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lh1110.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.246 73.157 6.180 0.899 0.143 9 | 04 0.216 101.764 18.680 0.337 0.159 10 | 05 0.270 60.299 7.168 0.851 0.160 11 | 06 0.462 69.541 7.790 0.709 0.343 12 | 07 0.563 87.338 6.172 0.904 0.409 13 | 08 0.401 79.347 7.016 0.959 0.253 14 | 09 0.221 86.371 15.439 0.143 0.488 15 | 10 0.258 72.305 7.441 0.910 0.151 16 | 11 0.558 78.460 7.930 0.739 0.449 17 | 12 0.470 83.905 5.819 0.927 0.314 18 | 13 0.586 71.722 9.445 0.757 0.477 19 | 15 0.482 83.785 14.366 0.437 0.538 20 | 17 0.551 79.725 8.021 0.682 0.463 21 | 18 0.448 73.919 7.645 0.606 0.355 22 | 19 0.069 97.036 17.435 0.124 0.048 23 | 20 0.149 120.482 28.867 0.109 0.236 24 | 21 0.296 107.592 23.583 0.373 0.246 25 | 22 0.015 111.911 36.147 0.011 0.023 26 | 23 0.193 98.428 21.260 0.230 0.166 27 | 25 0.050 127.028 36.577 0.032 0.118 28 | 26 0.263 85.674 18.390 0.324 0.221 29 | 28 0.309 86.925 19.676 0.564 0.213 30 | 29 0.352 75.260 9.993 0.523 0.265 31 | 30 0.314 84.617 6.128 0.932 0.189 32 | 31 0.183 79.750 8.992 0.626 0.107 33 | 32 0.266 88.227 15.163 0.345 0.216 34 | 33 0.120 82.970 14.036 0.252 0.079 35 | 34 0.366 85.650 12.923 0.247 0.709 36 | 35 0.544 66.363 5.484 0.890 0.392 37 | 36 0.620 75.260 5.320 0.878 0.479 38 | 37 0.013 127.875 24.197 0.007 0.135 39 | 39 0.189 80.250 17.476 0.111 0.639 40 | 40 0.123 39.038 8.084 0.969 0.065 41 | 41 0.117 82.024 13.603 0.338 0.070 42 | 42 0.204 105.792 26.975 0.140 0.376 43 | 43 0.603 100.737 8.515 0.722 0.518 44 | 44 0.101 93.552 25.732 0.055 0.587 45 | 45 0.140 86.925 17.127 0.165 0.121 46 | DM average 0.298178259934 +/- 0.177347661959 47 | HD average 86.6053868549 +/- 17.5118492011 48 | ASSD average 14.4946229774 +/- 8.42075769419 49 | Prec. average 0.495458887228 +/- 0.325639293572 50 | Rec. average 0.287347902695 +/- 0.178803160704 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lmg357.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.598 76.577 5.852 0.897 0.449 9 | 04 0.431 107.070 16.363 0.526 0.365 10 | 05 0.522 69.455 6.930 0.947 0.360 11 | 06 0.565 66.272 6.347 0.863 0.420 12 | 07 0.496 77.666 5.866 0.885 0.344 13 | 08 0.581 68.059 6.270 0.958 0.417 14 | 09 0.338 77.045 12.484 0.308 0.375 15 | 10 0.297 69.886 7.601 0.929 0.177 16 | 11 0.404 82.608 11.738 0.652 0.293 17 | 12 0.531 65.544 6.335 0.902 0.376 18 | 13 0.655 61.579 4.984 0.867 0.527 19 | 15 0.645 74.189 7.491 0.693 0.603 20 | 17 0.644 69.971 6.853 0.816 0.531 21 | 18 0.790 68.381 3.371 0.796 0.783 22 | 19 0.177 94.953 9.726 0.178 0.176 23 | 20 0.002 115.326 47.276 0.002 0.003 24 | 21 0.284 99.116 22.944 0.554 0.191 25 | 22 0.003 106.921 41.864 0.002 0.006 26 | 23 0.054 112.214 25.317 0.044 0.071 27 | 25 0.003 122.540 49.123 0.002 0.005 28 | 26 0.102 82.462 25.737 0.095 0.111 29 | 28 0.296 88.182 25.917 0.397 0.236 30 | 29 0.536 72.719 8.349 0.587 0.493 31 | 30 0.424 71.330 6.197 0.951 0.273 32 | 31 0.567 65.970 3.744 0.755 0.454 33 | 32 0.403 86.163 14.037 0.398 0.409 34 | 33 0.539 68.147 4.772 0.581 0.503 35 | 34 0.544 66.573 10.482 0.450 0.687 36 | 35 0.598 75.260 4.474 0.934 0.440 37 | 36 0.779 75.842 6.605 0.766 0.793 38 | 37 0.001 115.256 27.321 0.001 0.010 39 | 39 0.090 76.053 23.385 0.099 0.082 40 | 40 0.385 54.332 6.093 0.958 0.241 41 | 41 0.105 75.073 14.792 0.371 0.061 42 | 42 0.044 101.843 27.866 0.045 0.043 43 | 43 0.568 85.112 6.957 0.869 0.422 44 | 44 0.094 88.204 22.968 0.081 0.112 45 | 45 0.231 85.346 13.892 0.175 0.340 46 | DM average 0.377050217682 +/- 0.236088780395 47 | HD average 82.0851904374 +/- 16.7872268268 48 | ASSD average 14.6927154708 +/- 11.9190985317 49 | Prec. average 0.535113511054 +/- 0.348555541511 50 | Rec. average 0.320578610717 +/- 0.212624659937 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lmg3.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.326 90.532 8.148 0.632 0.219 9 | 04 0.182 113.243 24.127 0.134 0.283 10 | 05 0.310 79.070 7.574 0.653 0.203 11 | 06 0.315 84.024 9.901 0.439 0.245 12 | 07 0.375 88.182 10.546 0.562 0.282 13 | 08 0.360 86.741 8.755 0.680 0.245 14 | 09 0.107 87.704 17.803 0.064 0.341 15 | 10 0.268 87.476 9.255 0.619 0.171 16 | 11 0.255 93.574 16.664 0.220 0.302 17 | 12 0.337 92.671 11.039 0.508 0.252 18 | 13 0.364 80.324 9.912 0.482 0.293 19 | 15 0.266 89.196 15.757 0.214 0.353 20 | 17 0.315 89.978 11.776 0.355 0.283 21 | 18 0.279 80.025 11.789 0.260 0.301 22 | 19 0.121 100.737 21.516 0.081 0.232 23 | 20 0.029 121.161 38.972 0.020 0.056 24 | 21 0.170 106.226 27.107 0.179 0.163 25 | 22 0.010 115.065 36.917 0.006 0.048 26 | 23 0.083 118.878 28.576 0.056 0.163 27 | 25 0.022 126.807 40.593 0.013 0.069 28 | 26 0.156 90.443 23.015 0.118 0.230 29 | 28 0.193 91.978 23.045 0.215 0.174 30 | 29 0.263 90.929 12.839 0.223 0.319 31 | 30 0.326 89.889 8.201 0.634 0.219 32 | 31 0.331 86.046 11.323 0.334 0.328 33 | 32 0.227 96.540 17.923 0.209 0.249 34 | 33 0.285 88.250 11.043 0.293 0.278 35 | 34 0.201 86.787 15.008 0.137 0.375 36 | 35 0.373 78.664 8.522 0.553 0.281 37 | 36 0.315 85.299 13.384 0.320 0.310 38 | 37 0.003 125.618 28.418 0.001 0.072 39 | 39 0.067 88.295 22.104 0.039 0.250 40 | 40 0.337 70.086 6.186 0.788 0.214 41 | 41 0.174 88.182 14.384 0.274 0.127 42 | 42 0.069 105.698 26.190 0.048 0.126 43 | 43 0.327 96.167 14.315 0.418 0.269 44 | 44 0.045 90.973 24.050 0.025 0.266 45 | 45 0.157 91.782 16.946 0.113 0.260 46 | DM average 0.219501332483 +/- 0.116033043351 47 | HD average 94.0326143016 +/- 13.2495908664 48 | ASSD average 17.4636960804 +/- 8.90231028 49 | Prec. average 0.287338074729 +/- 0.226737905043 50 | Rec. average 0.232888311306 +/- 0.0822733968594 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lmg5.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.445 88.023 7.517 0.708 0.325 9 | 04 0.256 110.381 21.167 0.212 0.324 10 | 05 0.407 77.820 7.477 0.779 0.276 11 | 06 0.398 82.292 9.249 0.526 0.320 12 | 07 0.420 89.688 10.544 0.606 0.322 13 | 08 0.439 86.533 8.492 0.742 0.311 14 | 09 0.136 82.704 17.247 0.082 0.406 15 | 10 0.294 85.276 9.001 0.660 0.189 16 | 11 0.318 92.217 14.538 0.288 0.355 17 | 12 0.403 93.424 10.207 0.561 0.315 18 | 13 0.461 79.624 8.148 0.575 0.384 19 | 15 0.351 87.407 13.143 0.285 0.456 20 | 17 0.421 91.411 9.894 0.457 0.390 21 | 18 0.411 80.672 9.615 0.364 0.473 22 | 19 0.119 103.576 20.399 0.082 0.219 23 | 20 0.023 124.980 40.059 0.015 0.049 24 | 21 0.209 104.173 24.508 0.234 0.188 25 | 22 0.007 116.396 35.757 0.004 0.030 26 | 23 0.084 117.115 27.580 0.057 0.157 27 | 25 0.018 124.290 40.290 0.011 0.055 28 | 26 0.158 88.657 22.028 0.118 0.239 29 | 28 0.232 91.455 21.886 0.253 0.215 30 | 29 0.364 88.499 10.813 0.315 0.432 31 | 30 0.353 91.104 8.425 0.673 0.239 32 | 31 0.399 86.000 10.666 0.373 0.429 33 | 32 0.250 95.037 17.516 0.208 0.314 34 | 33 0.363 86.718 9.334 0.359 0.366 35 | 34 0.258 85.065 14.071 0.171 0.532 36 | 35 0.446 78.102 8.265 0.627 0.347 37 | 36 0.441 82.316 10.367 0.415 0.470 38 | 37 0.001 130.690 28.548 0.001 0.034 39 | 39 0.083 86.487 21.307 0.051 0.216 40 | 40 0.366 67.587 6.393 0.773 0.239 41 | 41 0.137 84.735 16.069 0.224 0.099 42 | 42 0.083 103.846 23.636 0.062 0.125 43 | 43 0.398 96.042 13.656 0.507 0.328 44 | 44 0.053 92.455 22.692 0.030 0.253 45 | 45 0.181 91.957 16.073 0.123 0.341 46 | DM average 0.268084178282 +/- 0.149764931494 47 | HD average 93.283044281 +/- 14.0135260672 48 | ASSD average 16.4887987247 +/- 8.92268493932 49 | Prec. average 0.329696008751 +/- 0.247964731046 50 | Rec. average 0.283206682021 +/- 0.127672584839 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.lmg7.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.565 88.679 8.205 0.741 0.456 9 | 04 0.271 113.031 20.577 0.248 0.298 10 | 05 0.493 78.435 7.572 0.830 0.351 11 | 06 0.464 81.633 9.476 0.608 0.375 12 | 07 0.414 90.355 11.194 0.584 0.321 13 | 08 0.521 87.864 8.571 0.800 0.386 14 | 09 0.146 84.095 16.922 0.091 0.373 15 | 10 0.277 87.155 8.834 0.654 0.176 16 | 11 0.329 89.308 13.785 0.305 0.357 17 | 12 0.427 93.574 10.228 0.584 0.336 18 | 13 0.548 78.816 8.584 0.631 0.485 19 | 15 0.421 90.200 12.838 0.346 0.539 20 | 17 0.499 88.792 9.626 0.519 0.480 21 | 18 0.597 82.438 9.568 0.496 0.749 22 | 19 0.093 102.489 20.054 0.063 0.176 23 | 20 0.018 119.766 38.194 0.011 0.042 24 | 21 0.192 104.480 23.339 0.229 0.166 25 | 22 0.008 116.241 34.838 0.004 0.027 26 | 23 0.055 117.132 25.602 0.039 0.093 27 | 25 0.011 125.491 37.392 0.007 0.034 28 | 26 0.125 88.679 20.652 0.096 0.178 29 | 28 0.247 92.628 20.499 0.273 0.225 30 | 29 0.445 88.295 11.711 0.382 0.531 31 | 30 0.342 89.554 8.655 0.695 0.227 32 | 31 0.423 87.384 11.747 0.384 0.471 33 | 32 0.278 96.519 17.932 0.227 0.359 34 | 33 0.484 86.603 10.884 0.420 0.570 35 | 34 0.311 84.617 13.319 0.217 0.552 36 | 35 0.479 77.589 8.246 0.660 0.376 37 | 36 0.621 85.417 10.604 0.530 0.751 38 | 37 0.004 124.145 28.247 0.002 0.087 39 | 39 0.075 88.431 21.074 0.049 0.155 40 | 40 0.370 68.673 6.351 0.744 0.246 41 | 41 0.105 86.741 16.073 0.188 0.073 42 | 42 0.088 103.730 23.299 0.074 0.108 43 | 43 0.424 94.043 13.004 0.546 0.346 44 | 44 0.045 91.630 22.297 0.026 0.166 45 | 45 0.178 90.443 17.025 0.120 0.347 46 | DM average 0.299824242535 +/- 0.189721376441 47 | HD average 93.2919822013 +/- 13.2019039338 48 | ASSD average 16.2372327222 +/- 8.28262257012 49 | Prec. average 0.353233096085 +/- 0.26309081721 50 | Rec. average 0.3155563734 +/- 0.185598543008 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/pre.b0s1.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.699 30.529 5.599 0.952 0.553 10 | 04 0.748 58.549 4.821 0.691 0.816 11 | 05 0.648 31.496 6.455 0.986 0.482 12 | 06 0.789 20.396 3.163 0.876 0.718 13 | 07 0.872 11.489 1.893 0.929 0.821 14 | 08 0.782 36.056 4.422 0.981 0.650 15 | 09 0.672 9.798 2.219 0.639 0.709 16 | 10 0.657 22.804 4.977 0.987 0.492 17 | 11 0.688 20.688 2.658 0.939 0.543 18 | 12 0.826 19.900 2.588 0.954 0.728 19 | 13 0.828 25.768 2.702 0.894 0.771 20 | 15 0.810 14.967 2.056 0.812 0.808 21 | 17 0.815 16.371 2.448 0.813 0.816 22 | 18 0.862 16.613 1.612 0.894 0.832 23 | 19 0.716 10.392 2.087 0.703 0.730 24 | 20 0.248 42.426 11.765 0.701 0.151 25 | 21 0.655 96.229 7.871 0.894 0.517 26 | 22 0.014 107.981 40.011 0.010 0.021 27 | 23 0.474 54.589 7.878 0.791 0.338 28 | 25 0.212 96.871 36.485 0.217 0.207 29 | 26 0.468 30.529 3.889 0.890 0.317 30 | 28 0.585 76.026 7.683 0.931 0.426 31 | 29 0.735 40.694 3.781 0.889 0.627 32 | 30 0.765 25.612 3.621 0.974 0.630 33 | 31 0.702 19.698 2.568 0.852 0.597 34 | 32 0.571 68.206 10.851 0.473 0.720 35 | 33 0.628 46.174 5.891 0.663 0.596 36 | 34 0.700 40.050 6.692 0.599 0.842 37 | 35 0.861 15.362 2.054 0.953 0.786 38 | 36 0.856 14.142 1.846 0.854 0.857 39 | 37 0.000 73.783 32.393 0.000 0.000 40 | 39 0.561 16.125 2.866 0.888 0.410 41 | 40 0.497 44.721 7.555 0.990 0.332 42 | 41 0.310 27.928 7.060 0.869 0.189 43 | 42 0.654 22.978 2.956 0.868 0.524 44 | 43 0.827 16.125 2.563 0.904 0.762 45 | 44 0.539 23.495 3.475 0.748 0.421 46 | 45 0.424 38.678 7.581 0.365 0.506 47 | DM average 0.623606035514 +/- 0.220511290183 48 | HD average 36.4273256335 +/- 25.3376659464 49 | ASSD average 7.07984487335 +/- 8.95814501101 50 | Prec. average 0.773068884663 +/- 0.249488412848 51 | Rec. average 0.559034587331 +/- 0.232773390205 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b1s1.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.638 34.234 6.813 0.974 0.474 10 | 04 0.732 68.352 6.554 0.683 0.790 11 | 05 0.342 38.523 11.216 0.995 0.206 12 | 06 0.804 20.881 2.989 0.905 0.723 13 | 07 0.878 12.961 1.782 0.949 0.817 14 | 08 0.700 26.683 5.292 0.986 0.542 15 | 09 0.554 77.305 8.457 0.430 0.779 16 | 10 0.492 26.382 7.395 0.993 0.327 17 | 11 0.585 44.091 6.098 0.948 0.424 18 | 12 0.827 15.620 2.411 0.968 0.722 19 | 13 0.811 25.456 2.824 0.912 0.730 20 | 15 0.814 14.967 1.958 0.828 0.801 21 | 17 0.818 15.100 2.439 0.799 0.837 22 | 18 0.781 22.891 2.800 0.848 0.723 23 | 19 0.545 70.965 7.581 0.431 0.744 24 | 20 0.805 72.719 10.975 0.743 0.878 25 | 21 0.820 18.000 2.151 0.941 0.727 26 | 22 0.297 23.580 6.665 0.229 0.423 27 | 23 0.382 98.265 20.107 0.267 0.669 28 | 25 0.593 54.000 5.837 0.490 0.751 29 | 26 0.715 22.091 2.673 0.603 0.879 30 | 28 0.823 26.000 2.750 0.818 0.827 31 | 29 0.739 45.387 4.250 0.831 0.666 32 | 30 0.504 22.181 5.657 0.962 0.341 33 | 31 0.730 16.248 2.285 0.851 0.639 34 | 32 0.536 68.235 13.261 0.485 0.598 35 | 33 0.577 46.861 6.261 0.792 0.453 36 | 34 0.725 39.038 6.296 0.660 0.803 37 | 35 0.815 12.649 2.613 0.945 0.717 38 | 36 0.848 14.142 2.039 0.812 0.887 39 | 37 0.000 57.793 33.373 0.000 0.000 40 | 39 0.639 11.489 2.438 0.696 0.591 41 | 40 0.168 50.160 10.825 0.958 0.092 42 | 41 0.059 55.714 14.902 0.937 0.030 43 | 42 0.586 16.125 3.074 0.928 0.429 44 | 43 0.735 17.205 3.666 0.940 0.604 45 | 44 0.024 25.768 6.365 0.900 0.012 46 | 45 0.473 18.974 4.988 0.646 0.374 47 | DM average 0.603021786864 +/- 0.236616376356 48 | HD average 35.4482352197 +/- 22.0895662158 49 | ASSD average 6.58043965474 +/- 5.96667987823 50 | Prec. average 0.765337069867 +/- 0.239692998417 51 | Rec. average 0.57972921722 +/- 0.253460620898 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth25.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.687 31.048 5.744 0.960 0.535 10 | 04 0.767 10.770 2.460 0.719 0.821 11 | 05 0.657 32.311 6.344 0.983 0.494 12 | 06 0.790 19.799 3.129 0.879 0.718 13 | 07 0.872 11.314 1.911 0.931 0.820 14 | 08 0.778 36.056 4.511 0.974 0.647 15 | 09 0.658 9.798 2.376 0.605 0.722 16 | 10 0.650 22.000 5.074 0.985 0.485 17 | 11 0.708 20.591 2.517 0.925 0.573 18 | 12 0.831 18.868 2.493 0.955 0.736 19 | 13 0.829 25.768 2.664 0.900 0.768 20 | 15 0.804 14.000 2.087 0.807 0.801 21 | 17 0.816 15.362 2.406 0.814 0.817 22 | 18 0.864 17.550 1.606 0.897 0.833 23 | 19 0.725 10.954 2.053 0.725 0.725 24 | 20 0.221 42.000 11.913 0.655 0.133 25 | 21 0.667 96.623 7.913 0.894 0.532 26 | 22 0.016 107.070 38.394 0.012 0.024 27 | 23 0.488 53.292 9.532 0.738 0.365 28 | 25 0.201 93.702 36.938 0.205 0.198 29 | 26 0.466 30.594 3.683 0.870 0.318 30 | 28 0.591 76.968 7.950 0.926 0.434 31 | 29 0.747 39.497 3.581 0.891 0.643 32 | 30 0.760 25.377 3.684 0.973 0.624 33 | 31 0.698 19.287 2.571 0.866 0.585 34 | 32 0.576 68.615 10.951 0.474 0.735 35 | 33 0.626 46.690 5.786 0.664 0.592 36 | 34 0.659 41.665 7.379 0.534 0.860 37 | 35 0.854 18.000 2.201 0.949 0.777 38 | 36 0.854 14.283 1.885 0.851 0.858 39 | 37 0.000 72.774 33.191 0.000 0.000 40 | 39 0.529 18.547 3.272 0.894 0.376 41 | 40 0.502 44.766 7.564 0.987 0.337 42 | 41 0.320 28.636 7.102 0.878 0.196 43 | 42 0.673 22.804 2.789 0.892 0.540 44 | 43 0.821 16.125 2.591 0.905 0.751 45 | 44 0.532 23.495 3.591 0.721 0.421 46 | 45 0.454 36.932 6.987 0.401 0.523 47 | DM average 0.623511989476 +/- 0.221276873926 48 | HD average 35.1034310356 +/- 25.0969000613 49 | ASSD average 7.07423187279 +/- 8.937646288 50 | Prec. average 0.769485996381 +/- 0.250764756416 51 | Rec. average 0.560962014086 +/- 0.23376059543 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b0s1_r2.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.700 29.394 5.502 0.954 0.552 10 | 04 0.749 33.941 3.314 0.698 0.808 11 | 05 0.642 31.875 6.659 0.987 0.475 12 | 06 0.787 19.900 3.221 0.871 0.719 13 | 07 0.872 10.954 1.928 0.916 0.831 14 | 08 0.779 36.277 4.513 0.979 0.647 15 | 09 0.651 9.165 2.450 0.576 0.748 16 | 10 0.660 22.978 4.956 0.985 0.496 17 | 11 0.687 20.591 2.767 0.921 0.548 18 | 12 0.834 18.868 2.475 0.960 0.737 19 | 13 0.828 25.768 2.671 0.902 0.765 20 | 15 0.803 14.697 2.109 0.805 0.802 21 | 17 0.808 15.748 2.526 0.808 0.808 22 | 18 0.865 16.492 1.589 0.913 0.821 23 | 19 0.717 12.000 2.151 0.707 0.728 24 | 20 0.213 42.426 12.113 0.637 0.128 25 | 21 0.657 96.208 7.637 0.907 0.515 26 | 22 0.016 107.981 39.429 0.012 0.025 27 | 23 0.473 53.442 9.633 0.750 0.345 28 | 25 0.212 92.801 35.721 0.225 0.201 29 | 26 0.447 29.732 3.968 0.917 0.296 30 | 28 0.598 76.968 7.862 0.935 0.439 31 | 29 0.728 39.497 3.815 0.885 0.619 32 | 30 0.766 24.739 3.554 0.972 0.632 33 | 31 0.713 19.799 2.424 0.855 0.611 34 | 32 0.566 69.340 11.392 0.463 0.727 35 | 33 0.619 46.733 6.685 0.643 0.596 36 | 34 0.711 42.000 6.546 0.616 0.840 37 | 35 0.856 17.088 2.162 0.953 0.777 38 | 36 0.857 12.961 1.819 0.850 0.865 39 | 37 0.000 79.246 33.453 0.000 0.000 40 | 39 0.553 18.439 3.061 0.945 0.390 41 | 40 0.481 46.433 7.917 0.990 0.318 42 | 41 0.319 28.142 7.106 0.878 0.195 43 | 42 0.660 22.716 2.826 0.883 0.526 44 | 43 0.822 16.125 2.617 0.911 0.748 45 | 44 0.558 23.152 3.348 0.735 0.449 46 | 45 0.431 38.471 7.617 0.380 0.498 47 | DM average 0.621991601791 +/- 0.221834676272 48 | HD average 35.8707183167 +/- 25.1506406547 49 | ASSD average 7.14568381388 +/- 8.94317820943 50 | Prec. average 0.771638139793 +/- 0.251821797435 51 | Rec. average 0.55859700772 +/- 0.234242660624 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b0s1_r3.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.697 29.732 5.594 0.955 0.549 10 | 04 0.732 57.827 5.286 0.662 0.818 11 | 05 0.647 32.863 6.498 0.985 0.482 12 | 06 0.787 19.596 3.183 0.873 0.717 13 | 07 0.874 10.770 1.890 0.923 0.830 14 | 08 0.778 36.277 4.524 0.981 0.644 15 | 09 0.665 8.944 2.337 0.628 0.706 16 | 10 0.656 22.000 4.931 0.986 0.492 17 | 11 0.684 20.688 2.844 0.937 0.539 18 | 12 0.832 19.900 2.490 0.965 0.731 19 | 13 0.832 24.900 2.631 0.898 0.775 20 | 15 0.805 14.697 2.081 0.815 0.796 21 | 17 0.818 17.550 2.415 0.827 0.809 22 | 18 0.865 17.205 1.588 0.912 0.822 23 | 19 0.726 14.560 2.116 0.714 0.738 24 | 20 0.174 40.546 13.471 0.607 0.102 25 | 21 0.650 97.755 7.991 0.894 0.511 26 | 22 0.012 107.981 39.854 0.009 0.017 27 | 23 0.465 55.642 10.937 0.722 0.343 28 | 25 0.204 92.087 36.635 0.211 0.199 29 | 26 0.389 31.623 4.196 0.900 0.248 30 | 28 0.605 76.158 7.439 0.932 0.448 31 | 29 0.735 39.497 3.753 0.887 0.628 32 | 30 0.762 24.819 3.623 0.978 0.625 33 | 31 0.693 20.396 2.658 0.850 0.584 34 | 32 0.597 68.235 10.578 0.508 0.724 35 | 33 0.608 46.174 6.085 0.655 0.566 36 | 34 0.683 41.231 7.096 0.576 0.839 37 | 35 0.853 16.125 2.227 0.951 0.773 38 | 36 0.856 12.961 1.867 0.851 0.860 39 | 37 0.000 77.201 33.962 0.000 0.000 40 | 39 0.513 19.698 3.323 0.965 0.350 41 | 40 0.483 44.766 7.817 0.992 0.319 42 | 41 0.310 28.071 7.158 0.872 0.188 43 | 42 0.627 87.932 9.049 0.813 0.510 44 | 43 0.817 16.125 2.680 0.903 0.745 45 | 44 0.549 23.495 3.490 0.723 0.443 46 | 45 0.444 36.932 7.263 0.390 0.515 47 | DM average 0.616455480822 +/- 0.22573983758 48 | HD average 38.2357492998 +/- 26.3583823022 49 | ASSD average 7.46213477105 +/- 9.07420510848 50 | Prec. average 0.769726430923 +/- 0.251685794146 51 | Rec. average 0.552195554185 +/- 0.237613864609 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/pre.b1s1_r3.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.623 34.234 6.966 0.972 0.458 10 | 04 0.726 67.676 6.304 0.665 0.800 11 | 05 0.339 36.932 10.994 0.995 0.204 12 | 06 0.802 20.100 3.019 0.901 0.723 13 | 07 0.878 12.806 1.799 0.942 0.823 14 | 08 0.694 26.000 5.406 0.986 0.536 15 | 09 0.527 77.305 9.252 0.402 0.765 16 | 10 0.499 30.529 7.398 0.992 0.333 17 | 11 0.590 44.045 6.097 0.948 0.428 18 | 12 0.827 16.125 2.445 0.970 0.720 19 | 13 0.815 25.456 2.775 0.907 0.739 20 | 15 0.815 14.967 1.980 0.826 0.803 21 | 17 0.809 16.125 2.530 0.777 0.845 22 | 18 0.778 19.698 2.658 0.850 0.717 23 | 19 0.522 71.694 7.884 0.394 0.775 24 | 20 0.792 72.966 11.198 0.721 0.879 25 | 21 0.817 16.971 2.159 0.944 0.719 26 | 22 0.326 19.079 6.158 0.261 0.432 27 | 23 0.372 99.156 21.169 0.261 0.646 28 | 25 0.591 55.064 6.039 0.485 0.755 29 | 26 0.707 20.494 2.766 0.589 0.883 30 | 28 0.824 26.533 2.698 0.821 0.827 31 | 29 0.741 45.166 4.215 0.838 0.664 32 | 30 0.519 23.749 5.551 0.950 0.357 33 | 31 0.750 14.000 2.116 0.855 0.669 34 | 32 0.533 68.993 13.401 0.471 0.613 35 | 33 0.609 46.861 5.931 0.828 0.482 36 | 34 0.728 38.471 6.121 0.677 0.786 37 | 35 0.822 12.329 2.542 0.948 0.725 38 | 36 0.845 12.961 2.054 0.804 0.891 39 | 37 0.000 60.166 34.678 0.000 0.000 40 | 39 0.632 13.416 2.421 0.768 0.537 41 | 40 0.148 55.172 11.336 0.966 0.080 42 | 41 0.078 54.663 14.813 0.942 0.041 43 | 42 0.605 15.748 2.989 0.924 0.450 44 | 43 0.706 67.676 5.240 0.935 0.567 45 | 44 0.049 46.433 9.985 0.864 0.025 46 | 45 0.484 18.868 4.900 0.628 0.394 47 | DM average 0.603206956234 +/- 0.233367503161 48 | HD average 37.3322367222 +/- 22.8608812339 49 | ASSD average 6.78914931742 +/- 6.21940251341 50 | Prec. average 0.763354173057 +/- 0.240974712331 51 | Rec. average 0.581416634846 +/- 0.252287624446 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth10.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.639 32.619 6.753 0.966 0.478 10 | 04 0.744 10.770 2.624 0.777 0.714 11 | 05 0.621 34.467 7.376 0.990 0.453 12 | 06 0.786 21.260 3.246 0.915 0.689 13 | 07 0.837 14.142 2.364 0.953 0.746 14 | 08 0.727 37.947 5.541 0.991 0.574 15 | 09 0.647 11.314 2.471 0.659 0.636 16 | 10 0.581 24.819 6.155 0.990 0.411 17 | 11 0.608 21.633 3.381 0.943 0.449 18 | 12 0.789 24.658 3.298 0.960 0.669 19 | 13 0.813 25.768 2.869 0.915 0.731 20 | 15 0.795 16.125 2.220 0.807 0.783 21 | 17 0.795 19.391 2.733 0.838 0.757 22 | 18 0.832 16.613 1.944 0.887 0.784 23 | 19 0.653 13.856 2.372 0.845 0.532 24 | 20 0.174 40.546 14.152 0.583 0.102 25 | 21 0.508 95.205 10.339 0.893 0.355 26 | 22 0.000 106.395 45.930 0.000 0.000 27 | 23 0.344 35.327 6.118 0.894 0.213 28 | 25 0.129 91.324 38.691 0.173 0.103 29 | 26 0.267 33.166 5.155 0.941 0.156 30 | 28 0.496 39.446 6.882 0.958 0.335 31 | 29 0.691 42.942 4.314 0.881 0.568 32 | 30 0.712 26.153 4.505 0.986 0.557 33 | 31 0.642 19.900 3.089 0.855 0.514 34 | 32 0.557 66.723 9.256 0.530 0.588 35 | 33 0.591 44.407 5.785 0.718 0.502 36 | 34 0.654 40.100 7.182 0.539 0.833 37 | 35 0.811 16.613 2.749 0.963 0.700 38 | 36 0.846 17.088 1.990 0.876 0.818 39 | 37 0.000 72.774 32.177 0.000 0.000 40 | 39 0.486 17.321 3.486 0.922 0.330 41 | 40 0.382 48.703 9.592 0.987 0.237 42 | 41 0.282 34.000 8.144 0.868 0.168 43 | 42 0.601 24.166 3.355 0.902 0.451 44 | 43 0.792 17.550 3.013 0.916 0.698 45 | 44 0.436 24.739 4.200 0.795 0.301 46 | 45 0.368 37.417 8.633 0.321 0.432 47 | DM average 0.569440380197 +/- 0.231801082585 48 | HD average 34.668120847 +/- 23.0563457892 49 | ASSD average 7.73910235896 +/- 9.66304477893 50 | Prec. average 0.787777599221 +/- 0.260197632504 51 | Rec. average 0.483327775711 +/- 0.235426108491 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth100.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.698 30.790 5.592 0.954 0.550 10 | 04 0.743 58.412 5.033 0.679 0.819 11 | 05 0.640 33.106 6.608 0.983 0.474 12 | 06 0.789 19.287 3.157 0.875 0.718 13 | 07 0.876 11.662 1.848 0.929 0.828 14 | 08 0.779 35.889 4.474 0.981 0.645 15 | 09 0.640 10.000 2.483 0.581 0.713 16 | 10 0.657 21.909 4.965 0.987 0.493 17 | 11 0.675 20.688 2.761 0.931 0.530 18 | 12 0.834 18.868 2.434 0.959 0.737 19 | 13 0.828 24.900 2.646 0.898 0.769 20 | 15 0.804 14.560 2.082 0.811 0.797 21 | 17 0.816 15.362 2.388 0.825 0.807 22 | 18 0.864 16.492 1.598 0.901 0.829 23 | 19 0.716 13.565 2.152 0.713 0.720 24 | 20 0.217 42.426 11.950 0.649 0.130 25 | 21 0.625 96.519 8.746 0.890 0.482 26 | 22 0.018 107.981 39.225 0.014 0.028 27 | 23 0.462 54.443 10.172 0.754 0.333 28 | 25 0.203 96.395 37.430 0.200 0.205 29 | 26 0.434 31.048 3.856 0.901 0.286 30 | 28 0.599 76.158 7.100 0.936 0.440 31 | 29 0.724 40.546 3.874 0.880 0.614 32 | 30 0.763 25.768 3.664 0.973 0.627 33 | 31 0.705 19.799 2.488 0.867 0.594 34 | 32 0.570 68.615 11.108 0.471 0.724 35 | 33 0.622 46.690 5.871 0.683 0.570 36 | 34 0.684 42.000 6.959 0.573 0.848 37 | 35 0.857 14.697 2.147 0.951 0.779 38 | 36 0.857 14.142 1.846 0.856 0.857 39 | 37 0.000 72.829 33.267 0.000 0.000 40 | 39 0.492 18.547 3.415 0.976 0.329 41 | 40 0.491 44.721 7.693 0.986 0.327 42 | 41 0.328 27.495 7.003 0.881 0.201 43 | 42 0.644 22.000 2.887 0.890 0.504 44 | 43 0.822 16.125 2.588 0.914 0.747 45 | 44 0.529 24.166 3.687 0.728 0.416 46 | 45 0.438 37.789 7.416 0.383 0.513 47 | DM average 0.616859586463 +/- 0.222194230933 48 | HD average 36.4839787761 +/- 25.2789350215 49 | ASSD average 7.2266134887 +/- 9.03867298376 50 | Prec. average 0.772726627209 +/- 0.253655541897 51 | Rec. average 0.552227465014 +/- 0.235227143105 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth1000.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.695 31.048 5.566 0.961 0.545 10 | 04 0.739 57.236 4.597 0.684 0.805 11 | 05 0.638 32.062 6.629 0.985 0.472 12 | 06 0.790 20.396 3.172 0.871 0.722 13 | 07 0.874 10.770 1.870 0.923 0.831 14 | 08 0.785 36.277 4.401 0.979 0.655 15 | 09 0.663 9.381 2.338 0.600 0.741 16 | 10 0.659 22.000 4.973 0.987 0.494 17 | 11 0.683 20.591 2.720 0.933 0.538 18 | 12 0.830 18.868 2.508 0.958 0.733 19 | 13 0.830 24.495 2.610 0.901 0.770 20 | 15 0.808 14.967 2.050 0.812 0.805 21 | 17 0.812 17.205 2.493 0.809 0.815 22 | 18 0.863 17.088 1.585 0.924 0.810 23 | 19 0.721 12.000 2.101 0.742 0.702 24 | 20 0.223 40.100 11.780 0.654 0.135 25 | 21 0.650 96.416 8.325 0.889 0.512 26 | 22 0.015 107.815 40.235 0.011 0.024 27 | 23 0.545 53.292 6.647 0.818 0.409 28 | 25 0.202 96.519 37.955 0.196 0.208 29 | 26 0.459 30.265 3.796 0.913 0.306 30 | 28 0.599 76.026 7.412 0.936 0.441 31 | 29 0.737 39.799 3.791 0.875 0.636 32 | 30 0.761 24.739 3.689 0.974 0.624 33 | 31 0.695 19.799 2.579 0.866 0.581 34 | 32 0.584 67.350 10.562 0.487 0.729 35 | 33 0.622 46.690 5.887 0.660 0.588 36 | 34 0.693 41.085 6.886 0.586 0.850 37 | 35 0.860 14.697 2.119 0.948 0.787 38 | 36 0.858 14.142 1.860 0.851 0.864 39 | 37 0.000 76.184 33.631 0.000 0.000 40 | 39 0.524 17.664 3.211 0.893 0.370 41 | 40 0.491 45.122 7.745 0.989 0.327 42 | 41 0.328 27.495 6.902 0.883 0.201 43 | 42 0.619 23.152 3.052 0.902 0.471 44 | 43 0.824 16.000 2.559 0.909 0.753 45 | 44 0.512 24.166 3.733 0.718 0.398 46 | 45 0.432 38.523 7.481 0.379 0.502 47 | DM average 0.621716779127 +/- 0.220825357702 48 | HD average 36.3532884949 +/- 25.3193600739 49 | ASSD average 7.1434050747 +/- 9.19084160678 50 | Prec. average 0.773876314656 +/- 0.252408504528 51 | Rec. average 0.556701278017 +/- 0.2331643142 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth1500.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.689 31.048 5.720 0.959 0.538 10 | 04 0.764 14.697 2.553 0.710 0.828 11 | 05 0.643 33.226 6.732 0.984 0.478 12 | 06 0.793 19.287 3.139 0.874 0.726 13 | 07 0.877 10.770 1.811 0.936 0.825 14 | 08 0.778 36.000 4.517 0.979 0.645 15 | 09 0.663 8.944 2.302 0.624 0.708 16 | 10 0.650 22.361 5.073 0.986 0.485 17 | 11 0.683 20.976 2.864 0.934 0.538 18 | 12 0.832 18.547 2.486 0.957 0.735 19 | 13 0.826 24.900 2.687 0.900 0.763 20 | 15 0.809 14.967 2.052 0.809 0.808 21 | 17 0.818 15.748 2.413 0.819 0.817 22 | 18 0.865 17.088 1.602 0.909 0.826 23 | 19 0.706 16.125 2.483 0.688 0.725 24 | 20 0.242 40.546 12.082 0.683 0.147 25 | 21 0.639 96.416 7.955 0.903 0.494 26 | 22 0.014 107.107 39.531 0.010 0.021 27 | 23 0.545 26.608 4.143 0.882 0.394 28 | 25 0.198 92.650 35.545 0.203 0.192 29 | 26 0.457 30.594 3.756 0.903 0.306 30 | 28 0.605 76.158 7.577 0.925 0.449 31 | 29 0.727 40.841 3.934 0.873 0.622 32 | 30 0.758 24.739 3.698 0.972 0.621 33 | 31 0.697 19.698 2.652 0.854 0.589 34 | 32 0.581 69.971 10.893 0.482 0.732 35 | 33 0.611 46.690 6.194 0.665 0.566 36 | 34 0.684 42.000 7.052 0.579 0.836 37 | 35 0.861 16.000 2.107 0.946 0.790 38 | 36 0.857 14.283 1.869 0.849 0.865 39 | 37 0.000 73.457 32.261 0.000 0.000 40 | 39 0.458 18.547 3.641 0.991 0.298 41 | 40 0.500 44.766 7.564 0.988 0.335 42 | 41 0.306 27.857 7.133 0.866 0.186 43 | 42 0.638 90.730 8.290 0.811 0.525 44 | 43 0.826 16.125 2.548 0.909 0.756 45 | 44 0.551 22.450 3.499 0.694 0.457 46 | 45 0.438 37.683 7.453 0.377 0.522 47 | DM average 0.620763349342 +/- 0.221561149952 48 | HD average 36.3316241351 +/- 26.2881288662 49 | ASSD average 7.1002882967 +/- 8.81658572196 50 | Prec. average 0.774567814989 +/- 0.252708532382 51 | Rec. average 0.556582503424 +/- 0.235003207558 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth2000.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.692 32.062 5.762 0.960 0.541 10 | 04 0.766 10.770 2.470 0.712 0.827 11 | 05 0.650 33.226 6.422 0.983 0.485 12 | 06 0.796 19.799 3.079 0.876 0.730 13 | 07 0.874 11.489 1.872 0.922 0.831 14 | 08 0.784 36.056 4.364 0.976 0.656 15 | 09 0.661 8.944 2.321 0.597 0.741 16 | 10 0.656 21.633 4.988 0.986 0.492 17 | 11 0.673 20.688 2.846 0.924 0.530 18 | 12 0.833 19.900 2.509 0.955 0.738 19 | 13 0.829 24.900 2.644 0.904 0.765 20 | 15 0.810 15.100 2.061 0.815 0.805 21 | 17 0.811 18.000 2.521 0.814 0.808 22 | 18 0.869 17.205 1.552 0.908 0.833 23 | 19 0.718 13.115 2.103 0.729 0.707 24 | 20 0.233 42.426 11.486 0.691 0.140 25 | 21 0.662 95.603 7.488 0.902 0.522 26 | 22 0.021 107.350 39.142 0.015 0.031 27 | 23 0.505 54.295 8.271 0.788 0.372 28 | 25 0.214 92.304 35.812 0.225 0.205 29 | 26 0.437 69.340 6.595 0.850 0.294 30 | 28 0.591 36.111 5.448 0.954 0.428 31 | 29 0.723 38.419 3.809 0.888 0.609 32 | 30 0.773 24.413 3.526 0.973 0.641 33 | 31 0.685 19.900 2.681 0.876 0.562 34 | 32 0.582 69.340 11.124 0.484 0.729 35 | 33 0.635 46.690 5.761 0.660 0.611 36 | 34 0.687 41.665 6.907 0.586 0.829 37 | 35 0.859 16.125 2.124 0.950 0.785 38 | 36 0.861 14.142 1.757 0.867 0.854 39 | 37 0.000 76.184 33.487 0.000 0.000 40 | 39 0.453 20.000 3.735 0.985 0.294 41 | 40 0.486 44.766 7.845 0.989 0.322 42 | 41 0.328 28.355 7.061 0.871 0.202 43 | 42 0.630 85.463 8.118 0.816 0.514 44 | 43 0.821 16.125 2.610 0.912 0.746 45 | 44 0.549 23.495 3.475 0.712 0.447 46 | 45 0.438 38.523 7.350 0.383 0.512 47 | DM average 0.620837916021 +/- 0.221571576758 48 | HD average 36.9452933092 +/- 25.916729756 49 | ASSD average 7.18756053015 +/- 8.87726925392 50 | Prec. average 0.774633709007 +/- 0.250121652001 51 | Rec. average 0.556270352851 +/- 0.234883005987 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth50.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.698 30.199 5.614 0.957 0.549 10 | 04 0.756 30.854 2.844 0.707 0.811 11 | 05 0.641 33.287 6.660 0.985 0.475 12 | 06 0.790 19.799 3.162 0.881 0.716 13 | 07 0.876 11.314 1.858 0.926 0.831 14 | 08 0.784 33.166 4.341 0.979 0.653 15 | 09 0.684 9.798 2.138 0.643 0.730 16 | 10 0.659 21.726 4.955 0.982 0.496 17 | 11 0.692 20.591 2.692 0.928 0.551 18 | 12 0.834 19.900 2.501 0.952 0.742 19 | 13 0.831 25.768 2.643 0.908 0.766 20 | 15 0.804 14.967 2.097 0.807 0.800 21 | 17 0.812 15.748 2.492 0.812 0.812 22 | 18 0.868 17.205 1.568 0.916 0.824 23 | 19 0.715 11.489 2.193 0.687 0.746 24 | 20 0.247 41.085 12.406 0.647 0.153 25 | 21 0.632 96.291 8.270 0.892 0.489 26 | 22 0.014 107.201 39.630 0.011 0.021 27 | 23 0.539 53.292 6.756 0.802 0.406 28 | 25 0.205 92.844 36.483 0.202 0.209 29 | 26 0.427 31.048 3.873 0.869 0.283 30 | 28 0.601 36.715 5.396 0.946 0.441 31 | 29 0.734 40.546 3.834 0.878 0.631 32 | 30 0.765 24.739 3.571 0.973 0.630 33 | 31 0.692 18.974 2.625 0.860 0.579 34 | 32 0.582 70.114 11.227 0.486 0.724 35 | 33 0.604 46.690 6.912 0.634 0.577 36 | 34 0.695 42.190 6.934 0.594 0.836 37 | 35 0.853 16.000 2.200 0.950 0.774 38 | 36 0.858 14.142 1.848 0.852 0.865 39 | 37 0.000 73.457 32.667 0.000 0.000 40 | 39 0.484 18.547 3.408 0.975 0.322 41 | 40 0.487 44.766 7.789 0.988 0.323 42 | 41 0.339 27.857 6.901 0.879 0.210 43 | 42 0.653 21.726 2.954 0.868 0.523 44 | 43 0.822 16.000 2.612 0.905 0.753 45 | 44 0.540 23.065 3.620 0.675 0.451 46 | 45 0.417 37.789 7.700 0.359 0.498 47 | DM average 0.621909036456 +/- 0.221053979107 48 | HD average 34.4970898912 +/- 23.8978803198 49 | ASSD average 7.0361972846 +/- 8.96716152061 50 | Prec. average 0.771455473501 +/- 0.253162547275 51 | Rec. average 0.557885520816 +/- 0.233183141492 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth500.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.700 30.332 5.564 0.954 0.552 10 | 04 0.752 30.332 2.939 0.698 0.815 11 | 05 0.652 32.558 6.503 0.983 0.488 12 | 06 0.794 20.494 3.113 0.879 0.725 13 | 07 0.876 11.314 1.852 0.927 0.830 14 | 08 0.778 36.986 4.538 0.980 0.645 15 | 09 0.655 9.165 2.378 0.593 0.732 16 | 10 0.655 22.978 5.026 0.986 0.490 17 | 11 0.687 20.976 2.849 0.935 0.543 18 | 12 0.834 18.547 2.477 0.954 0.740 19 | 13 0.830 25.377 2.649 0.898 0.772 20 | 15 0.814 14.000 1.987 0.819 0.809 21 | 17 0.811 17.205 2.511 0.812 0.811 22 | 18 0.865 16.971 1.611 0.900 0.832 23 | 19 0.720 12.329 2.138 0.721 0.718 24 | 20 0.207 41.085 12.323 0.630 0.124 25 | 21 0.658 96.519 8.325 0.887 0.523 26 | 22 0.016 107.815 38.753 0.012 0.024 27 | 23 0.545 53.292 6.759 0.791 0.416 28 | 25 0.222 92.801 34.512 0.241 0.206 29 | 26 0.455 31.177 3.854 0.896 0.305 30 | 28 0.601 76.968 7.491 0.931 0.444 31 | 29 0.734 41.857 3.930 0.881 0.630 32 | 30 0.759 24.900 3.715 0.977 0.621 33 | 31 0.692 19.698 2.660 0.851 0.583 34 | 32 0.580 68.411 10.975 0.482 0.729 35 | 33 0.641 46.690 5.681 0.674 0.610 36 | 34 0.683 40.100 6.999 0.572 0.847 37 | 35 0.859 16.000 2.122 0.948 0.784 38 | 36 0.857 13.266 1.874 0.846 0.870 39 | 37 0.000 73.783 32.715 0.000 0.000 40 | 39 0.569 14.697 2.748 0.912 0.413 41 | 40 0.481 44.721 7.841 0.989 0.318 42 | 41 0.321 28.142 7.018 0.862 0.197 43 | 42 0.661 22.891 2.930 0.862 0.536 44 | 43 0.826 16.125 2.557 0.906 0.759 45 | 44 0.529 23.495 3.689 0.756 0.406 46 | 45 0.431 38.523 7.557 0.371 0.513 47 | DM average 0.62496151331 +/- 0.220950018752 48 | HD average 35.5925808118 +/- 24.8978921449 49 | ASSD average 6.97802307904 +/- 8.71478976301 50 | Prec. average 0.771449819926 +/- 0.249276443063 51 | Rec. average 0.562113727393 +/- 0.233759234515 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/rdf.tdepth75.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.700 29.257 5.569 0.957 0.552 10 | 04 0.748 58.822 4.292 0.690 0.815 11 | 05 0.640 33.226 6.666 0.983 0.474 12 | 06 0.791 19.799 3.153 0.877 0.720 13 | 07 0.867 10.770 1.967 0.924 0.816 14 | 08 0.783 35.440 4.425 0.972 0.656 15 | 09 0.678 8.944 2.231 0.619 0.749 16 | 10 0.657 22.450 5.006 0.985 0.493 17 | 11 0.678 20.976 2.846 0.934 0.532 18 | 12 0.832 20.000 2.491 0.956 0.736 19 | 13 0.826 25.768 2.668 0.898 0.765 20 | 15 0.807 14.967 2.079 0.807 0.806 21 | 17 0.807 16.613 2.563 0.805 0.809 22 | 18 0.862 17.205 1.611 0.904 0.824 23 | 19 0.726 9.165 2.054 0.716 0.735 24 | 20 0.228 40.546 11.448 0.692 0.136 25 | 21 0.641 96.726 7.801 0.897 0.499 26 | 22 0.017 107.107 38.991 0.013 0.026 27 | 23 0.498 53.217 9.134 0.753 0.372 28 | 25 0.204 93.295 35.933 0.205 0.203 29 | 26 0.466 28.705 3.679 0.888 0.316 30 | 28 0.610 75.180 7.020 0.938 0.452 31 | 29 0.735 40.546 3.770 0.881 0.630 32 | 30 0.751 24.819 3.830 0.975 0.610 33 | 31 0.697 19.799 2.588 0.875 0.579 34 | 32 0.568 69.426 11.126 0.464 0.731 35 | 33 0.611 46.861 6.617 0.637 0.587 36 | 34 0.680 42.521 7.149 0.569 0.846 37 | 35 0.853 17.205 2.207 0.945 0.777 38 | 36 0.858 14.283 1.872 0.848 0.867 39 | 37 0.000 70.484 33.324 0.000 0.000 40 | 39 0.481 18.547 3.449 0.975 0.319 41 | 40 0.487 46.174 7.847 0.991 0.323 42 | 41 0.316 28.355 7.052 0.873 0.193 43 | 42 0.638 22.891 2.989 0.869 0.504 44 | 43 0.818 16.000 2.670 0.901 0.749 45 | 44 0.543 23.495 3.481 0.716 0.437 46 | 45 0.433 36.770 7.448 0.382 0.501 47 | DM average 0.619216503176 +/- 0.220738002683 48 | HD average 36.2198929964 +/- 24.9697371308 49 | ASSD average 7.13287526006 +/- 8.87449082069 50 | Prec. average 0.771369915749 +/- 0.252288962939 51 | Rec. average 0.556295618139 +/- 0.234693368292 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size200k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.689 30.133 5.778 0.957 0.539 10 | 04 0.748 46.043 3.756 0.685 0.824 11 | 05 0.641 33.287 6.441 0.985 0.475 12 | 06 0.794 19.799 3.097 0.872 0.729 13 | 07 0.871 11.314 1.905 0.931 0.818 14 | 08 0.777 36.056 4.569 0.977 0.645 15 | 09 0.661 9.165 2.354 0.604 0.731 16 | 10 0.653 22.361 5.054 0.987 0.488 17 | 11 0.665 20.688 2.857 0.926 0.519 18 | 12 0.830 18.868 2.501 0.959 0.732 19 | 13 0.832 25.377 2.629 0.903 0.771 20 | 15 0.805 14.967 2.109 0.805 0.806 21 | 17 0.811 17.205 2.497 0.811 0.812 22 | 18 0.865 15.748 1.575 0.906 0.828 23 | 19 0.727 9.165 2.036 0.733 0.722 24 | 20 0.230 35.440 11.383 0.726 0.137 25 | 21 0.642 96.519 8.525 0.888 0.502 26 | 22 0.011 107.369 41.001 0.008 0.017 27 | 23 0.497 54.443 8.288 0.777 0.366 28 | 25 0.194 93.231 37.074 0.195 0.193 29 | 26 0.331 31.623 4.205 0.908 0.203 30 | 28 0.590 76.158 7.760 0.930 0.432 31 | 29 0.726 42.426 4.030 0.865 0.625 32 | 30 0.751 24.000 3.731 0.975 0.611 33 | 31 0.672 20.100 2.818 0.858 0.552 34 | 32 0.592 68.411 10.257 0.501 0.723 35 | 33 0.609 46.690 6.334 0.655 0.570 36 | 34 0.681 40.645 7.035 0.575 0.836 37 | 35 0.856 16.125 2.150 0.949 0.779 38 | 36 0.857 14.283 1.867 0.848 0.866 39 | 37 0.000 76.184 32.893 0.000 0.000 40 | 39 0.445 19.698 3.654 0.926 0.293 41 | 40 0.487 44.721 7.723 0.989 0.323 42 | 41 0.300 28.914 7.243 0.864 0.182 43 | 42 0.629 86.971 8.832 0.781 0.527 44 | 43 0.818 16.125 2.648 0.911 0.742 45 | 44 0.500 24.166 3.888 0.675 0.397 46 | 45 0.407 38.523 7.934 0.357 0.473 47 | DM average 0.610478749322 +/- 0.227060586807 48 | HD average 37.7088847035 +/- 26.1662300182 49 | ASSD average 7.37981497229 +/- 9.08903431956 50 | Prec. average 0.768455149974 +/- 0.251733269957 51 | Rec. average 0.547037841516 +/- 0.240879674966 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size250k_r5.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.700 31.559 5.606 0.953 0.554 10 | 04 0.761 11.489 2.553 0.711 0.818 11 | 05 0.629 34.059 6.798 0.984 0.462 12 | 06 0.791 19.799 3.190 0.867 0.727 13 | 07 0.871 11.662 1.940 0.917 0.829 14 | 08 0.774 36.277 4.571 0.980 0.640 15 | 09 0.658 9.165 2.403 0.598 0.732 16 | 10 0.648 22.716 5.105 0.988 0.482 17 | 11 0.696 20.688 2.576 0.927 0.557 18 | 12 0.827 18.439 2.536 0.956 0.729 19 | 13 0.833 25.456 2.608 0.903 0.773 20 | 15 0.807 13.266 2.082 0.804 0.809 21 | 17 0.813 17.205 2.487 0.817 0.808 22 | 18 0.860 17.088 1.664 0.893 0.829 23 | 19 0.734 11.489 2.053 0.738 0.730 24 | 20 0.249 40.100 11.397 0.691 0.152 25 | 21 0.645 95.352 7.421 0.901 0.503 26 | 22 0.018 107.350 38.933 0.013 0.029 27 | 23 0.504 52.192 6.947 0.806 0.366 28 | 25 0.192 96.726 37.224 0.204 0.182 29 | 26 0.448 31.241 3.903 0.904 0.298 30 | 28 0.584 76.968 7.848 0.928 0.426 31 | 29 0.723 39.497 3.790 0.888 0.610 32 | 30 0.770 24.658 3.540 0.973 0.637 33 | 31 0.697 19.391 2.615 0.863 0.585 34 | 32 0.576 70.114 11.195 0.479 0.722 35 | 33 0.628 46.861 5.972 0.666 0.595 36 | 34 0.674 42.521 7.091 0.557 0.852 37 | 35 0.859 16.125 2.121 0.949 0.785 38 | 36 0.859 14.142 1.808 0.862 0.856 39 | 37 0.000 72.829 32.274 0.000 0.000 40 | 39 0.551 16.125 2.978 0.876 0.402 41 | 40 0.501 44.766 7.557 0.989 0.336 42 | 41 0.323 27.928 7.014 0.873 0.198 43 | 42 0.663 22.000 2.847 0.867 0.536 44 | 43 0.829 16.000 2.512 0.909 0.762 45 | 44 0.545 23.580 3.665 0.689 0.451 46 | 45 0.416 39.648 7.758 0.356 0.500 47 | DM average 0.62256250482 +/- 0.22075330053 48 | HD average 35.1702537916 +/- 25.3314987157 49 | ASSD average 7.01527934434 +/- 8.925305389 50 | Prec. average 0.77059278527 +/- 0.251702859818 51 | Rec. average 0.559511482557 +/- 0.233618409529 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size500k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.698 31.496 5.632 0.957 0.549 10 | 04 0.747 58.856 4.367 0.681 0.827 11 | 05 0.645 32.863 6.434 0.982 0.480 12 | 06 0.792 20.494 3.162 0.866 0.729 13 | 07 0.880 11.489 1.791 0.926 0.839 14 | 08 0.788 36.056 4.316 0.973 0.662 15 | 09 0.657 9.165 2.401 0.582 0.755 16 | 10 0.662 22.000 4.873 0.985 0.499 17 | 11 0.688 20.100 2.692 0.927 0.547 18 | 12 0.832 20.100 2.475 0.953 0.739 19 | 13 0.831 25.768 2.643 0.898 0.774 20 | 15 0.803 14.000 2.099 0.809 0.797 21 | 17 0.818 15.748 2.370 0.826 0.810 22 | 18 0.868 17.088 1.549 0.917 0.824 23 | 19 0.717 13.416 2.221 0.695 0.741 24 | 20 0.250 42.000 12.342 0.640 0.156 25 | 21 0.652 96.416 8.361 0.892 0.514 26 | 22 0.013 107.981 38.547 0.009 0.020 27 | 23 0.563 26.608 4.074 0.890 0.412 28 | 25 0.203 97.077 37.725 0.196 0.211 29 | 26 0.452 30.854 3.874 0.886 0.303 30 | 28 0.618 36.111 5.114 0.958 0.456 31 | 29 0.741 39.799 3.718 0.884 0.638 32 | 30 0.770 24.413 3.507 0.970 0.638 33 | 31 0.688 18.974 2.639 0.871 0.569 34 | 32 0.579 69.971 11.164 0.475 0.741 35 | 33 0.612 47.707 7.265 0.620 0.605 36 | 34 0.690 41.713 6.939 0.583 0.843 37 | 35 0.862 14.697 2.079 0.945 0.793 38 | 36 0.858 14.142 1.833 0.854 0.862 39 | 37 0.000 74.216 33.607 0.000 0.000 40 | 39 0.431 20.000 3.852 0.990 0.275 41 | 40 0.496 44.721 7.667 0.988 0.331 42 | 41 0.316 27.495 7.000 0.870 0.193 43 | 42 0.656 87.132 7.497 0.831 0.542 44 | 43 0.825 16.125 2.549 0.905 0.758 45 | 44 0.523 23.495 3.789 0.679 0.425 46 | 45 0.454 37.789 6.945 0.393 0.538 47 | DM average 0.623134722665 +/- 0.221978421639 48 | HD average 36.5283580734 +/- 25.706749137 49 | ASSD average 7.13442482872 +/- 9.01709497335 50 | Prec. average 0.771186974595 +/- 0.254992561563 51 | Rec. average 0.563037797488 +/- 0.236470199534 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.median7.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.228 91.586 9.558 0.534 0.145 9 | 04 0.135 112.196 25.649 0.095 0.233 10 | 05 0.210 74.673 8.619 0.566 0.129 11 | 06 0.246 82.049 11.111 0.352 0.189 12 | 07 0.317 89.129 11.727 0.475 0.238 13 | 08 0.275 84.971 9.688 0.582 0.180 14 | 09 0.079 87.109 18.532 0.046 0.289 15 | 10 0.216 85.276 9.835 0.549 0.135 16 | 11 0.181 91.258 18.690 0.144 0.242 17 | 12 0.275 90.686 12.223 0.445 0.199 18 | 13 0.284 79.498 11.796 0.385 0.226 19 | 15 0.193 86.994 18.098 0.156 0.255 20 | 17 0.246 87.567 14.013 0.277 0.220 21 | 18 0.226 80.623 13.722 0.210 0.245 22 | 19 0.100 100.578 22.875 0.067 0.198 23 | 20 0.030 124.258 37.800 0.021 0.052 24 | 21 0.126 108.830 29.920 0.128 0.124 25 | 22 0.017 117.201 36.896 0.010 0.080 26 | 23 0.072 121.557 29.454 0.049 0.138 27 | 25 0.021 128.717 40.131 0.012 0.070 28 | 26 0.132 90.885 23.872 0.100 0.193 29 | 28 0.161 96.374 24.398 0.187 0.141 30 | 29 0.207 91.280 14.853 0.177 0.248 31 | 30 0.271 94.826 8.929 0.577 0.177 32 | 31 0.261 85.065 13.163 0.258 0.263 33 | 32 0.224 97.857 17.882 0.230 0.218 34 | 33 0.221 87.178 12.766 0.242 0.204 35 | 34 0.196 87.886 15.549 0.138 0.336 36 | 35 0.281 79.145 9.913 0.428 0.209 37 | 36 0.247 84.119 15.857 0.247 0.246 38 | 37 0.004 128.686 29.072 0.002 0.111 39 | 39 0.047 87.636 23.544 0.027 0.194 40 | 40 0.266 66.603 6.538 0.726 0.163 41 | 41 0.172 84.876 13.845 0.312 0.118 42 | 42 0.054 107.703 28.239 0.037 0.099 43 | 43 0.262 100.200 15.257 0.349 0.210 44 | 44 0.031 94.382 26.158 0.017 0.225 45 | 45 0.146 93.145 17.746 0.112 0.210 46 | DM average 0.175224612524 +/- 0.090150755928 47 | HD average 94.2789936009 +/- 14.5854216083 48 | ASSD average 18.6294585521 +/- 8.6502466935 49 | Prec. average 0.243887276552 +/- 0.198229286468 50 | Rec. average 0.188184092492 +/- 0.062285249029 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/rdf.tdepth500_r2.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.699 30.529 5.599 0.952 0.553 10 | 04 0.748 58.549 4.821 0.691 0.816 11 | 05 0.648 31.496 6.455 0.986 0.482 12 | 06 0.789 20.396 3.163 0.876 0.718 13 | 07 0.872 11.489 1.893 0.929 0.821 14 | 08 0.782 36.056 4.422 0.981 0.650 15 | 09 0.672 9.798 2.219 0.639 0.709 16 | 10 0.657 22.804 4.977 0.987 0.492 17 | 11 0.688 20.688 2.658 0.939 0.543 18 | 12 0.826 19.900 2.588 0.954 0.728 19 | 13 0.828 25.768 2.702 0.894 0.771 20 | 15 0.810 14.967 2.056 0.812 0.808 21 | 17 0.815 16.371 2.448 0.813 0.816 22 | 18 0.862 16.613 1.612 0.894 0.832 23 | 19 0.716 10.392 2.087 0.703 0.730 24 | 20 0.248 42.426 11.765 0.701 0.151 25 | 21 0.655 96.229 7.871 0.894 0.517 26 | 22 0.014 107.981 40.011 0.010 0.021 27 | 23 0.474 54.589 7.878 0.791 0.338 28 | 25 0.212 96.871 36.485 0.217 0.207 29 | 26 0.468 30.529 3.889 0.890 0.317 30 | 28 0.585 76.026 7.683 0.931 0.426 31 | 29 0.735 40.694 3.781 0.889 0.627 32 | 30 0.765 25.612 3.621 0.974 0.630 33 | 31 0.702 19.698 2.568 0.852 0.597 34 | 32 0.571 68.206 10.851 0.473 0.720 35 | 33 0.628 46.174 5.891 0.663 0.596 36 | 34 0.700 40.050 6.692 0.599 0.842 37 | 35 0.861 15.362 2.054 0.953 0.786 38 | 36 0.856 14.142 1.846 0.854 0.857 39 | 37 0.000 73.783 32.393 0.000 0.000 40 | 39 0.561 16.125 2.866 0.888 0.410 41 | 40 0.497 44.721 7.555 0.990 0.332 42 | 41 0.310 27.928 7.060 0.869 0.189 43 | 42 0.654 22.978 2.956 0.868 0.524 44 | 43 0.827 16.125 2.563 0.904 0.762 45 | 44 0.539 23.495 3.475 0.748 0.421 46 | 45 0.424 38.678 7.581 0.365 0.506 47 | DM average 0.623606035514 +/- 0.220511290183 48 | HD average 36.4273256335 +/- 25.3376659464 49 | ASSD average 7.07984487335 +/- 8.95814501101 50 | Prec. average 0.773068884663 +/- 0.249488412848 51 | Rec. average 0.559034587331 +/- 0.232773390205 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size1000k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.696 29.732 5.533 0.951 0.549 10 | 04 0.724 58.412 5.277 0.645 0.824 11 | 05 0.657 32.249 6.357 0.982 0.494 12 | 06 0.792 19.391 3.141 0.865 0.731 13 | 07 0.882 10.770 1.771 0.917 0.850 14 | 08 0.792 36.056 4.215 0.974 0.668 15 | 09 0.658 8.944 2.368 0.582 0.757 16 | 10 0.667 21.541 4.797 0.984 0.504 17 | 11 0.688 20.688 2.727 0.931 0.545 18 | 12 0.839 18.868 2.361 0.956 0.747 19 | 13 0.831 24.900 2.635 0.895 0.775 20 | 15 0.806 14.000 2.081 0.805 0.807 21 | 17 0.813 15.362 2.418 0.805 0.822 22 | 18 0.874 16.613 1.466 0.918 0.835 23 | 19 0.722 11.489 2.145 0.687 0.761 24 | 20 0.269 40.546 10.841 0.685 0.167 25 | 21 0.680 96.416 7.294 0.897 0.547 26 | 22 0.007 107.815 39.944 0.005 0.010 27 | 23 0.573 53.591 7.137 0.803 0.445 28 | 25 0.223 96.850 37.009 0.213 0.235 29 | 26 0.521 28.355 3.320 0.884 0.369 30 | 28 0.632 76.053 6.827 0.931 0.478 31 | 29 0.740 38.419 3.609 0.889 0.634 32 | 30 0.779 23.495 3.406 0.971 0.651 33 | 31 0.701 19.287 2.537 0.874 0.585 34 | 32 0.564 70.937 11.364 0.450 0.756 35 | 33 0.621 47.413 6.830 0.631 0.610 36 | 34 0.695 42.521 7.046 0.592 0.841 37 | 35 0.864 15.362 2.042 0.948 0.794 38 | 36 0.859 14.142 1.820 0.848 0.871 39 | 37 0.000 76.184 33.678 0.000 0.000 40 | 39 0.525 18.547 3.246 0.911 0.369 41 | 40 0.510 44.721 7.456 0.989 0.343 42 | 41 0.323 27.350 6.928 0.868 0.199 43 | 42 0.626 87.932 7.746 0.832 0.501 44 | 43 0.826 16.000 2.526 0.908 0.757 45 | 44 0.562 22.716 3.522 0.664 0.487 46 | 45 0.436 37.947 7.276 0.373 0.526 47 | DM average 0.630962806648 +/- 0.218069521848 48 | HD average 37.9371988522 +/- 26.8491006629 49 | ASSD average 7.17617107845 +/- 9.07095288244 50 | Prec. average 0.764833979031 +/- 0.252898779332 51 | Rec. average 0.574837696993 +/- 0.231742312915 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size150k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.693 30.199 5.685 0.960 0.542 10 | 04 0.744 58.412 5.290 0.686 0.813 11 | 05 0.632 32.863 6.825 0.988 0.464 12 | 06 0.788 19.287 3.169 0.882 0.712 13 | 07 0.872 11.489 1.909 0.933 0.819 14 | 08 0.773 36.986 4.633 0.978 0.639 15 | 09 0.654 8.246 2.423 0.587 0.739 16 | 10 0.646 23.065 5.143 0.986 0.480 17 | 11 0.673 20.688 2.823 0.935 0.526 18 | 12 0.830 19.799 2.509 0.954 0.734 19 | 13 0.825 25.768 2.728 0.903 0.759 20 | 15 0.809 14.967 2.052 0.819 0.799 21 | 17 0.812 17.205 2.495 0.806 0.817 22 | 18 0.858 17.088 1.688 0.899 0.821 23 | 19 0.722 16.125 2.332 0.730 0.714 24 | 20 0.226 41.085 12.470 0.661 0.136 25 | 21 0.624 95.205 7.762 0.911 0.475 26 | 22 0.009 107.981 40.523 0.006 0.014 27 | 23 0.405 54.589 11.967 0.711 0.283 28 | 25 0.194 93.231 36.259 0.209 0.181 29 | 26 0.428 31.559 3.984 0.899 0.281 30 | 28 0.587 76.968 7.480 0.934 0.428 31 | 29 0.712 41.952 4.077 0.882 0.597 32 | 30 0.761 24.083 3.668 0.974 0.624 33 | 31 0.696 18.547 2.574 0.865 0.583 34 | 32 0.584 68.381 10.880 0.497 0.708 35 | 33 0.616 46.690 6.574 0.649 0.586 36 | 34 0.667 40.645 7.133 0.547 0.852 37 | 35 0.848 18.000 2.270 0.951 0.766 38 | 36 0.852 12.961 1.856 0.853 0.852 39 | 37 0.000 76.184 34.215 0.000 0.000 40 | 39 0.490 20.000 3.457 0.936 0.332 41 | 40 0.481 45.607 7.929 0.990 0.318 42 | 41 0.311 28.355 7.089 0.870 0.189 43 | 42 0.656 21.448 2.868 0.863 0.529 44 | 43 0.813 16.125 2.742 0.902 0.740 45 | 44 0.521 23.495 3.547 0.717 0.409 46 | 45 0.411 37.417 7.661 0.366 0.469 47 | DM average 0.61115319661 +/- 0.224211253696 48 | HD average 36.6499362917 +/- 25.0461271578 49 | ASSD average 7.38651975333 +/- 9.13290086264 50 | Prec. average 0.769467037483 +/- 0.253554099918 51 | Rec. average 0.545560090935 +/- 0.238173044318 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size150k_r4.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.699 31.048 5.611 0.955 0.552 10 | 04 0.758 10.770 2.540 0.715 0.807 11 | 05 0.638 33.526 6.696 0.983 0.472 12 | 06 0.789 19.900 3.172 0.875 0.719 13 | 07 0.870 11.314 1.943 0.934 0.814 14 | 08 0.779 36.497 4.524 0.978 0.647 15 | 09 0.667 9.165 2.316 0.623 0.717 16 | 10 0.649 22.978 5.150 0.985 0.484 17 | 11 0.681 20.688 2.678 0.941 0.534 18 | 12 0.835 19.391 2.446 0.965 0.736 19 | 13 0.829 25.768 2.673 0.901 0.768 20 | 15 0.807 15.362 2.069 0.805 0.810 21 | 17 0.812 17.205 2.483 0.825 0.801 22 | 18 0.856 17.205 1.712 0.896 0.820 23 | 19 0.704 16.613 2.594 0.681 0.729 24 | 20 0.221 40.546 12.262 0.711 0.131 25 | 21 0.653 96.354 7.614 0.897 0.513 26 | 22 0.018 107.350 38.933 0.013 0.029 27 | 23 0.480 54.443 9.009 0.754 0.352 28 | 25 0.179 95.373 37.090 0.188 0.171 29 | 26 0.403 31.623 4.178 0.914 0.259 30 | 28 0.574 37.736 5.684 0.961 0.409 31 | 29 0.724 40.841 3.932 0.888 0.611 32 | 30 0.763 25.768 3.687 0.979 0.625 33 | 31 0.700 18.974 2.546 0.876 0.583 34 | 32 0.575 68.059 10.661 0.487 0.702 35 | 33 0.601 47.244 6.436 0.647 0.560 36 | 34 0.658 40.645 7.395 0.539 0.845 37 | 35 0.850 17.205 2.229 0.946 0.772 38 | 36 0.855 14.283 1.840 0.862 0.847 39 | 37 0.000 74.833 34.026 0.000 0.000 40 | 39 0.534 14.560 2.840 0.914 0.377 41 | 40 0.468 46.390 8.029 0.991 0.306 42 | 41 0.339 29.052 7.045 0.879 0.210 43 | 42 0.652 22.891 2.920 0.891 0.514 44 | 43 0.816 16.125 2.688 0.904 0.744 45 | 44 0.542 23.833 3.590 0.696 0.444 46 | 45 0.406 37.789 7.876 0.354 0.477 47 | DM average 0.615357280067 +/- 0.223236666498 48 | HD average 34.4564257659 +/- 24.2577602833 49 | ASSD average 7.13462152725 +/- 9.04670648827 50 | Prec. average 0.772454143022 +/- 0.255178411883 51 | Rec. average 0.549650147655 +/- 0.234388854122 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size2000k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.697 29.732 5.556 0.952 0.550 10 | 04 0.726 58.412 5.304 0.646 0.827 11 | 05 0.652 32.619 6.380 0.978 0.489 12 | 06 0.794 19.391 3.125 0.867 0.732 13 | 07 0.878 11.489 1.831 0.908 0.849 14 | 08 0.796 34.756 4.097 0.973 0.674 15 | 09 0.644 8.944 2.469 0.567 0.746 16 | 10 0.670 21.633 4.735 0.984 0.508 17 | 11 0.710 20.591 2.397 0.924 0.577 18 | 12 0.843 19.391 2.326 0.956 0.754 19 | 13 0.831 25.768 2.612 0.899 0.773 20 | 15 0.809 13.565 2.051 0.804 0.814 21 | 17 0.818 13.565 2.362 0.812 0.825 22 | 18 0.875 17.088 1.470 0.902 0.850 23 | 19 0.714 16.248 2.390 0.661 0.775 24 | 20 0.326 42.000 10.127 0.729 0.210 25 | 21 0.713 96.519 6.869 0.899 0.590 26 | 22 0.010 107.201 39.098 0.007 0.015 27 | 23 0.560 53.591 8.808 0.742 0.450 28 | 25 0.232 96.726 37.148 0.212 0.255 29 | 26 0.543 28.284 3.172 0.869 0.394 30 | 28 0.648 76.942 6.577 0.931 0.497 31 | 29 0.750 38.419 3.511 0.882 0.653 32 | 30 0.784 23.324 3.309 0.967 0.658 33 | 31 0.701 19.799 2.558 0.868 0.588 34 | 32 0.567 71.190 11.363 0.452 0.760 35 | 33 0.615 47.244 6.859 0.625 0.606 36 | 34 0.677 61.286 8.646 0.565 0.844 37 | 35 0.868 14.697 2.007 0.945 0.803 38 | 36 0.860 12.961 1.799 0.852 0.868 39 | 37 0.000 73.783 33.775 0.000 0.000 40 | 39 0.533 18.547 3.227 0.934 0.373 41 | 40 0.514 44.587 7.374 0.987 0.347 42 | 41 0.325 28.142 6.945 0.865 0.200 43 | 42 0.651 88.091 6.696 0.840 0.532 44 | 43 0.823 16.000 2.561 0.905 0.756 45 | 44 0.557 22.450 3.528 0.650 0.487 46 | 45 0.455 36.277 6.937 0.387 0.553 47 | DM average 0.63610084155 +/- 0.215134702717 48 | HD average 38.4540538349 +/- 26.9487126238 49 | ASSD average 7.15779321167 +/- 9.01729616829 50 | Prec. average 0.761764216959 +/- 0.252596191563 51 | Rec. average 0.583854280637 +/- 0.228690676438 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size250k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.699 30.529 5.599 0.952 0.553 10 | 04 0.748 58.549 4.821 0.691 0.816 11 | 05 0.648 31.496 6.455 0.986 0.482 12 | 06 0.789 20.396 3.163 0.876 0.718 13 | 07 0.872 11.489 1.893 0.929 0.821 14 | 08 0.782 36.056 4.422 0.981 0.650 15 | 09 0.672 9.798 2.219 0.639 0.709 16 | 10 0.657 22.804 4.977 0.987 0.492 17 | 11 0.688 20.688 2.658 0.939 0.543 18 | 12 0.826 19.900 2.588 0.954 0.728 19 | 13 0.828 25.768 2.702 0.894 0.771 20 | 15 0.810 14.967 2.056 0.812 0.808 21 | 17 0.815 16.371 2.448 0.813 0.816 22 | 18 0.862 16.613 1.612 0.894 0.832 23 | 19 0.716 10.392 2.087 0.703 0.730 24 | 20 0.248 42.426 11.765 0.701 0.151 25 | 21 0.655 96.229 7.871 0.894 0.517 26 | 22 0.014 107.981 40.011 0.010 0.021 27 | 23 0.474 54.589 7.878 0.791 0.338 28 | 25 0.212 96.871 36.485 0.217 0.207 29 | 26 0.468 30.529 3.889 0.890 0.317 30 | 28 0.585 76.026 7.683 0.931 0.426 31 | 29 0.735 40.694 3.781 0.889 0.627 32 | 30 0.765 25.612 3.621 0.974 0.630 33 | 31 0.702 19.698 2.568 0.852 0.597 34 | 32 0.571 68.206 10.851 0.473 0.720 35 | 33 0.628 46.174 5.891 0.663 0.596 36 | 34 0.700 40.050 6.692 0.599 0.842 37 | 35 0.861 15.362 2.054 0.953 0.786 38 | 36 0.856 14.142 1.846 0.854 0.857 39 | 37 0.000 73.783 32.393 0.000 0.000 40 | 39 0.561 16.125 2.866 0.888 0.410 41 | 40 0.497 44.721 7.555 0.990 0.332 42 | 41 0.310 27.928 7.060 0.869 0.189 43 | 42 0.654 22.978 2.956 0.868 0.524 44 | 43 0.827 16.125 2.563 0.904 0.762 45 | 44 0.539 23.495 3.475 0.748 0.421 46 | 45 0.424 38.678 7.581 0.365 0.506 47 | DM average 0.623606035514 +/- 0.220511290183 48 | HD average 36.4273256335 +/- 25.3376659464 49 | ASSD average 7.07984487335 +/- 8.95814501101 50 | Prec. average 0.773068884663 +/- 0.249488412848 51 | Rec. average 0.559034587331 +/- 0.232773390205 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size250k_r2.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.700 29.394 5.502 0.954 0.552 10 | 04 0.749 33.941 3.314 0.698 0.808 11 | 05 0.642 31.875 6.659 0.987 0.475 12 | 06 0.787 19.900 3.221 0.871 0.719 13 | 07 0.872 10.954 1.928 0.916 0.831 14 | 08 0.779 36.277 4.513 0.979 0.647 15 | 09 0.651 9.165 2.450 0.576 0.748 16 | 10 0.660 22.978 4.956 0.985 0.496 17 | 11 0.687 20.591 2.767 0.921 0.548 18 | 12 0.834 18.868 2.475 0.960 0.737 19 | 13 0.828 25.768 2.671 0.902 0.765 20 | 15 0.803 14.697 2.109 0.805 0.802 21 | 17 0.808 15.748 2.526 0.808 0.808 22 | 18 0.865 16.492 1.589 0.913 0.821 23 | 19 0.717 12.000 2.151 0.707 0.728 24 | 20 0.213 42.426 12.113 0.637 0.128 25 | 21 0.657 96.208 7.637 0.907 0.515 26 | 22 0.016 107.981 39.429 0.012 0.025 27 | 23 0.473 53.442 9.633 0.750 0.345 28 | 25 0.212 92.801 35.721 0.225 0.201 29 | 26 0.447 29.732 3.968 0.917 0.296 30 | 28 0.598 76.968 7.862 0.935 0.439 31 | 29 0.728 39.497 3.815 0.885 0.619 32 | 30 0.766 24.739 3.554 0.972 0.632 33 | 31 0.713 19.799 2.424 0.855 0.611 34 | 32 0.566 69.340 11.392 0.463 0.727 35 | 33 0.619 46.733 6.685 0.643 0.596 36 | 34 0.711 42.000 6.546 0.616 0.840 37 | 35 0.856 17.088 2.162 0.953 0.777 38 | 36 0.857 12.961 1.819 0.850 0.865 39 | 37 0.000 79.246 33.453 0.000 0.000 40 | 39 0.553 18.439 3.061 0.945 0.390 41 | 40 0.481 46.433 7.917 0.990 0.318 42 | 41 0.319 28.142 7.106 0.878 0.195 43 | 42 0.660 22.716 2.826 0.883 0.526 44 | 43 0.822 16.125 2.617 0.911 0.748 45 | 44 0.558 23.152 3.348 0.735 0.449 46 | 45 0.431 38.471 7.617 0.380 0.498 47 | DM average 0.621991601791 +/- 0.221834676272 48 | HD average 35.8707183167 +/- 25.1506406547 49 | ASSD average 7.14568381388 +/- 8.94317820943 50 | Prec. average 0.771638139793 +/- 0.251821797435 51 | Rec. average 0.55859700772 +/- 0.234242660624 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size250k_r3.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.697 29.732 5.594 0.955 0.549 10 | 04 0.732 57.827 5.286 0.662 0.818 11 | 05 0.647 32.863 6.498 0.985 0.482 12 | 06 0.787 19.596 3.183 0.873 0.717 13 | 07 0.874 10.770 1.890 0.923 0.830 14 | 08 0.778 36.277 4.524 0.981 0.644 15 | 09 0.665 8.944 2.337 0.628 0.706 16 | 10 0.656 22.000 4.931 0.986 0.492 17 | 11 0.684 20.688 2.844 0.937 0.539 18 | 12 0.832 19.900 2.490 0.965 0.731 19 | 13 0.832 24.900 2.631 0.898 0.775 20 | 15 0.805 14.697 2.081 0.815 0.796 21 | 17 0.818 17.550 2.415 0.827 0.809 22 | 18 0.865 17.205 1.588 0.912 0.822 23 | 19 0.726 14.560 2.116 0.714 0.738 24 | 20 0.174 40.546 13.471 0.607 0.102 25 | 21 0.650 97.755 7.991 0.894 0.511 26 | 22 0.012 107.981 39.854 0.009 0.017 27 | 23 0.465 55.642 10.937 0.722 0.343 28 | 25 0.204 92.087 36.635 0.211 0.199 29 | 26 0.389 31.623 4.196 0.900 0.248 30 | 28 0.605 76.158 7.439 0.932 0.448 31 | 29 0.735 39.497 3.753 0.887 0.628 32 | 30 0.762 24.819 3.623 0.978 0.625 33 | 31 0.693 20.396 2.658 0.850 0.584 34 | 32 0.597 68.235 10.578 0.508 0.724 35 | 33 0.608 46.174 6.085 0.655 0.566 36 | 34 0.683 41.231 7.096 0.576 0.839 37 | 35 0.853 16.125 2.227 0.951 0.773 38 | 36 0.856 12.961 1.867 0.851 0.860 39 | 37 0.000 77.201 33.962 0.000 0.000 40 | 39 0.513 19.698 3.323 0.965 0.350 41 | 40 0.483 44.766 7.817 0.992 0.319 42 | 41 0.310 28.071 7.158 0.872 0.188 43 | 42 0.627 87.932 9.049 0.813 0.510 44 | 43 0.817 16.125 2.680 0.903 0.745 45 | 44 0.549 23.495 3.490 0.723 0.443 46 | 45 0.444 36.932 7.263 0.390 0.515 47 | DM average 0.616455480822 +/- 0.22573983758 48 | HD average 38.2357492998 +/- 26.3583823022 49 | ASSD average 7.46213477105 +/- 9.07420510848 50 | Prec. average 0.769726430923 +/- 0.251685794146 51 | Rec. average 0.552195554185 +/- 0.237613864609 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size250k_r6.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.665 33.106 6.380 0.967 0.506 10 | 04 0.690 12.649 3.274 0.586 0.839 11 | 05 0.635 38.626 6.966 0.936 0.480 12 | 06 0.801 15.232 3.030 0.788 0.815 13 | 07 0.806 17.205 2.969 0.856 0.762 14 | 08 0.690 26.382 5.964 0.956 0.539 15 | 09 0.670 9.165 2.190 0.632 0.713 16 | 10 0.642 23.152 5.203 0.988 0.476 17 | 11 0.639 20.976 3.008 0.944 0.483 18 | 12 0.821 26.306 2.880 0.958 0.719 19 | 13 0.814 24.900 2.833 0.905 0.740 20 | 15 0.804 14.697 2.113 0.819 0.789 21 | 17 0.809 18.000 2.489 0.837 0.784 22 | 18 0.862 18.000 1.639 0.915 0.814 23 | 19 0.735 10.954 2.014 0.750 0.720 24 | 20 0.000 70.824 39.448 0.000 0.000 25 | 21 0.603 96.623 9.026 0.879 0.459 26 | 22 0.007 108.536 42.198 0.005 0.009 27 | 23 0.490 54.589 10.870 0.731 0.369 28 | 25 0.169 93.231 37.204 0.195 0.149 29 | 26 0.354 32.125 4.357 0.910 0.220 30 | 28 0.567 36.277 5.591 0.954 0.404 31 | 29 0.737 40.100 3.770 0.887 0.630 32 | 30 0.739 26.758 3.927 0.977 0.594 33 | 31 0.659 19.900 2.902 0.854 0.537 34 | 32 0.588 68.235 10.360 0.501 0.712 35 | 33 0.632 46.174 5.898 0.696 0.578 36 | 34 0.681 59.363 8.614 0.567 0.854 37 | 35 0.844 17.205 2.333 0.956 0.756 38 | 36 0.856 14.283 1.819 0.876 0.837 39 | 37 0.000 70.370 34.098 0.000 0.000 40 | 39 0.446 19.698 3.721 0.976 0.289 41 | 40 0.452 44.766 8.059 0.989 0.293 42 | 41 0.289 29.189 7.376 0.879 0.173 43 | 42 0.598 23.324 3.222 0.915 0.444 44 | 43 0.812 16.000 2.703 0.908 0.735 45 | 44 0.532 24.166 3.475 0.828 0.392 46 | 45 0.410 36.770 7.914 0.363 0.470 47 | DM average 0.593371452561 +/- 0.235780730769 48 | HD average 35.7329854958 +/- 24.827744671 49 | ASSD average 8.20621063681 +/- 10.6269002222 50 | Prec. average 0.754848245615 +/- 0.281917103901 51 | Rec. average 0.528445656242 +/- 0.24786902272 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/sample.size400k.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.696 31.048 5.723 0.951 0.549 10 | 04 0.745 53.703 4.265 0.679 0.826 11 | 05 0.654 33.645 6.461 0.983 0.490 12 | 06 0.790 20.396 3.160 0.873 0.721 13 | 07 0.877 11.489 1.841 0.928 0.831 14 | 08 0.786 36.056 4.295 0.977 0.658 15 | 09 0.650 8.246 2.417 0.591 0.722 16 | 10 0.664 22.000 4.836 0.985 0.501 17 | 11 0.687 20.591 2.694 0.931 0.545 18 | 12 0.837 19.799 2.435 0.956 0.745 19 | 13 0.827 25.768 2.700 0.901 0.765 20 | 15 0.807 14.000 2.054 0.817 0.797 21 | 17 0.813 15.748 2.483 0.809 0.818 22 | 18 0.868 17.205 1.587 0.901 0.837 23 | 19 0.720 12.329 2.155 0.714 0.726 24 | 20 0.296 41.085 10.377 0.754 0.184 25 | 21 0.657 96.354 7.888 0.896 0.519 26 | 22 0.013 107.815 38.755 0.010 0.019 27 | 23 0.506 54.443 7.501 0.812 0.367 28 | 25 0.205 92.455 36.870 0.213 0.198 29 | 26 0.476 28.705 3.758 0.897 0.324 30 | 28 0.603 75.180 7.083 0.930 0.446 31 | 29 0.736 41.231 3.868 0.882 0.631 32 | 30 0.769 24.739 3.521 0.972 0.636 33 | 31 0.697 19.698 2.564 0.872 0.580 34 | 32 0.572 68.615 11.192 0.467 0.737 35 | 33 0.619 47.244 6.573 0.648 0.592 36 | 34 0.695 41.713 7.044 0.591 0.843 37 | 35 0.859 14.697 2.120 0.949 0.785 38 | 36 0.860 14.142 1.817 0.856 0.864 39 | 37 0.000 76.184 32.813 0.000 0.000 40 | 39 0.525 18.547 3.214 0.957 0.361 41 | 40 0.490 44.452 7.609 0.988 0.326 42 | 41 0.325 27.857 7.057 0.873 0.200 43 | 42 0.636 90.355 8.488 0.820 0.519 44 | 43 0.824 16.000 2.556 0.907 0.755 45 | 44 0.526 23.495 3.782 0.676 0.430 46 | 45 0.435 39.497 7.249 0.384 0.502 47 | DM average 0.624816679046 +/- 0.218379577471 48 | HD average 38.0664543918 +/- 26.4076902183 49 | ASSD average 7.17909092512 +/- 8.86306262368 50 | Prec. average 0.772300928783 +/- 0.251260131115 51 | Rec. average 0.561770596393 +/- 0.232458815084 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.04.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.584 33.893 6.030 0.976 0.416 10 | 04 0.638 80.376 11.809 0.557 0.747 11 | 05 0.305 26.019 9.466 0.999 0.180 12 | 06 0.706 18.375 2.507 0.956 0.559 13 | 07 0.745 17.224 2.545 0.963 0.608 14 | 08 0.766 23.676 3.668 0.976 0.630 15 | 09 0.370 14.141 2.238 0.797 0.241 16 | 10 0.535 21.683 6.100 0.992 0.366 17 | 11 0.587 24.216 2.517 0.904 0.434 18 | 12 0.749 17.448 3.269 0.976 0.607 19 | 13 0.774 29.045 2.907 0.903 0.678 20 | 15 0.739 17.817 1.870 0.834 0.663 21 | 17 0.772 66.070 4.262 0.842 0.713 22 | 18 0.804 14.169 1.401 0.926 0.710 23 | 19 0.182 98.328 22.410 0.414 0.116 24 | 20 0.741 115.046 12.438 0.682 0.811 25 | 21 0.843 13.682 1.388 0.865 0.822 26 | 22 0.307 40.016 6.539 0.204 0.620 27 | 23 0.512 93.748 8.739 0.484 0.544 28 | 25 0.466 91.207 6.601 0.336 0.760 29 | 26 0.677 16.500 2.148 0.637 0.723 30 | 28 0.795 23.409 2.029 0.868 0.733 31 | 29 0.681 63.770 7.082 0.725 0.643 32 | 30 0.376 31.546 5.788 0.990 0.232 33 | 31 0.483 31.923 4.810 0.958 0.322 34 | 32 0.537 68.111 11.199 0.490 0.594 35 | 33 0.475 23.527 3.893 0.913 0.321 36 | 34 0.692 14.191 2.041 0.881 0.569 37 | 35 0.687 15.461 3.193 0.985 0.527 38 | 36 0.802 12.136 2.147 0.746 0.868 39 | 37 0.011 64.835 21.589 0.006 0.069 40 | 39 0.461 27.500 3.810 0.552 0.395 41 | 40 0.269 41.151 8.237 0.979 0.156 42 | 41 0.119 64.491 15.885 0.720 0.065 43 | 42 0.398 67.404 18.560 0.489 0.335 44 | 43 0.652 21.497 4.084 0.981 0.489 45 | 44 0.000 83.334 69.641 0.000 0.000 46 | 45 0.270 29.500 9.127 0.409 0.202 47 | DM average 0.539618378539 +/- 0.228656411952 48 | HD average 40.9596554557 +/- 28.6221031493 49 | ASSD average 8.26230394456 +/- 11.4484282273 50 | Prec. average 0.734527653676 +/- 0.276150410645 51 | Rec. average 0.4859819591 +/- 0.238161600576 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.08.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.581 34.574 6.409 0.980 0.413 10 | 04 0.602 83.688 13.770 0.495 0.767 11 | 05 0.318 36.484 10.223 0.998 0.189 12 | 06 0.726 14.456 2.390 0.955 0.585 13 | 07 0.822 15.867 1.959 0.928 0.738 14 | 08 0.768 23.385 3.943 0.974 0.634 15 | 09 0.118 75.265 12.188 0.566 0.066 16 | 10 0.563 22.434 5.815 0.992 0.393 17 | 11 0.510 46.753 6.213 0.972 0.346 18 | 12 0.733 17.854 3.629 0.982 0.585 19 | 13 0.793 27.588 2.857 0.895 0.712 20 | 15 0.768 17.822 1.798 0.837 0.709 21 | 17 0.792 49.930 3.347 0.846 0.744 22 | 18 0.784 15.856 1.747 0.944 0.671 23 | 19 0.000 123.165 98.650 0.000 0.000 24 | 20 0.715 113.501 18.994 0.633 0.820 25 | 21 0.843 13.414 1.584 0.859 0.828 26 | 22 0.303 27.995 6.322 0.218 0.497 27 | 23 0.559 95.882 10.685 0.514 0.611 28 | 25 0.445 95.212 8.335 0.313 0.769 29 | 26 0.657 22.164 2.869 0.563 0.788 30 | 28 0.801 26.877 2.179 0.883 0.734 31 | 29 0.677 62.132 8.869 0.716 0.642 32 | 30 0.393 32.139 5.843 0.989 0.245 33 | 31 0.469 33.938 5.483 0.948 0.311 34 | 32 0.488 66.076 12.563 0.436 0.554 35 | 33 0.554 22.253 3.580 0.911 0.398 36 | 34 0.688 13.401 2.252 0.890 0.561 37 | 35 0.746 15.353 2.635 0.984 0.600 38 | 36 0.799 13.714 2.308 0.740 0.868 39 | 37 0.000 68.497 25.663 0.000 0.000 40 | 39 0.400 59.829 8.312 0.386 0.415 41 | 40 0.227 41.461 9.010 0.974 0.128 42 | 41 0.129 62.823 15.322 0.736 0.071 43 | 42 0.303 67.446 21.549 0.316 0.291 44 | 43 0.684 24.516 4.183 0.946 0.535 45 | 44 0.000 83.619 66.877 0.000 0.000 46 | 45 0.318 30.717 8.294 0.492 0.235 47 | DM average 0.528283704155 +/- 0.25174002013 48 | HD average 44.6862585162 +/- 29.9882414308 49 | ASSD average 11.280219904 +/- 18.1471410132 50 | Prec. average 0.70558603503 +/- 0.306407908683 51 | Rec. average 0.485678310907 +/- 0.259988117771 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.iso1.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.654 35.143 5.965 0.963 0.495 10 | 04 0.769 64.265 5.271 0.766 0.771 11 | 05 0.279 35.143 11.131 0.999 0.162 12 | 06 0.740 22.226 3.694 0.963 0.601 13 | 07 0.835 16.401 2.241 0.977 0.729 14 | 08 0.701 24.352 4.676 0.978 0.547 15 | 09 0.527 77.440 10.148 0.399 0.776 16 | 10 0.535 36.674 7.239 0.994 0.366 17 | 11 0.712 23.728 2.756 0.903 0.588 18 | 12 0.794 17.550 2.761 0.971 0.671 19 | 13 0.804 25.179 2.713 0.958 0.692 20 | 15 0.815 13.601 1.862 0.817 0.812 21 | 17 0.814 18.138 2.213 0.874 0.762 22 | 18 0.831 14.353 1.840 0.835 0.827 23 | 19 0.491 74.424 11.264 0.349 0.825 24 | 20 0.834 8.832 1.762 0.794 0.877 25 | 21 0.838 18.841 1.982 0.898 0.786 26 | 22 0.311 31.875 7.126 0.218 0.545 27 | 23 0.489 95.885 16.098 0.429 0.568 28 | 25 0.540 33.076 5.611 0.448 0.678 29 | 26 0.744 20.273 2.119 0.670 0.838 30 | 28 0.833 24.779 2.515 0.832 0.835 31 | 29 0.746 40.025 3.770 0.813 0.689 32 | 30 0.452 24.617 5.929 0.976 0.294 33 | 31 0.771 11.916 1.791 0.821 0.726 34 | 32 0.507 73.600 13.189 0.422 0.634 35 | 33 0.564 45.935 6.541 0.797 0.436 36 | 34 0.610 64.187 10.596 0.491 0.807 37 | 35 0.714 15.620 3.676 0.967 0.565 38 | 36 0.847 12.689 1.860 0.806 0.893 39 | 37 0.000 69.203 35.291 0.000 0.000 40 | 39 0.546 60.614 6.597 0.452 0.689 41 | 40 0.273 44.822 8.459 0.966 0.159 42 | 41 0.063 59.245 27.292 0.517 0.034 43 | 42 0.614 15.297 2.844 0.908 0.464 44 | 43 0.648 70.242 8.801 0.914 0.501 45 | 44 0.438 24.062 3.648 0.944 0.285 46 | 45 0.430 68.337 9.043 0.625 0.328 47 | DM average 0.608179767155 +/- 0.213563645398 48 | HD average 37.6997635281 +/- 23.292565754 49 | ASSD average 6.90295544935 +/- 6.83926147347 50 | Prec. average 0.748801786394 +/- 0.251417829528 51 | Rec. average 0.585687469731 +/- 0.23564922882 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.iso1_r2.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.668 35.440 6.020 0.957 0.512 10 | 04 0.771 64.915 5.685 0.769 0.772 11 | 05 0.272 37.229 11.367 1.000 0.157 12 | 06 0.740 21.424 3.652 0.967 0.600 13 | 07 0.828 17.493 2.317 0.977 0.719 14 | 08 0.710 24.556 4.535 0.985 0.555 15 | 09 0.519 77.589 9.874 0.392 0.770 16 | 10 0.530 35.355 7.245 0.992 0.362 17 | 11 0.704 21.863 2.539 0.921 0.570 18 | 12 0.794 17.521 2.748 0.964 0.674 19 | 13 0.802 25.318 2.734 0.952 0.693 20 | 15 0.810 13.928 1.880 0.814 0.805 21 | 17 0.809 18.682 2.317 0.878 0.750 22 | 18 0.835 15.033 1.818 0.842 0.828 23 | 19 0.522 74.243 10.740 0.381 0.831 24 | 20 0.838 8.832 1.731 0.792 0.889 25 | 21 0.839 18.974 1.968 0.899 0.787 26 | 22 0.317 26.249 7.020 0.225 0.539 27 | 23 0.451 95.656 16.464 0.401 0.515 28 | 25 0.533 33.511 5.818 0.445 0.663 29 | 26 0.750 20.248 2.094 0.684 0.829 30 | 28 0.831 25.710 2.530 0.839 0.823 31 | 29 0.742 42.000 3.997 0.802 0.691 32 | 30 0.444 23.875 5.761 0.962 0.288 33 | 31 0.778 11.358 1.759 0.829 0.734 34 | 32 0.505 73.048 13.321 0.419 0.635 35 | 33 0.545 45.815 6.941 0.774 0.421 36 | 34 0.617 64.273 10.651 0.497 0.812 37 | 35 0.702 15.780 3.819 0.972 0.549 38 | 36 0.853 12.207 1.774 0.816 0.894 39 | 37 0.000 69.231 34.259 0.000 0.000 40 | 39 0.589 23.000 3.809 0.515 0.688 41 | 40 0.263 45.089 8.664 0.956 0.152 42 | 41 0.069 58.549 25.769 0.559 0.037 43 | 42 0.602 14.177 2.873 0.908 0.451 44 | 43 0.641 69.886 9.189 0.908 0.495 45 | 44 0.490 23.537 3.280 0.915 0.335 46 | 45 0.423 66.678 9.381 0.621 0.321 47 | DM average 0.608821861989 +/- 0.21349825873 48 | HD average 36.5334785955 +/- 23.0837079624 49 | ASSD average 6.79860554927 +/- 6.64786990267 50 | Prec. average 0.750736655819 +/- 0.247409995502 51 | Rec. average 0.582781581126 +/- 0.235188111907 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.iso2.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.636 34.234 6.760 0.973 0.473 10 | 04 0.715 68.352 8.398 0.648 0.797 11 | 05 0.335 36.932 11.133 0.996 0.201 12 | 06 0.805 20.494 2.948 0.914 0.720 13 | 07 0.879 12.961 1.776 0.948 0.820 14 | 08 0.689 27.350 5.479 0.985 0.529 15 | 09 0.567 76.263 8.448 0.445 0.783 16 | 10 0.490 28.071 7.434 0.991 0.325 17 | 11 0.582 44.045 6.145 0.948 0.420 18 | 12 0.825 15.362 2.446 0.967 0.720 19 | 13 0.813 25.690 2.817 0.909 0.736 20 | 15 0.809 15.362 2.023 0.823 0.795 21 | 17 0.810 15.620 2.534 0.784 0.838 22 | 18 0.786 17.205 2.544 0.859 0.725 23 | 19 0.562 71.694 7.397 0.441 0.772 24 | 20 0.811 70.795 9.649 0.768 0.859 25 | 21 0.831 18.547 2.068 0.930 0.751 26 | 22 0.306 21.354 6.648 0.234 0.444 27 | 23 0.405 98.102 19.617 0.289 0.673 28 | 25 0.595 80.548 8.059 0.492 0.753 29 | 26 0.713 20.881 2.701 0.599 0.881 30 | 28 0.823 26.000 2.722 0.816 0.831 31 | 29 0.737 45.166 4.222 0.834 0.661 32 | 30 0.499 22.450 5.609 0.956 0.338 33 | 31 0.744 17.889 2.194 0.848 0.663 34 | 32 0.537 68.235 13.098 0.477 0.613 35 | 33 0.613 48.083 6.011 0.831 0.485 36 | 34 0.724 39.294 6.191 0.660 0.803 37 | 35 0.816 12.649 2.600 0.955 0.712 38 | 36 0.845 12.806 2.026 0.808 0.886 39 | 37 0.000 59.262 33.273 0.000 0.000 40 | 39 0.627 11.489 2.641 0.647 0.608 41 | 40 0.163 51.342 10.802 0.958 0.089 42 | 41 0.064 54.332 14.792 0.949 0.033 43 | 42 0.592 14.560 3.039 0.925 0.435 44 | 43 0.724 68.147 5.429 0.924 0.595 45 | 44 0.123 25.768 5.612 1.000 0.066 46 | 45 0.477 18.868 5.078 0.627 0.385 47 | DM average 0.607178726846 +/- 0.229533513988 48 | HD average 37.2685756748 +/- 23.4879723714 49 | ASSD average 6.64110289851 +/- 5.89085528107 50 | Prec. average 0.767264716325 +/- 0.240648402091 51 | Rec. average 0.584693163506 +/- 0.250730374795 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.native.orig.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.580 34.117 6.066 0.977 0.412 10 | 04 0.620 84.333 13.596 0.533 0.739 11 | 05 0.311 26.278 9.578 0.999 0.184 12 | 06 0.697 37.899 3.596 0.962 0.546 13 | 07 0.853 37.048 2.201 0.922 0.795 14 | 08 0.788 20.698 3.294 0.973 0.661 15 | 09 0.332 29.715 5.585 0.428 0.271 16 | 10 0.512 24.133 6.530 0.993 0.345 17 | 11 0.570 19.112 2.210 0.936 0.410 18 | 12 0.759 16.500 3.163 0.979 0.620 19 | 13 0.781 37.532 3.111 0.867 0.711 20 | 15 0.753 22.386 1.851 0.797 0.714 21 | 17 0.779 74.407 4.116 0.832 0.732 22 | 18 0.810 14.776 1.318 0.910 0.729 23 | 19 0.000 75.587 36.310 0.000 0.000 24 | 20 0.649 119.048 22.898 0.548 0.795 25 | 21 0.856 14.267 1.178 0.926 0.795 26 | 22 0.219 87.575 17.537 0.138 0.528 27 | 23 0.529 93.609 8.766 0.488 0.579 28 | 25 0.447 95.684 9.954 0.315 0.768 29 | 26 0.690 22.553 2.376 0.626 0.769 30 | 28 0.806 23.738 1.849 0.883 0.742 31 | 29 0.721 31.251 2.607 0.793 0.661 32 | 30 0.312 67.077 9.684 0.961 0.186 33 | 31 0.380 39.362 6.760 0.968 0.236 34 | 32 0.589 67.326 9.227 0.565 0.616 35 | 33 0.418 24.365 4.650 0.914 0.271 36 | 34 0.710 11.714 1.927 0.851 0.609 37 | 35 0.744 13.652 2.889 0.987 0.597 38 | 36 0.825 46.983 2.437 0.798 0.855 39 | 37 0.000 61.970 24.637 0.000 0.000 40 | 39 0.480 15.522 3.002 0.660 0.378 41 | 40 0.136 49.426 11.459 0.975 0.073 42 | 41 0.038 48.852 13.549 0.994 0.019 43 | 42 0.316 67.304 18.528 0.410 0.257 44 | 43 0.675 22.052 3.898 0.972 0.517 45 | 44 0.000 84.020 67.593 0.000 0.000 46 | 45 0.275 25.387 8.139 0.544 0.184 47 | DM average 0.52530552749 +/- 0.261131602659 48 | HD average 44.401527045 +/- 28.1521746943 49 | ASSD average 9.42281720034 +/- 12.1618327321 50 | Prec. average 0.721696952889 +/- 0.304609728323 51 | Rec. average 0.481741153212 +/- 0.26612046549 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.native.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.580 34.117 6.066 0.977 0.412 10 | 04 0.620 84.333 13.596 0.533 0.739 11 | 05 0.311 26.278 9.578 0.999 0.184 12 | 06 0.697 37.899 3.596 0.962 0.546 13 | 07 0.853 37.048 2.201 0.922 0.795 14 | 08 0.788 20.698 3.294 0.973 0.661 15 | 09 0.332 29.715 5.585 0.428 0.271 16 | 10 0.512 24.133 6.530 0.993 0.345 17 | 11 0.570 19.112 2.210 0.936 0.410 18 | 12 0.759 16.500 3.163 0.979 0.620 19 | 13 0.781 37.532 3.111 0.867 0.711 20 | 15 0.753 22.386 1.851 0.797 0.714 21 | 17 0.779 74.407 4.116 0.832 0.732 22 | 18 0.810 14.776 1.318 0.910 0.729 23 | 19 0.000 75.587 36.310 0.000 0.000 24 | 20 0.649 119.048 22.898 0.548 0.795 25 | 21 0.856 14.267 1.178 0.926 0.795 26 | 22 0.219 87.575 17.537 0.138 0.528 27 | 23 0.529 93.609 8.766 0.488 0.579 28 | 25 0.447 95.684 9.954 0.315 0.768 29 | 26 0.690 22.553 2.376 0.626 0.769 30 | 28 0.806 23.738 1.849 0.883 0.742 31 | 29 0.721 31.251 2.607 0.793 0.661 32 | 30 0.312 67.077 9.684 0.961 0.186 33 | 31 0.380 39.362 6.760 0.968 0.236 34 | 32 0.589 67.326 9.227 0.565 0.616 35 | 33 0.418 24.365 4.650 0.914 0.271 36 | 34 0.710 11.714 1.927 0.851 0.609 37 | 35 0.744 13.652 2.889 0.987 0.597 38 | 36 0.825 46.983 2.437 0.798 0.855 39 | 37 0.000 61.970 24.637 0.000 0.000 40 | 39 0.480 15.522 3.002 0.660 0.378 41 | 40 0.136 49.426 11.459 0.975 0.073 42 | 41 0.038 48.852 13.549 0.994 0.019 43 | 42 0.316 67.304 18.528 0.410 0.257 44 | 43 0.675 22.052 3.898 0.972 0.517 45 | 44 0.000 84.020 67.593 0.000 0.000 46 | 45 0.275 25.387 8.139 0.544 0.184 47 | DM average 0.52530552749 +/- 0.261131602659 48 | HD average 44.401527045 +/- 28.1521746943 49 | ASSD average 9.42281720034 +/- 12.1618327321 50 | Prec. average 0.721696952889 +/- 0.304609728323 51 | Rec. average 0.481741153212 +/- 0.26612046549 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.int.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.190 90.863 10.142 0.462 0.119 9 | 04 0.103 112.161 26.259 0.075 0.166 10 | 05 0.164 80.349 9.533 0.499 0.098 11 | 06 0.197 83.259 12.109 0.306 0.145 12 | 07 0.246 90.089 13.386 0.410 0.176 13 | 08 0.216 86.279 10.292 0.521 0.136 14 | 09 0.073 87.361 19.388 0.042 0.249 15 | 10 0.177 86.441 10.573 0.487 0.108 16 | 11 0.145 92.282 19.079 0.116 0.193 17 | 12 0.210 90.819 13.253 0.369 0.146 18 | 13 0.225 82.316 12.745 0.320 0.174 19 | 15 0.158 86.856 18.493 0.131 0.199 20 | 17 0.191 92.109 14.565 0.230 0.164 21 | 18 0.199 82.801 14.553 0.184 0.217 22 | 19 0.072 102.000 24.140 0.046 0.165 23 | 20 0.027 124.788 36.412 0.020 0.045 24 | 21 0.096 108.830 29.874 0.105 0.088 25 | 22 0.013 117.201 37.188 0.007 0.055 26 | 23 0.074 122.016 29.442 0.052 0.130 27 | 25 0.021 129.012 38.348 0.013 0.062 28 | 26 0.108 90.443 23.377 0.087 0.143 29 | 28 0.128 95.184 24.368 0.159 0.107 30 | 29 0.165 91.258 15.865 0.146 0.191 31 | 30 0.200 92.217 10.218 0.473 0.127 32 | 31 0.169 88.566 15.641 0.150 0.194 33 | 32 0.157 98.833 20.343 0.154 0.160 34 | 33 0.140 88.949 15.680 0.140 0.140 35 | 34 0.154 87.567 16.583 0.110 0.258 36 | 35 0.218 80.125 10.876 0.350 0.158 37 | 36 0.211 86.856 16.253 0.212 0.209 38 | 37 0.006 128.452 29.540 0.003 0.135 39 | 39 0.042 89.844 22.830 0.025 0.149 40 | 40 0.209 67.082 7.337 0.613 0.126 41 | 41 0.152 90.620 14.565 0.261 0.107 42 | 42 0.055 107.722 28.105 0.039 0.090 43 | 43 0.191 100.757 16.625 0.262 0.150 44 | 44 0.030 95.226 26.308 0.016 0.203 45 | 45 0.102 92.304 19.342 0.075 0.160 46 | DM average 0.137710994814 +/- 0.0681434796442 47 | HD average 95.2588781021 +/- 13.9871683904 48 | ASSD average 19.3060045016 +/- 8.07698461097 49 | Prec. average 0.201889446915 +/- 0.170853745939 50 | Rec. average 0.148476408652 +/- 0.0482789695877 51 | INFO: Done. 52 | -------------------------------------------------------------------------------- /logs/origeval.iso1.sequence.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.654 35.143 5.965 0.963 0.495 10 | 04 0.769 64.265 5.271 0.766 0.771 11 | 05 0.279 35.143 11.131 0.999 0.162 12 | 06 0.740 22.226 3.694 0.963 0.601 13 | 07 0.835 16.401 2.241 0.977 0.729 14 | 08 0.701 24.352 4.676 0.978 0.547 15 | 09 0.527 77.440 10.148 0.399 0.776 16 | 10 0.535 36.674 7.239 0.994 0.366 17 | 11 0.712 23.728 2.756 0.903 0.588 18 | 12 0.794 17.550 2.761 0.971 0.671 19 | 13 0.804 25.179 2.713 0.958 0.692 20 | 15 0.815 13.601 1.862 0.817 0.812 21 | 17 0.814 18.138 2.213 0.874 0.762 22 | 18 0.831 14.353 1.840 0.835 0.827 23 | 19 0.491 74.424 11.264 0.349 0.825 24 | 20 0.834 8.832 1.762 0.794 0.877 25 | 21 0.838 18.841 1.982 0.898 0.786 26 | 22 0.311 31.875 7.126 0.218 0.545 27 | 23 0.489 95.885 16.098 0.429 0.568 28 | 25 0.540 33.076 5.611 0.448 0.678 29 | 26 0.744 20.273 2.119 0.670 0.838 30 | 28 0.833 24.779 2.515 0.832 0.835 31 | 29 0.746 40.025 3.770 0.813 0.689 32 | 30 0.452 24.617 5.929 0.976 0.294 33 | 31 0.771 11.916 1.791 0.821 0.726 34 | 32 0.507 73.600 13.189 0.422 0.634 35 | 33 0.564 45.935 6.541 0.797 0.436 36 | 34 0.610 64.187 10.596 0.491 0.807 37 | 35 0.714 15.620 3.676 0.967 0.565 38 | 36 0.847 12.689 1.860 0.806 0.893 39 | 37 0.000 69.203 35.291 0.000 0.000 40 | 39 0.546 60.614 6.597 0.452 0.689 41 | 40 0.273 44.822 8.459 0.966 0.159 42 | 41 0.063 59.245 27.292 0.517 0.034 43 | 42 0.614 15.297 2.844 0.908 0.464 44 | 43 0.648 70.242 8.801 0.914 0.501 45 | 44 0.438 24.062 3.648 0.944 0.285 46 | 45 0.430 68.337 9.043 0.625 0.328 47 | DM average 0.608179767155 +/- 0.213563645398 48 | HD average 37.6997635281 +/- 23.292565754 49 | ASSD average 6.90295544935 +/- 6.83926147347 50 | Prec. average 0.748801786394 +/- 0.251417829528 51 | Rec. average 0.585687469731 +/- 0.23564922882 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.04_r2.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.593 34.130 6.096 0.973 0.426 10 | 04 0.625 84.333 12.874 0.542 0.737 11 | 05 0.311 26.765 9.381 0.999 0.184 12 | 06 0.705 17.967 2.563 0.948 0.561 13 | 07 0.748 16.788 2.506 0.964 0.612 14 | 08 0.763 23.478 3.885 0.975 0.626 15 | 09 0.317 14.205 2.479 0.786 0.199 16 | 10 0.530 22.378 6.141 0.992 0.361 17 | 11 0.588 25.132 2.557 0.891 0.439 18 | 12 0.742 18.173 3.441 0.980 0.597 19 | 13 0.773 28.303 2.888 0.903 0.676 20 | 15 0.732 18.070 1.975 0.824 0.659 21 | 17 0.772 65.879 4.006 0.860 0.701 22 | 18 0.806 14.055 1.367 0.914 0.720 23 | 19 0.171 98.411 29.936 0.315 0.118 24 | 20 0.744 114.985 12.411 0.686 0.812 25 | 21 0.844 13.660 1.475 0.853 0.835 26 | 22 0.319 43.039 6.576 0.210 0.661 27 | 23 0.499 93.532 9.251 0.479 0.519 28 | 25 0.448 95.323 8.576 0.317 0.765 29 | 26 0.688 16.500 2.156 0.641 0.741 30 | 28 0.802 23.576 1.852 0.880 0.737 31 | 29 0.693 44.620 5.347 0.755 0.641 32 | 30 0.383 29.934 5.561 0.987 0.238 33 | 31 0.498 32.272 4.480 0.955 0.337 34 | 32 0.531 68.767 11.305 0.477 0.600 35 | 33 0.496 25.051 3.670 0.904 0.342 36 | 34 0.684 13.794 2.211 0.878 0.560 37 | 35 0.695 14.141 2.940 0.983 0.537 38 | 36 0.806 12.457 2.043 0.753 0.866 39 | 37 0.014 64.668 20.167 0.008 0.082 40 | 39 0.475 27.085 3.469 0.575 0.405 41 | 40 0.253 41.346 8.514 0.983 0.145 42 | 41 0.130 50.612 11.763 0.824 0.071 43 | 42 0.398 67.495 19.336 0.455 0.353 44 | 43 0.643 21.218 4.144 0.985 0.478 45 | 44 0.000 83.596 67.530 0.000 0.000 46 | 45 0.233 63.116 12.451 0.345 0.176 47 | DM average 0.538190478879 +/- 0.230872062268 48 | HD average 41.2857490168 +/- 28.7047229521 49 | ASSD average 8.40319226605 +/- 11.4308066893 50 | Prec. average 0.731521395646 +/- 0.282867829369 51 | Rec. average 0.487241926877 +/- 0.239666039472 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/space.08_r2.sequ.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Morphological post-processing 6 | INFO: Compute overall evaluation 7 | Metrics: 8 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 9 | 03 0.576 35.336 6.532 0.981 0.408 10 | 04 0.593 81.771 14.030 0.487 0.759 11 | 05 0.309 36.340 10.295 0.999 0.183 12 | 06 0.724 17.396 2.504 0.951 0.584 13 | 07 0.813 16.500 2.062 0.931 0.721 14 | 08 0.771 22.585 3.938 0.975 0.637 15 | 09 0.143 25.166 9.014 0.396 0.088 16 | 10 0.560 21.976 5.841 0.993 0.390 17 | 11 0.522 46.719 6.141 0.972 0.357 18 | 12 0.739 17.105 3.500 0.981 0.593 19 | 13 0.794 27.056 2.858 0.901 0.710 20 | 15 0.767 19.321 1.787 0.841 0.705 21 | 17 0.783 50.027 3.510 0.832 0.741 22 | 18 0.783 15.100 1.750 0.943 0.670 23 | 19 0.000 123.410 98.723 0.000 0.000 24 | 20 0.687 114.249 21.983 0.590 0.820 25 | 21 0.851 13.682 1.479 0.867 0.835 26 | 22 0.303 27.995 6.199 0.218 0.498 27 | 23 0.530 96.386 12.785 0.499 0.565 28 | 25 0.442 94.992 9.700 0.307 0.790 29 | 26 0.662 17.474 2.768 0.572 0.784 30 | 28 0.796 27.368 2.251 0.880 0.726 31 | 29 0.678 62.038 8.709 0.727 0.636 32 | 30 0.382 30.735 6.180 0.990 0.237 33 | 31 0.452 33.720 5.514 0.959 0.296 34 | 32 0.485 67.178 12.746 0.458 0.514 35 | 33 0.546 22.541 3.648 0.908 0.391 36 | 34 0.703 11.867 2.254 0.875 0.587 37 | 35 0.745 16.234 2.711 0.977 0.602 38 | 36 0.798 14.206 2.357 0.741 0.864 39 | 37 0.000 69.008 25.830 0.000 0.000 40 | 39 0.385 60.848 8.925 0.379 0.391 41 | 40 0.230 41.412 8.956 0.976 0.130 42 | 41 0.129 62.016 16.128 0.708 0.071 43 | 42 0.310 67.446 21.674 0.331 0.291 44 | 43 0.672 24.924 4.429 0.943 0.522 45 | 44 0.000 83.542 67.199 0.000 0.000 46 | 45 0.295 30.093 8.018 0.504 0.208 47 | DM average 0.525184651382 +/- 0.250823947505 48 | HD average 43.3094546642 +/- 29.8023986719 49 | ASSD average 11.4454233729 +/- 18.2242812013 50 | Prec. average 0.699775599584 +/- 0.309261150498 51 | Rec. average 0.481644396598 +/- 0.259580508854 52 | INFO: Done. 53 | -------------------------------------------------------------------------------- /logs/eval.pre.flair.ggm5.log: -------------------------------------------------------------------------------- 1 | INFO: Extracting the features 2 | INFO: Drawing a training set for each leave-one-out case using stratified random sampling 3 | INFO: Training random decision forests 4 | INFO: Applying random decision forests to segment lesion 5 | INFO: Compute overall evaluation 6 | Metrics: 7 | Case DC[0,1] HD(mm) P2C(mm) prec. recall 8 | 03 0.081 87.086 13.927 0.206 0.051 9 | 04 0.052 111.427 26.339 0.040 0.072 10 | 05 0.083 78.816 12.076 0.286 0.049 11 | 06 0.075 84.475 15.394 0.135 0.052 12 | 07 0.068 90.200 18.623 0.127 0.046 13 | 08 0.074 88.679 14.105 0.222 0.045 14 | 09 0.021 84.404 20.087 0.013 0.066 15 | 10 0.076 82.316 13.989 0.234 0.046 16 | 11 0.060 94.043 17.682 0.052 0.071 17 | 12 0.076 94.425 16.472 0.143 0.052 18 | 13 0.085 82.994 14.993 0.136 0.062 19 | 15 0.062 87.841 19.092 0.055 0.072 20 | 17 0.086 89.219 15.687 0.120 0.066 21 | 18 0.061 82.777 16.283 0.060 0.062 22 | 19 0.027 103.846 25.048 0.018 0.057 23 | 20 0.025 122.687 28.798 0.018 0.040 24 | 21 0.058 105.167 23.971 0.069 0.050 25 | 22 0.012 118.794 31.790 0.007 0.048 26 | 23 0.032 120.830 26.379 0.024 0.048 27 | 25 0.016 126.870 29.157 0.010 0.044 28 | 26 0.051 93.059 17.369 0.042 0.062 29 | 28 0.070 94.106 18.948 0.099 0.054 30 | 29 0.057 90.885 16.682 0.054 0.061 31 | 30 0.061 91.148 14.943 0.166 0.038 32 | 31 0.063 86.046 16.725 0.060 0.067 33 | 32 0.053 98.265 21.749 0.052 0.054 34 | 33 0.068 88.949 18.254 0.080 0.059 35 | 34 0.047 85.065 17.521 0.034 0.079 36 | 35 0.074 80.275 14.546 0.141 0.050 37 | 36 0.069 83.570 16.608 0.076 0.063 38 | 37 0.001 132.439 31.724 0.001 0.029 39 | 39 0.023 90.576 21.033 0.013 0.078 40 | 40 0.070 70.370 11.022 0.245 0.041 41 | 41 0.048 89.554 17.184 0.084 0.033 42 | 42 0.034 104.671 25.119 0.026 0.049 43 | 43 0.067 98.813 19.335 0.101 0.051 44 | 44 0.007 93.851 24.336 0.004 0.040 45 | 45 0.041 92.542 21.988 0.031 0.063 46 | DM average 0.0535890241434 +/- 0.0231474247793 47 | HD average 94.7652497468 +/- 13.9536853617 48 | ASSD average 19.6046103006 +/- 5.31021471235 49 | Prec. average 0.0863883921643 +/- 0.0743916933701 50 | Rec. average 0.0544867209739 +/- 0.0119571543567 51 | INFO: Done. 52 | --------------------------------------------------------------------------------