diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/mc/__init__.py
similarity index 100%
copy from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
copy to Modules/Biophotonics/python/iMC/mc/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/mc/batches.py b/Modules/Biophotonics/python/iMC/mc/batches.py
new file mode 100644
index 0000000000..2706262dc6
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/batches.py
@@ -0,0 +1,375 @@
+'''
+Created on Oct 15, 2015
+
+@author: wirkert
+'''
+
+import numpy as np
+from pandas import DataFrame
+import pandas as pd
+
+
+class AbstractBatch(object):
+ """summarizes a batch of simulated mc spectra"""
+
+ def __init__(self):
+ self._nr_layers = 0 # internally keeps track of number of layers
+ my_index = pd.MultiIndex(levels=[[], []],
+ labels=[[], []])
+ self.df = DataFrame(columns=my_index)
+
+ def create_parameters(self, nr_samples):
+ """create the parameters for the batch, the simulation has
+ to create the resulting reflectances"""
+ pass
+
+ def nr_elements(self):
+ return self.df.shape[0]
+
+
+class GenericBatch(AbstractBatch):
+ """generic n-layer batch with each layer having the same oxygenation """
+
+ def __init__(self):
+ super(GenericBatch, self).__init__()
+
+ def append_one_layer(self, saO2, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # scales data to lie between maxi and mini instead of 0 and 1
+ scale = lambda x, mini, maxi: x * (maxi - mini) + mini
+ # shortcut to random generator
+ gen = np.random.random_sample
+ gen_n = np.random.normal
+
+ # create layer elements
+ self.df["layer" + str(self._nr_layers), "vhb"] = \
+ scale(gen(nr_samples), 0, 1.)
+ self.df["layer" + str(self._nr_layers), "sao2"] = \
+ saO2
+ self.df["layer" + str(self._nr_layers), "a_mie"] = \
+ np.clip(gen_n(loc=18.9, scale=10.2, size=nr_samples),
+ 0.1, np.inf) * 100 # to 1/m
+ self.df["layer" + str(self._nr_layers), "b_mie"] = \
+ np.clip(gen_n(loc=1.286, scale=0.521, size=nr_samples), 0, np.inf)
+ self.df["layer" + str(self._nr_layers), "d"] = \
+ scale(gen(nr_samples), 0, 1.)
+ self.df["layer" + str(self._nr_layers), "n"] = \
+ scale(gen(nr_samples), 1.33, 1.54)
+ self.df["layer" + str(self._nr_layers), "g"] = \
+ scale(gen(nr_samples), 0.8, 0.95)
+ self._nr_layers += 1
+
+ def create_parameters(self, nr_samples):
+ """Create generic three layer batch with a total diameter of 2mm.
+ saO2 is the same in all layers, but all other parameters vary randomly
+ within each layer"""
+ saO2 = np.random.random_sample(size=nr_samples)
+
+ # create three layers with random samples
+ self.append_one_layer(saO2, nr_samples)
+ self.append_one_layer(saO2, nr_samples)
+ self.append_one_layer(saO2, nr_samples)
+
+ # "normalize" d to 2mm
+ # first extract all layers from df
+ self.df
+
+ layers = [l for l in self.df.columns.levels[0] if "layer" in l]
+ # summarize all ds
+ sum_d = 0
+ for l in layers:
+ sum_d += self.df[l, "d"]
+ for l in layers:
+ self.df[l, "d"] = self.df[l, "d"] / sum_d * 2000. * 10 ** -6
+ self.df[l, "d"] = np.clip(self.df[l, "d"], 25 * 10 ** -6, np.inf)
+
+ return self.df
+
+
+class GenericBatch(AbstractBatch):
+ """generic n-layer batch with each layer having the same oxygenation """
+
+ def __init__(self):
+ super(GenericBatch, self).__init__()
+
+ def append_one_layer(self, saO2, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # scales data to lie between maxi and mini instead of 0 and 1
+ scale = lambda x, mini, maxi: x * (maxi - mini) + mini
+ # shortcut to random generator
+ gen = np.random.random_sample
+ gen_n = np.random.normal
+
+ # create layer elements
+ self.df["layer" + str(self._nr_layers), "vhb"] = \
+ scale(gen(nr_samples), 0, 1.)
+ self.df["layer" + str(self._nr_layers), "sao2"] = \
+ saO2
+ self.df["layer" + str(self._nr_layers), "a_mie"] = \
+ np.clip(gen_n(loc=18.9, scale=10.2, size=nr_samples),
+ 0.1, np.inf) * 100 # to 1/m
+ self.df["layer" + str(self._nr_layers), "b_mie"] = \
+ np.clip(gen_n(loc=1.286, scale=0.521, size=nr_samples), 0, np.inf)
+ self.df["layer" + str(self._nr_layers), "d"] = \
+ scale(gen(nr_samples), 0, 1.)
+ self.df["layer" + str(self._nr_layers), "n"] = \
+ scale(gen(nr_samples), 1.33, 1.54)
+ self.df["layer" + str(self._nr_layers), "g"] = \
+ scale(gen(nr_samples), 0.8, 0.95)
+ self._nr_layers += 1
+
+ def create_parameters(self, nr_samples):
+ """Create generic three layer batch with a total diameter of 2mm.
+ saO2 is the same in all layers, but all other parameters vary randomly
+ within each layer"""
+ saO2 = np.random.random_sample(size=nr_samples)
+
+ # create three layers with random samples
+ self.append_one_layer(saO2, nr_samples)
+ self.append_one_layer(saO2, nr_samples)
+ self.append_one_layer(saO2, nr_samples)
+
+ # "normalize" d to 2mm
+ # first extract all layers from df
+ self.df
+
+ layers = [l for l in self.df.columns.levels[0] if "layer" in l]
+ # summarize all ds
+ sum_d = 0
+ for l in layers:
+ sum_d += self.df[l, "d"]
+ for l in layers:
+ self.df[l, "d"] = self.df[l, "d"] / sum_d * 2000. * 10 ** -6
+ self.df[l, "d"] = np.clip(self.df[l, "d"], 25 * 10 ** -6, np.inf)
+
+ return self.df
+
+
+class LessGenericBatch(AbstractBatch):
+ """less generic three layer batch. This only varies blood volume fraction
+ w.r.t. the ColonMuscleBatch. Let's see if DA works in this case."""
+
+ def __init__(self):
+ super(LessGenericBatch, self).__init__()
+
+ def append_one_layer(self, saO2, n, d_ranges, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # scales data to lie between maxi and mini instead of 0 and 1
+ scale = lambda x, mini, maxi: x * (maxi - mini) + mini
+ # shortcut to random generator
+ gen = np.random.random_sample
+
+ # create as generic batch
+ super(LessGenericBatch, self).append_one_layer(saO2, nr_samples)
+ self._nr_layers -= 1 # we're not finished
+
+ # but some changes in specific layer elements
+ # more specific layer thicknesses
+ self.df["layer" + str(self._nr_layers), "d"] = \
+ scale(gen(nr_samples), d_ranges[0], d_ranges[1])
+ # more specific n
+ self.df["layer" + str(self._nr_layers), "n"] = \
+ n
+
+ self._nr_layers += 1
+
+ def create_parameters(self, nr_samples):
+ """Create generic three layer batch with a total diameter of 2mm.
+ saO2 is the same in all layers, but all other parameters vary randomly
+ within each layer"""
+ saO2 = np.random.random_sample(size=nr_samples)
+ n = np.ones_like(saO2)
+ # create three layers with random samples
+ # muscle
+ self.append_one_layer(saO2, n * 1.36, (600.*10 ** -6, 1010.*10 ** -6),
+ nr_samples)
+ # submucosa
+ self.append_one_layer(saO2, n * 1.36, (415.*10 ** -6, 847.*10 ** -6),
+ nr_samples)
+ # mucosa
+ self.append_one_layer(saO2, n * 1.38, (395.*10 ** -6, 603.*10 ** -6),
+ nr_samples)
+
+ return self.df
+
+
+class ColonMuscleBatch(GenericBatch):
+ """three layer batch simulating colonic tissue"""
+
+ def __init__(self):
+ super(ColonMuscleBatch, self).__init__()
+
+ def append_one_layer(self, saO2, n, d_ranges, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # scales data to lie between maxi and mini instead of 0 and 1
+ scale = lambda x, mini, maxi: x * (maxi - mini) + mini
+ # shortcut to random generator
+ gen = np.random.random_sample
+
+ # create as generic batch
+ super(ColonMuscleBatch, self).append_one_layer(saO2, nr_samples)
+ self._nr_layers -= 1 # we're not finished
+
+ # but some changes in specific layer elements
+ # less blood
+ self.df["layer" + str(self._nr_layers), "vhb"] = \
+ scale(gen(nr_samples), 0, 0.1)
+ # more specific layer thicknesses
+ self.df["layer" + str(self._nr_layers), "d"] = \
+ scale(gen(nr_samples), d_ranges[0], d_ranges[1])
+ # more specific n
+ self.df["layer" + str(self._nr_layers), "n"] = \
+ n
+
+ self._nr_layers += 1
+
+ def create_parameters(self, nr_samples):
+ """Create generic three layer batch with a total diameter of 2mm.
+ saO2 is the same in all layers, but all other parameters vary randomly
+ within each layer"""
+ saO2 = np.random.random_sample(size=nr_samples)
+ n = np.ones_like(saO2)
+ # create three layers with random samples
+ # muscle
+ self.append_one_layer(saO2, n * 1.36, (600.*10 ** -6, 1010.*10 ** -6),
+ nr_samples)
+ # submucosa
+ self.append_one_layer(saO2, n * 1.36, (415.*10 ** -6, 847.*10 ** -6),
+ nr_samples)
+ # mucosa
+ self.append_one_layer(saO2, n * 1.38, (395.*10 ** -6, 603.*10 ** -6),
+ nr_samples)
+
+ return self.df
+
+
+class GenericMeanScatteringBatch(GenericBatch):
+ """three layer batch simulating colonic tissue"""
+
+ def __init__(self):
+ super(GenericMeanScatteringBatch, self).__init__()
+
+ def append_one_layer(self, saO2, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # create as generic batch
+ super(GenericMeanScatteringBatch, self).append_one_layer(saO2,
+ nr_samples)
+ self._nr_layers -= 1 # we're not finished
+
+ # restrict exponential scattering to mean value for soft tissue.
+ self.df["layer" + str(self._nr_layers), "b_mie"] = 1.286
+
+ self._nr_layers += 1
+
+
+class ColonMuscleMeanScatteringBatch(ColonMuscleBatch):
+ """three layer batch simulating colonic tissue"""
+
+ def __init__(self):
+ super(ColonMuscleMeanScatteringBatch, self).__init__()
+
+ def append_one_layer(self, saO2, n, d_ranges, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # create as generic batch
+ super(ColonMuscleMeanScatteringBatch, self).append_one_layer(saO2,
+ n,
+ d_ranges,
+ nr_samples)
+ self._nr_layers -= 1 # we're not finished
+
+ # restrict exponential scattering to mean value for soft tissue.
+ self.df["layer" + str(self._nr_layers), "b_mie"] = 1.286
+
+ self._nr_layers += 1
+
+
+class VisualizationBatch(AbstractBatch):
+ """batch used for visualization of different spectra. Feel free to adapt
+ for your visualization purposes."""
+
+ def __init__(self):
+ super(VisualizationBatch, self).__init__()
+
+ def append_one_layer(self, vhb, sao2, a_mie, b_mie, d, n, g, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # create layer elements
+ self.df["layer" + str(self._nr_layers), "vhb"] = vhb
+ self.df["layer" + str(self._nr_layers), "sao2"] = sao2
+ self.df["layer" + str(self._nr_layers), "a_mie"] = a_mie
+ self.df["layer" + str(self._nr_layers), "b_mie"] = b_mie
+ self.df["layer" + str(self._nr_layers), "d"] = d
+ self.df["layer" + str(self._nr_layers), "n"] = n
+ self.df["layer" + str(self._nr_layers), "g"] = g
+ self._nr_layers += 1
+
+ def create_parameters(self, nr_samples):
+ # bvf = np.linspace(0.0, .1, nr_samples)
+ # saO2 = np.linspace(0., 1., nr_samples)
+ # d = np.linspace(175, 735, nr_samples) * 10 ** -6
+ # a_mie = np.linspace(5., 30., nr_samples) * 100
+ # a_ray = np.linspace(0., 60., nr_samples) * 100
+ # n = np.linspace(1.33, 1.54, nr_samples)
+ # g = np.linspace(0, 0.95, nr_samples)
+ # create three layers with random samples
+ self.append_one_layer([0.1, 0.02], [0.7, 0.1], 18.9*100., 1.286,
+ 500 * 10 ** -6, 1.38, 0.9,
+ nr_samples)
+ self.append_one_layer(0.04, 0.7, 18.9*100., 1.286, 500 * 10 ** -6,
+ 1.36, 0.9,
+ nr_samples)
+ self.append_one_layer(0.04, 0.7, 18.9*100., 1.286, 500 * 10 ** -6,
+ 1.36, 0.9,
+ nr_samples)
+
+ return self.df
+
+
+class IntralipidPhantomBatch(AbstractBatch):
+ """batch used for visualization of different spectra. Feel free to adapt
+ for your visualization purposes."""
+
+ def __init__(self):
+ super(IntralipidPhantomBatch, self).__init__()
+
+ def append_one_layer(self, nr_samples):
+ """helper function to create parameters for one layer"""
+
+ # scales data to lie between maxi and mini instead of 0 and 1
+ scale = lambda x, mini, maxi: x * (maxi - mini) + mini
+ # shortcut to random generator
+ gen = np.random.random_sample
+
+ # create layer elements
+ self.df["layer" + str(self._nr_layers), "vhb"] = \
+ scale(gen(nr_samples), 0.001, 0.1)
+ self.df["layer" + str(self._nr_layers), "sao2"] = \
+ scale(gen(nr_samples), 0., 1.)
+ self.df["layer" + str(self._nr_layers), "a_mie"] = \
+ scale(gen(nr_samples), 5., 40.) * 100 # to 1/m
+ self.df["layer" + str(self._nr_layers), "b_mie"] = \
+ scale(gen(nr_samples), 2.3, 2.4)
+ self.df["layer" + str(self._nr_layers), "d"] = \
+ 2000.*10**-6
+ self.df["layer" + str(self._nr_layers), "n"] = \
+ scale(gen(nr_samples), 1.33, 1.54)
+ self.df["layer" + str(self._nr_layers), "g"] = \
+ scale(gen(nr_samples), 0.8, 0.95)
+ self._nr_layers += 1
+
+ def create_parameters(self, nr_samples):
+ """Create intralipid batch with a total diameter of 2mm.
+ all other parameters vary randomly
+ within each layer to simulate the interlipid scattering/absorption
+ properties."""
+
+ # create three layers with random samples
+ self.append_one_layer(nr_samples)
+
+ return self.df
diff --git a/Modules/Biophotonics/python/iMC/mc/create_spectrum.py b/Modules/Biophotonics/python/iMC/mc/create_spectrum.py
new file mode 100644
index 0000000000..8d42ea197c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/create_spectrum.py
@@ -0,0 +1,41 @@
+
+import logging
+import time
+import os
+
+from mc.sim import get_diffuse_reflectance
+
+
+def create_spectrum(tissue_model, sim_wrapper, wavelengths):
+ """
+ Create a whole spectrum from one instance (dataframe_row) using our
+ tissue model at wavelength wavelength.
+
+ Args:
+ tissue_model: the model which should be used to generate the
+ spectrum
+ sim_wrapper: the simulation which should be used to generate the
+ reflectances
+ wavelengths: the wavelengths which shall be simulated
+
+ Returns: the simulated reflectances
+ """
+ start = time.time()
+ # map the _wavelengths array to reflectance list
+
+ def wavelength_to_reflectance(wavelength):
+ # helper function to determine the reflectance for a given
+ # wavelength using the current model and simulation
+ tissue_model.set_wavelength(wavelength)
+ tissue_model.create_mci_file()
+ sim_wrapper.run_simulation()
+ simulation_path = os.path.split(sim_wrapper.mcml_executable)[0]
+ return get_diffuse_reflectance(os.path.join(simulation_path,
+ tissue_model.
+ get_mco_filename()))
+ reflectances = map(wavelength_to_reflectance, wavelengths)
+ end = time.time()
+ # success!
+ logging.info("successfully ran simulation in " +
+ "{:.2f}".format(end - start) + " seconds")
+ return reflectances
diff --git a/Modules/Biophotonics/python/iMC/mc/data/beta_carotin.txt b/Modules/Biophotonics/python/iMC/mc/data/beta_carotin.txt
new file mode 100644
index 0000000000..902019d56c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/data/beta_carotin.txt
@@ -0,0 +1,1924 @@
+lambda beta carotin
+##Wavelength (nm) Molar Extinction (cm-1/M)
+219.74 860669
+219.99 866939
+220.24 873996
+220.49 887103
+220.74 901200
+220.99 914068
+221.24 931102
+221.49 952261
+221.74 984397
+221.99 1006831
+222.24 1032652
+222.49 1061135
+222.74 1081015
+222.99 1093144
+223.24 1101278
+223.49 1095590
+223.74 1087870
+223.99 1078610
+224.24 1055667
+224.49 1019649
+224.74 984279
+224.99 942523
+225.24 897948
+225.49 847468
+225.74 802920
+225.99 750521
+226.24 704257
+226.49 657528
+226.74 612102
+226.99 568332
+227.24 522203
+227.49 483550
+227.74 445839
+227.99 410272
+228.24 376479
+228.49 346892
+228.74 317864
+228.99 291931
+229.24 267330
+229.49 244432
+229.74 224462
+229.99 206460
+230.24 189372
+230.49 174797
+230.74 162312
+230.99 149431
+231.24 139576
+231.49 129411
+231.74 119268
+231.99 111778
+232.24 104297
+232.49 97028
+232.74 91749
+232.99 85840
+233.24 82466
+233.49 78359
+233.74 74179
+233.99 71819
+234.24 68531
+234.49 65721
+234.74 62361
+234.99 60073
+235.24 57992
+235.49 56889
+235.74 54353
+235.99 52961
+236.24 51795
+236.49 51443
+236.74 49052
+236.99 49363
+237.24 49200
+237.49 48552
+237.74 47755
+237.99 47755
+238.24 47872
+238.49 46494
+238.74 45877
+238.99 45503
+239.24 46845
+239.49 45570
+239.74 46489
+239.99 45822
+240.24 45151
+240.49 45629
+240.74 45232
+240.99 45426
+241.24 44949
+241.49 45723
+241.74 45863
+241.99 44908
+242.24 45165
+242.49 45219
+242.74 44710
+242.99 45597
+243.24 44814
+243.49 45192
+243.74 45250
+243.99 44863
+244.24 44926
+244.49 44841
+244.74 44660
+244.99 44359
+245.24 44796
+245.49 44260
+245.74 45746
+245.99 45404
+246.24 45917
+246.49 45759
+246.74 46012
+246.99 45386
+247.24 45372
+247.49 46291
+247.74 45656
+247.99 46417
+248.24 46989
+248.49 46750
+248.74 47615
+248.99 48034
+249.24 48313
+249.49 48295
+249.74 48777
+249.99 49601
+250.24 49817
+250.49 50290
+250.74 50169
+250.99 49971
+251.24 51047
+251.49 51475
+251.74 52313
+251.99 52551
+252.24 52416
+252.49 54020
+252.74 54168
+252.99 53988
+253.24 53583
+253.49 55038
+253.74 55213
+253.99 55308
+254.24 55155
+254.49 56299
+254.74 56546
+254.99 56470
+255.24 56546
+255.49 56929
+255.74 56641
+255.99 57726
+256.24 58510
+256.49 58433
+256.74 58609
+256.99 58830
+257.24 59411
+257.49 60199
+257.74 59785
+257.99 61920
+258.24 62595
+258.49 63109
+258.74 64541
+258.99 63901
+259.24 64662
+259.49 65284
+259.74 66779
+259.99 66365
+260.24 67946
+260.49 67734
+260.74 69689
+260.99 70594
+261.24 71004
+261.49 72387
+261.74 74004
+261.99 75368
+262.24 75283
+262.49 75864
+262.74 75738
+262.99 77503
+263.24 76265
+263.49 77116
+263.74 77976
+263.99 78476
+264.24 78827
+264.49 79215
+264.74 79841
+264.99 79246
+265.24 79341
+265.49 78886
+265.74 79652
+265.99 80958
+266.24 80696
+266.49 82030
+266.74 82214
+266.99 82201
+267.24 83273
+267.49 84101
+267.74 84790
+267.99 86502
+268.24 87196
+268.49 87479
+268.74 88029
+268.99 89853
+269.24 89641
+269.49 90925
+269.74 93334
+269.99 93983
+270.24 94415
+270.49 95136
+270.74 95951
+270.99 97046
+271.24 98482
+271.49 99924
+271.74 101248
+271.99 101460
+272.24 102617
+272.49 104198
+272.74 104572
+272.99 103621
+273.24 104112
+273.49 103928
+273.74 103185
+273.99 102324
+274.24 103414
+274.49 102270
+274.74 100802
+274.99 100099
+275.24 98856
+275.49 97528
+275.74 98050
+275.99 96253
+276.24 96469
+276.49 97104
+276.74 97212
+276.99 97663
+277.24 98329
+277.49 98235
+277.74 98523
+277.99 98942
+278.24 100099
+278.49 99757
+278.74 101550
+278.99 101649
+279.24 100933
+279.49 102689
+279.74 102865
+279.99 102743
+280.24 103266
+280.49 104220
+280.74 104018
+280.99 103748
+281.24 104797
+281.49 105247
+281.74 105878
+281.99 105954
+282.24 107324
+282.49 108333
+282.74 109679
+282.99 110400
+283.24 111179
+283.49 111332
+283.74 111499
+283.99 110323
+284.24 108968
+284.49 108432
+284.74 106148
+284.99 104653
+285.24 102905
+285.49 99717
+285.74 97735
+285.99 95681
+286.24 92771
+286.49 90096
+286.74 88344
+286.99 85795
+287.24 83975
+287.49 83147
+287.74 80728
+287.99 79206
+288.24 79071
+288.49 78386
+288.74 77503
+288.99 78206
+289.24 77125
+289.49 78053
+289.74 76715
+289.99 77215
+290.24 77035
+290.49 77913
+290.74 77071
+290.99 77715
+291.24 76454
+291.49 76783
+291.74 74440
+291.99 75175
+292.24 73260
+292.49 72198
+292.74 71828
+292.99 71576
+293.24 71725
+293.49 71535
+293.74 70918
+293.99 70319
+294.24 70306
+294.49 71035
+294.74 70603
+294.99 70896
+295.24 70797
+295.49 70783
+295.74 69067
+295.99 67986
+296.24 66658
+296.49 64874
+296.74 62600
+296.99 61176
+297.24 59316
+297.49 56191
+297.74 53763
+297.99 50912
+298.24 48412
+298.49 44381
+298.74 41994
+298.99 39296
+299.24 36734
+299.49 34342
+299.74 32923
+299.99 31887
+300.24 30667
+300.49 29343
+300.74 27352
+300.99 28383
+301.24 26834
+301.49 25902
+301.74 24852
+301.99 23951
+302.24 23591
+302.49 22627
+302.74 22717
+302.99 22136
+303.24 21889
+303.49 22100
+303.74 22961
+303.99 21911
+304.24 20664
+304.49 20551
+304.74 20934
+304.99 19150
+305.24 20736
+305.49 19983
+305.74 21087
+305.99 20245
+306.24 18448
+306.49 18254
+306.74 17547
+306.99 16808
+307.24 16777
+307.49 16434
+307.74 16232
+307.99 17605
+308.24 16551
+308.49 17214
+308.74 16664
+308.99 16218
+309.24 16601
+309.49 16939
+309.74 16205
+309.99 19488
+310.24 16412
+310.49 17713
+310.74 18520
+310.99 12223
+311.24 14417
+311.49 16669
+311.74 18119
+311.99 15633
+312.24 15871
+312.49 14016
+312.74 15961
+312.99 15457
+313.24 13570
+313.49 16808
+313.74 15669
+313.99 14421
+314.24 16033
+314.49 14642
+314.74 16385
+314.99 13471
+315.24 14871
+315.49 17218
+315.74 15943
+315.99 17722
+316.24 13056
+316.49 16376
+316.74 14218
+316.99 13444
+317.24 15043
+317.49 14808
+317.74 12493
+317.99 14142
+318.24 13034
+318.49 11939
+318.74 13980
+318.99 15398
+319.24 12804
+319.49 14115
+319.74 14277
+319.99 15561
+320.24 16313
+320.49 14525
+320.74 13642
+320.99 11989
+321.24 13939
+321.49 14367
+321.74 14759
+321.99 12133
+322.24 13624
+322.49 14430
+322.74 8715
+322.99 14687
+323.24 13741
+323.49 11989
+323.74 10408
+323.99 12457
+324.24 13241
+324.49 12881
+324.74 12376
+324.99 13309
+325.24 14390
+325.49 12120
+325.74 13155
+325.99 12120
+326.24 13552
+326.49 12597
+326.74 13300
+326.99 11822
+327.24 16074
+327.49 14097
+327.74 13498
+327.99 12624
+328.24 14426
+328.49 12291
+328.74 11822
+328.99 13106
+329.24 13863
+329.49 13056
+329.74 11061
+329.99 14421
+330.24 14417
+330.49 13083
+330.74 15079
+330.99 13691
+331.24 12201
+331.49 15858
+331.74 14128
+331.99 14903
+332.24 14727
+332.49 12435
+332.74 13052
+332.99 14660
+333.24 15223
+333.49 13520
+333.74 12002
+333.99 13655
+334.24 14056
+334.49 13705
+334.74 12313
+334.99 14272
+335.24 14295
+335.49 16786
+335.74 14813
+335.99 13565
+336.24 15128
+336.49 14200
+336.74 14241
+336.99 13975
+337.24 12165
+337.49 12854
+337.74 16070
+337.99 12939
+338.24 14484
+338.49 14727
+338.74 16151
+338.99 16245
+339.24 14529
+339.49 15313
+339.74 15655
+339.99 13791
+340.24 13822
+340.49 16466
+340.74 14390
+340.99 15889
+341.24 13714
+341.49 12903
+341.74 11899
+341.99 13854
+342.24 11629
+342.49 13813
+342.74 14853
+342.99 15475
+343.24 13944
+343.49 13637
+343.74 14529
+343.99 14056
+344.24 14466
+344.49 14957
+344.74 14079
+344.99 13953
+345.24 16088
+345.49 14678
+345.74 12854
+345.99 14944
+346.24 13219
+346.49 16070
+346.74 14556
+346.99 15281
+347.24 13998
+347.49 15043
+347.74 15038
+347.99 15565
+348.24 14723
+348.49 15164
+348.74 13660
+348.99 14002
+349.24 14480
+349.49 15579
+349.74 14678
+349.99 15786
+350.24 15880
+350.49 16146
+350.74 14390
+350.99 15020
+351.24 15007
+351.49 15502
+351.74 14209
+351.99 16236
+352.24 16880
+352.49 14142
+352.74 14709
+352.99 15254
+353.24 14678
+353.49 16052
+353.74 15038
+353.99 13822
+354.24 15281
+354.49 14601
+354.74 14588
+354.99 16583
+355.24 15187
+355.49 16678
+355.74 15232
+355.99 15380
+356.24 15466
+356.49 17695
+356.74 15534
+356.99 17934
+357.24 17358
+357.49 16344
+357.74 15511
+357.99 15781
+358.24 17137
+358.49 16813
+358.74 16587
+358.99 15664
+359.24 16673
+359.49 14529
+359.74 15412
+359.99 15412
+360.24 15714
+360.49 16862
+360.74 15723
+360.99 17907
+361.24 16574
+361.49 17502
+361.74 17295
+361.99 16673
+362.24 17141
+362.49 17795
+362.74 16178
+362.99 17646
+363.24 18047
+363.49 17975
+363.74 17389
+363.99 16786
+364.24 16745
+364.49 18614
+364.74 17331
+364.99 17686
+365.24 19191
+365.49 18857
+365.74 17056
+365.99 19529
+366.24 20862
+366.49 18862
+366.74 19281
+366.99 19776
+367.24 20452
+367.49 19727
+367.74 19623
+367.99 18574
+368.24 21010
+368.49 19911
+368.74 20812
+368.99 20028
+369.24 22623
+369.49 22425
+369.74 21695
+369.99 21609
+370.24 21308
+370.49 22456
+370.74 21591
+370.99 21555
+371.24 22578
+371.49 22956
+371.74 23033
+371.99 23641
+372.24 24204
+372.49 24150
+372.74 24123
+372.99 25019
+373.24 23528
+373.49 23469
+373.74 25523
+373.99 25361
+374.24 24298
+374.49 25068
+374.74 25244
+374.99 26555
+375.24 26762
+375.49 25352
+375.74 26244
+375.99 26451
+376.24 26654
+376.49 27352
+376.74 26591
+376.99 27451
+377.24 27424
+377.49 28518
+377.74 27892
+377.99 28577
+378.24 28338
+378.49 29059
+378.74 29298
+378.99 29928
+379.24 29253
+379.49 30090
+379.74 29847
+379.99 29757
+380.24 32072
+380.49 30329
+380.74 29325
+380.99 32432
+381.24 30365
+381.49 30424
+381.74 32013
+381.99 31068
+382.24 32824
+382.49 32959
+382.74 34991
+382.99 31968
+383.24 33045
+383.49 33599
+383.74 34049
+383.99 34923
+384.24 33482
+384.49 34774
+384.74 36216
+384.99 35004
+385.24 36008
+385.49 35981
+385.74 36450
+385.99 35626
+386.24 36828
+386.49 36954
+386.74 38242
+386.99 37833
+387.24 37616
+387.49 38977
+387.74 38472
+387.99 38454
+388.24 39576
+388.49 38796
+388.74 40656
+388.99 40003
+389.24 40733
+389.49 40107
+389.74 42683
+389.99 41850
+390.24 42098
+390.49 40931
+390.74 42791
+390.99 43976
+391.24 44219
+391.49 44246
+391.74 45836
+391.99 45904
+392.24 44570
+392.49 46881
+392.74 47948
+392.99 46849
+393.24 47448
+393.49 48187
+393.74 48863
+393.99 50925
+394.24 50723
+394.49 50916
+394.74 49691
+394.99 50151
+395.24 51164
+395.49 52340
+395.74 52096
+395.99 51624
+396.24 54218
+396.49 53326
+396.74 53754
+396.99 55420
+397.24 55465
+397.49 54529
+397.74 55632
+397.99 56407
+398.24 57528
+398.49 57091
+398.74 56961
+398.99 59213
+399.24 58726
+399.49 59208
+399.74 59109
+399.99 58312
+400.24 60258
+400.49 60744
+400.74 60505
+400.99 61185
+401.24 62154
+401.49 61483
+401.74 61023
+401.99 62302
+402.24 61348
+402.49 61676
+402.74 62717
+402.99 62919
+403.24 62879
+403.49 64248
+403.74 63455
+403.99 63627
+404.24 65315
+404.49 64874
+404.74 65644
+404.99 66126
+405.24 65203
+405.49 66360
+405.74 65117
+405.99 66631
+406.24 66333
+406.49 67063
+406.74 68004
+406.99 68117
+407.24 68063
+407.49 68108
+407.74 68747
+407.99 68189
+408.24 71153
+408.49 69270
+408.74 70999
+408.99 70135
+409.24 71612
+409.49 72414
+409.74 73071
+409.99 73202
+410.24 73179
+410.49 73873
+410.74 74963
+410.99 75463
+411.24 75206
+411.49 75805
+411.74 76260
+411.99 76634
+412.24 78287
+412.49 77485
+412.74 78656
+412.99 78692
+413.24 80233
+413.49 79859
+413.74 81250
+413.99 80426
+414.24 82710
+414.49 83723
+414.74 83723
+414.99 82223
+415.24 83354
+415.49 83633
+415.74 85885
+415.99 86389
+416.24 86750
+416.49 88132
+416.74 88398
+416.99 88259
+417.24 90065
+417.49 89979
+417.74 90416
+417.99 91672
+418.24 92141
+418.49 93294
+418.74 92389
+418.99 94789
+419.24 94744
+419.49 95321
+419.74 96519
+419.99 97374
+420.24 97712
+420.49 97825
+420.74 98014
+420.99 99496
+421.24 99347
+421.49 99527
+421.74 99527
+421.99 100442
+422.24 100955
+422.49 101784
+422.74 102153
+422.99 103176
+423.24 103428
+423.49 103626
+423.74 103468
+423.99 103338
+424.24 103757
+424.49 104738
+424.74 105297
+424.99 105923
+425.24 105756
+425.49 105819
+425.74 106126
+425.99 106094
+426.24 106166
+426.49 105085
+426.74 105711
+426.99 105774
+427.24 106162
+427.49 107071
+427.74 107080
+427.99 106824
+428.24 107193
+428.49 106770
+428.74 108269
+428.99 107216
+429.24 107855
+429.49 107589
+429.74 107445
+429.99 106824
+430.24 107324
+430.49 107711
+430.74 109035
+430.99 107571
+431.24 108634
+431.49 108661
+431.74 107621
+431.99 109040
+432.24 108008
+432.49 108801
+432.74 109179
+432.99 109801
+433.24 109459
+433.49 109341
+433.74 110170
+433.99 110003
+434.24 110116
+434.49 109801
+434.74 111197
+434.99 111436
+435.24 110805
+435.49 112053
+435.74 111643
+435.99 113197
+436.24 112742
+436.49 113008
+436.74 115215
+436.99 114129
+437.24 113994
+437.49 115435
+437.74 116111
+437.99 116147
+438.24 116593
+438.49 117701
+438.74 118205
+438.99 117944
+439.24 118453
+439.49 119908
+439.74 119529
+439.99 120966
+440.24 120948
+440.49 121295
+440.74 122556
+440.99 123367
+441.24 124087
+441.49 124380
+441.74 125105
+441.99 126781
+442.24 124200
+442.49 126961
+442.74 127037
+442.99 127835
+443.24 128785
+443.49 127609
+443.74 129172
+443.99 130510
+444.24 130758
+444.49 130731
+444.74 131604
+444.99 132086
+445.24 132609
+445.49 132721
+445.74 132582
+445.99 135095
+446.24 135649
+446.49 133969
+446.74 134676
+446.99 135383
+447.24 136428
+447.49 135964
+447.74 136752
+447.99 136270
+448.24 137604
+448.49 138288
+448.74 137329
+448.99 136698
+449.24 137464
+449.49 139171
+449.74 139342
+449.99 138730
+450.24 138243
+450.49 139356
+450.74 138590
+450.99 139500
+451.24 137541
+451.49 138509
+451.74 138342
+451.99 137401
+452.24 137887
+452.49 137820
+452.74 136518
+452.99 137572
+453.24 136653
+453.49 136000
+453.74 135915
+453.99 135550
+454.24 135437
+454.49 133577
+454.74 134036
+454.99 133122
+455.24 134000
+455.49 132424
+455.74 133253
+455.99 130983
+456.24 131816
+456.49 131920
+456.74 129028
+456.99 129478
+457.24 129087
+457.49 129015
+457.74 126893
+457.99 126808
+458.24 125736
+458.49 125065
+458.74 125335
+458.99 124367
+459.24 123227
+459.49 122187
+459.74 121966
+459.99 121173
+460.24 119818
+460.49 119651
+460.74 119435
+460.99 118336
+461.24 118070
+461.49 116665
+461.74 116818
+461.99 116273
+462.24 114805
+462.49 114057
+462.74 113998
+462.99 113535
+463.24 113904
+463.49 112882
+463.74 111368
+463.99 112332
+464.24 111233
+464.49 111436
+464.74 109504
+464.99 110148
+465.24 110386
+465.49 109990
+465.74 109431
+465.99 110161
+466.24 110139
+466.49 108369
+466.74 108981
+466.99 107995
+467.24 107450
+467.49 107445
+467.74 107661
+467.99 108432
+468.24 107621
+468.49 108796
+468.74 107517
+468.99 107607
+469.24 108378
+469.49 107977
+469.74 108251
+469.99 108427
+470.24 108792
+470.49 108900
+470.74 108157
+470.99 109283
+471.24 109350
+471.49 109805
+471.74 109094
+471.99 109197
+472.24 109319
+472.49 109058
+472.74 109940
+472.99 110148
+473.24 110472
+473.49 110071
+473.74 111864
+473.99 111409
+474.24 110747
+474.49 111733
+474.74 111134
+474.99 112395
+475.24 112972
+475.49 112566
+475.74 112521
+475.99 111765
+476.24 111747
+476.49 111792
+476.74 112778
+476.99 110404
+477.24 112314
+477.49 112476
+477.74 113111
+477.99 112368
+478.24 111850
+478.49 110445
+478.74 111517
+478.99 110711
+479.24 110828
+479.49 110382
+479.74 109873
+479.99 110769
+480.24 110166
+480.49 108936
+480.74 108427
+480.99 108409
+481.24 108837
+481.49 107270
+481.74 105716
+481.99 106765
+482.24 105491
+482.49 104711
+482.74 103712
+482.99 104356
+483.24 103198
+483.49 102941
+483.74 101518
+483.99 100162
+484.24 99802
+484.49 98491
+484.74 98960
+484.99 96757
+485.24 96248
+485.49 95622
+485.74 94663
+485.99 95114
+486.24 93803
+486.49 91772
+486.74 91551
+486.99 89497
+487.24 89529
+487.49 85826
+487.74 86646
+487.99 85047
+488.24 85115
+488.49 83304
+488.74 81021
+488.99 80611
+489.24 80399
+489.49 79075
+489.74 77318
+489.99 76107
+490.24 74945
+490.49 74323
+490.74 72553
+490.99 70999
+491.24 71265
+491.49 70590
+491.74 68027
+491.99 66887
+492.24 65180
+492.49 64514
+492.74 63618
+492.99 62996
+493.24 59983
+493.49 59379
+493.74 57789
+493.99 58560
+494.24 55605
+494.49 55024
+494.74 54200
+494.99 52736
+495.24 52376
+495.49 50371
+495.74 50218
+495.99 49926
+496.24 48696
+496.49 47142
+496.74 46525
+496.99 45332
+497.24 44390
+497.49 42030
+497.74 41454
+497.99 40458
+498.24 41260
+498.49 37598
+498.74 37044
+498.99 36337
+499.24 35968
+499.49 34621
+499.74 33729
+499.99 32662
+500.24 32135
+500.49 32657
+500.74 30180
+500.99 29933
+501.24 28100
+501.49 27982
+501.74 27437
+501.99 26257
+502.24 24960
+502.49 25203
+502.74 24942
+502.99 24686
+503.24 23118
+503.49 22375
+503.74 21353
+503.99 20673
+504.24 19871
+504.49 20407
+504.74 18155
+504.99 19186
+505.24 19596
+505.49 17912
+505.74 16619
+505.99 16867
+506.24 16880
+506.49 15628
+506.74 15205
+506.99 15434
+507.24 14736
+507.49 13628
+507.74 13016
+507.99 13286
+508.24 13223
+508.49 13417
+508.74 12363
+508.99 11259
+509.24 11800
+509.49 10606
+509.74 9760
+509.99 10985
+510.24 10440
+510.49 9751
+510.74 10277
+510.99 9890
+511.24 9287
+511.49 9683
+511.74 8845
+511.99 8039
+512.24 7296
+512.49 7192
+512.74 7215
+512.99 7994
+513.24 7449
+513.49 6850
+513.74 7003
+513.99 7147
+514.24 6652
+514.49 7490
+514.74 6341
+514.99 6539
+515.24 5129
+515.49 5084
+515.74 4206
+515.99 4963
+516.24 4859
+516.49 5557
+516.74 5490
+516.99 4585
+517.24 4828
+517.49 4278
+517.74 4301
+517.99 4350
+518.24 5098
+518.49 4562
+518.74 4062
+518.99 4589
+519.24 3778
+519.49 3220
+519.74 3639
+519.99 3386
+520.24 3319
+520.49 2850
+520.74 3823
+520.99 4305
+521.24 3666
+521.49 3400
+521.74 1900
+521.99 4188
+522.24 2418
+522.49 3350
+522.74 2116
+522.99 2670
+523.24 3585
+523.49 2535
+523.74 3355
+523.99 1621
+524.24 2661
+524.49 2306
+524.74 2441
+524.99 2026
+525.24 1990
+525.49 2706
+525.74 2319
+525.99 1806
+526.24 2026
+526.49 3058
+526.74 2233
+526.99 319
+527.24 1873
+527.49 2814
+527.74 2837
+527.99 1999
+528.24 1612
+528.49 2143
+528.74 1977
+528.99 3026
+529.24 1549
+529.49 1180
+529.74 1508
+529.99 2229
+530.24 2040
+530.49 824
+530.74 1607
+530.99 1562
+531.24 2260
+531.49 1157
+531.74 1193
+531.99 1810
+532.24 675
+532.49 1837
+532.74 801
+532.99 1801
+533.24 2405
+533.49 963
+533.74 743
+533.99 540
+534.24 1688
+534.49 1288
+534.74 1806
+534.99 454
+535.24 2053
+535.49 1603
+535.74 1896
+535.99 1184
+536.24 -67
+536.49 1423
+536.74 1697
+536.99 986
+537.24 653
+537.49 247
+537.74 157
+537.99 -405
+538.24 1022
+538.49 797
+538.74 1495
+538.99 2062
+539.24 999
+539.49 1634
+539.74 -229
+539.99 2143
+540.24 571
+540.49 1797
+540.74 1274
+540.99 909
+541.24 1355
+541.49 1391
+541.74 1567
+541.99 1157
+542.24 855
+542.49 571
+542.74 810
+542.99 1229
+543.24 1130
+543.49 1035
+543.74 1198
+543.99 571
+544.24 1279
+544.49 319
+544.74 1283
+544.99 702
+545.24 774
+545.49 0
+545.74 1265
+545.99 963
+546.24 -297
+546.49 819
+546.74 427
+546.99 1923
+547.24 495
+547.49 1238
+547.74 405
+547.99 1292
+548.24 882
+548.49 657
+548.74 567
+548.99 900
+549.24 1851
+549.49 1202
+549.74 1373
+549.99 1369
+550.24 1756
+550.49 1153
+550.74 851
+550.99 1675
+551.24 729
+551.49 1279
+551.74 806
+551.99 -495
+552.24 508
+552.49 544
+552.74 1013
+552.99 621
+553.24 229
+553.49 972
+553.74 1697
+553.99 234
+554.24 27
+554.49 1490
+554.74 369
+554.99 747
+555.24 1963
+555.49 585
+555.74 1756
+555.99 13
+556.24 1107
+556.49 -58
+556.74 783
+556.99 1490
+557.24 -337
+557.49 1860
+557.74 666
+557.99 459
+558.24 117
+558.49 977
+558.74 310
+558.99 1026
+559.24 -3
+559.49 1576
+559.74 900
+559.99 -1184
+560.24 774
+560.49 936
+560.74 360
+560.99 801
+561.24 -819
+561.49 1580
+561.74 63
+561.99 1112
+562.24 571
+562.49 833
+562.74 283
+562.99 -211
+563.24 1035
+563.49 252
+563.74 792
+563.99 -481
+564.24 288
+564.49 540
+564.74 31
+564.99 1585
+565.24 -94
+565.49 1427
+565.74 675
+565.99 1252
+566.24 1499
+566.49 -977
+566.74 648
+566.99 -198
+567.24 1549
+567.49 1089
+567.74 680
+567.99 -423
+568.24 198
+568.49 878
+568.74 189
+568.99 193
+569.24 576
+569.49 1022
+569.74 630
+569.99 653
+570.24 481
+570.49 270
+570.74 216
+570.99 1216
+571.24 873
+571.49 -756
+571.74 1589
+571.99 175
+572.24 909
+572.49 -499
+572.74 1134
+572.99 472
+573.24 1162
+573.49 1702
+573.74 36
+573.99 1026
+574.24 1130
+574.49 896
+574.74 1058
+574.99 972
+575.24 1107
+575.49 702
+575.74 1454
+575.99 1116
+576.24 1562
+576.49 707
+576.74 1130
+576.99 1576
+577.24 364
+577.49 18
+577.74 666
+577.99 175
+578.24 905
+578.49 364
+578.74 2161
+578.99 684
+579.24 1342
+579.49 130
+579.74 923
+579.99 833
+580.24 1116
+580.49 666
+580.74 27
+580.99 1189
+581.24 454
+581.49 139
+581.74 -414
+581.99 481
+582.24 2022
+582.49 743
+582.74 594
+582.99 657
+583.24 1026
+583.49 1630
+583.74 207
+583.99 319
+584.24 553
+584.49 1166
+584.74 716
+584.99 1107
+585.24 -72
+585.49 815
+585.74 1382
+585.99 1445
+586.24 860
+586.49 535
+586.74 819
+586.99 355
+587.24 400
+587.49 626
+587.74 -121
+587.99 1175
+588.24 1116
+588.49 788
+588.74 -198
+588.99 1490
+589.24 1279
+589.49 -499
+589.74 1049
+589.99 103
+590.24 481
+590.49 1153
+590.74 1396
+590.99 -193
+591.24 999
+591.49 364
+591.74 972
+591.99 891
+592.24 -31
+592.49 810
+592.74 1171
+592.99 626
+593.24 959
+593.49 1143
+593.74 297
+593.99 558
+594.24 -94
+594.49 918
+594.74 504
+594.99 1022
+595.24 626
+595.49 211
+595.74 490
+595.99 1391
+596.24 220
+596.49 617
+596.74 261
+596.99 346
+597.24 828
+597.49 162
+597.74 121
+597.99 36
+598.24 184
+598.49 1360
+598.74 1022
+598.99 630
+599.24 1116
+599.49 1819
+599.74 -45
+599.99 734
+600.24 522
+600.49 558
+600.74 887
+600.99 81
+601.24 1373
+601.49 297
+601.74 1427
+601.99 -603
+602.24 81
+602.49 1351
+602.74 891
+602.99 635
+603.24 963
+603.49 -247
+603.74 1058
+603.99 936
+604.24 1688
+604.49 -162
+604.74 1342
+604.99 680
+605.24 963
+605.49 567
+605.74 1171
+605.99 1238
+606.24 693
+606.49 1517
+606.74 526
+606.99 792
+607.24 436
+607.49 1508
+607.74 -328
+607.99 -144
+608.24 1567
+608.49 914
+608.74 702
+608.99 891
+609.24 535
+609.49 1261
+609.74 495
+609.99 1630
+610.24 486
+610.49 1116
+610.74 1274
+610.99 1130
+611.24 914
+611.49 1022
+611.74 1504
+611.99 441
+612.24 1216
+612.49 279
+612.74 729
+612.99 1693
+613.24 968
+613.49 1234
+613.74 851
+613.99 698
+614.24 873
+614.49 1040
+614.74 617
+614.99 684
+615.24 1472
+615.49 608
+615.74 779
+615.99 -139
+616.24 1851
+616.49 1391
+616.74 1540
+616.99 463
+617.24 1080
+617.49 450
+617.74 1058
+617.99 1067
+618.24 819
+618.49 783
+618.74 747
+618.99 603
+619.24 1454
+619.49 896
+619.74 1243
+619.99 1743
+620.24 535
+620.49 1607
+620.74 -198
+620.99 1026
+621.24 535
+621.49 54
+621.74 1121
+621.99 432
+622.24 1243
+622.49 846
+622.74 918
+622.99 662
+623.24 2058
+623.49 207
+623.74 508
+623.99 869
+624.24 -13
+624.49 1387
+624.74 950
+624.99 1779
+625.24 1017
+625.49 1369
+625.74 720
+625.99 346
+626.24 2076
+626.49 319
+626.74 1495
+626.99 1202
+627.24 1274
+627.49 2175
+627.74 743
+627.99 1977
+628.24 680
+628.49 1292
+628.74 1234
+628.99 1914
+629.24 626
+629.49 27
+629.74 1882
+629.99 535
+630.24 1495
+630.49 1171
+630.74 720
+630.99 571
+631.24 1049
+631.49 680
+631.74 788
+631.99 1981
+632.24 738
+632.49 801
+632.74 986
+632.99 837
+633.24 1265
+633.49 1481
+633.74 1896
+633.99 738
+634.24 990
+634.49 729
+634.74 968
+634.99 1684
+635.24 963
+635.49 2310
+635.74 743
+635.99 1071
+636.24 1247
+636.49 617
+636.74 2139
+636.99 1688
+637.24 1432
+637.49 1004
+637.74 788
+637.99 1234
+638.24 761
+638.49 806
+638.74 743
+638.99 1589
+639.24 1490
+639.49 2116
+639.74 1774
+639.99 936
+640.24 1612
+640.49 1193
+640.74 977
+640.99 720
+641.24 1238
+641.49 1657
+641.74 900
+641.99 1603
+642.24 761
+642.49 878
+642.74 599
+642.99 585
+643.24 1891
+643.49 1684
+643.74 2022
+643.99 1634
+644.24 873
+644.49 342
+644.74 1373
+644.99 346
+645.24 1774
+645.49 1107
+645.74 977
+645.99 1909
+646.24 468
+646.49 1171
+646.74 662
+646.99 1837
+647.24 274
+647.49 562
+647.74 932
+647.99 621
+648.24 648
+648.49 815
+648.74 1220
+648.99 1022
+649.24 1067
+649.49 828
+649.74 373
+649.99 553
+650.24 828
+650.49 1116
+650.74 1752
+650.99 297
+651.24 2085
+651.49 45
+651.74 1103
+651.99 562
+652.24 1234
+652.49 540
+652.74 581
+652.99 400
+653.24 1288
+653.49 644
+653.74 423
+653.99 1472
+654.24 490
+654.49 684
+654.74 1571
+654.99 1094
+655.24 535
+655.49 198
+655.74 454
+655.99 666
+656.24 445
+656.49 234
+656.74 544
+656.99 1594
+657.24 806
+657.49 941
+657.74 797
+657.99 914
+658.25 234
+658.5 819
+658.75 873
+659 36
+659.25 1481
+659.5 1306
+659.75 662
+660 454
+660.25 1013
+660.5 945
+660.75 -108
+661 1504
+661.25 472
+661.5 1004
+661.75 391
+662 -67
+662.25 648
+662.5 -139
+662.75 869
+663 306
+663.25 1400
+663.5 1116
+663.75 887
+664 1040
+664.25 391
+664.5 378
+664.75 -337
+665 666
+665.25 562
+665.5 112
+665.75 806
+666 544
+666.25 1508
+666.5 90
+666.75 211
+667 378
+667.25 -441
+667.5 540
+667.75 486
+668 562
+668.25 -36
+668.5 247
+668.75 423
+669 -486
+669.25 225
+669.5 918
+669.75 1049
+670 1409
+670.25 549
+670.5 477
+670.75 369
+671 283
+671.25 891
+671.5 171
+671.75 49
+672 387
+672.25 1008
+672.5 405
+672.75 67
+673 -175
+673.25 905
+673.5 -139
+673.75 558
+674 945
+674.25 959
+674.5 450
+674.75 508
+675 234
+675.25 297
+675.5 -13
+675.75 -49
+676 414
+676.25 382
+676.5 -103
+676.75 1013
+677 639
+677.25 513
+677.5 -58
+677.75 1661
+678 -153
+678.25 40
+678.5 130
+678.75 639
+679 941
+679.25 -477
+679.5 -108
+679.75 180
+680 472
+680.25 765
+680.5 -297
+680.75 1220
+681 684
+681.25 450
+681.5 234
+681.75 310
+682 -54
+682.25 279
+682.5 261
+682.75 499
+683 -135
+683.25 517
+683.5 -2
+683.75 94
+684 72
+684.25 680
+684.5 -108
+684.75 279
+685 513
+685.25 -328
+685.5 594
+685.75 126
+686 675
+686.25 103
+686.5 387
+686.75 927
+687 -310
+687.25 364
+687.5 306
+687.75 756
+688 810
+688.25 725
+688.5 54
+688.75 40
+689 720
+689.25 409
+689.5 657
+689.75 315
+690 599
+690.25 373
+690.5 -247
+690.75 490
+691 54
+691.25 540
+691.5 -126
+691.75 -549
+692 486
+692.25 788
+692.5 -234
+692.75 -162
+693 171
+693.25 409
+693.5 477
+693.75 -981
+694 157
+694.25 99
+694.5 1071
+694.75 -648
+695 -58
+695.25 477
+695.5 220
+695.75 211
+696 -171
+696.25 126
+696.5 666
+696.75 166
+697 743
+697.25 387
+697.5 -130
+697.75 716
+698 409
+698.25 4
+698.5 774
+698.75 1639
+699 252
+699.25 396
+699.5 -454
+699.75 -148
+700 1436
diff --git a/Modules/Biophotonics/python/iMC/mc/data/bilirubin.txt b/Modules/Biophotonics/python/iMC/mc/data/bilirubin.txt
new file mode 100644
index 0000000000..3ca6e8e1c0
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/data/bilirubin.txt
@@ -0,0 +1,1844 @@
+# taken from http://omlc.org/spectra/PhotochemCAD/data/119-abs.txt
+##Wavelength (nm) Molar Extinction (cm-1/M)
+239.75 17208
+240 16074
+240.25 18576
+240.5 16910
+240.75 17810
+241 17784
+241.25 17734
+241.5 18617
+241.75 17737
+242 17532
+242.25 17582
+242.5 17609
+242.75 17141
+243 17102
+243.25 16666
+243.5 16594
+243.75 16111
+244 16576
+244.25 15964
+244.5 15470
+244.75 15805
+245 15304
+245.25 15243
+245.5 15230
+245.75 14725
+246 14481
+246.25 14588
+246.5 14454
+246.75 14002
+247 14152
+247.25 13951
+247.5 13735
+247.75 13755
+248 13531
+248.25 13231
+248.5 13354
+248.75 13226
+249 12855
+249.25 13256
+249.5 12851
+249.75 12557
+250 12254
+250.25 12287
+250.5 12174
+250.75 12231
+251 11840
+251.25 11772
+251.5 11575
+251.75 11246
+252 11231
+252.25 11165
+252.5 11021
+252.75 11034
+253 11068
+253.25 10789
+253.5 10691
+253.75 10568
+254 10477
+254.25 10341
+254.5 10346
+254.75 10029
+255 10164
+255.25 10055
+255.5 9970
+255.75 9865
+256 9945
+256.25 9764
+256.5 9632
+256.75 9781
+257 9670
+257.25 9526
+257.5 9223
+257.75 9096
+258 9220
+258.25 9312
+258.5 9145
+258.75 9138
+259 8955
+259.25 8984
+259.5 8862
+259.75 8933
+260 8891
+260.25 8896
+260.5 8816
+260.75 8984
+261 8774
+261.25 8840
+261.5 8737
+261.75 8679
+262 8719
+262.25 8874
+262.5 8777
+262.75 8685
+263 8627
+263.25 8732
+263.5 8527
+263.75 8572
+264 8650
+264.25 8812
+264.5 8614
+264.75 8601
+265 8612
+265.25 8688
+265.5 8513
+265.75 8498
+266 8698
+266.25 8554
+266.5 8479
+266.75 8449
+267 8560
+267.25 8544
+267.5 8536
+267.75 8448
+268 8470
+268.25 8574
+268.5 8519
+268.75 8580
+269 8518
+269.25 8460
+269.5 8514
+269.75 8616
+270 8620
+270.25 8681
+270.5 8436
+270.75 8509
+271 8573
+271.25 8526
+271.5 8474
+271.75 8543
+272 8591
+272.25 8515
+272.5 8537
+272.75 8695
+273 8550
+273.25 8547
+273.5 8596
+273.75 8545
+274 8435
+274.25 8695
+274.5 8471
+274.75 8560
+275 8727
+275.25 8631
+275.5 8652
+275.75 8360
+276 8625
+276.25 8456
+276.5 8639
+276.75 8632
+277 8473
+277.25 8521
+277.5 8589
+277.75 8557
+278 8627
+278.25 8344
+278.5 8597
+278.75 8561
+279 8646
+279.25 8452
+279.5 8527
+279.75 8426
+280 8634
+280.25 8461
+280.5 8496
+280.75 8525
+281 8383
+281.25 8515
+281.5 8307
+281.75 8411
+282 8374
+282.25 8663
+282.5 8398
+282.75 8418
+283 8501
+283.25 8565
+283.5 8227
+283.75 8286
+284 8582
+284.25 8334
+284.5 8305
+284.75 8220
+285 8313
+285.25 8211
+285.5 8302
+285.75 8226
+286 8234
+286.25 8471
+286.5 8205
+286.75 8313
+287 8258
+287.25 8237
+287.5 8234
+287.75 8210
+288 8104
+288.25 8203
+288.5 8269
+288.75 8138
+289 8030
+289.25 8063
+289.5 8104
+289.75 8119
+290 7874
+290.25 7970
+290.5 8081
+290.75 8068
+291 8115
+291.25 7943
+291.5 7911
+291.75 7808
+292 7876
+292.25 7947
+292.5 7832
+292.75 8024
+293 7867
+293.25 7657
+293.5 7798
+293.75 7739
+294 7745
+294.25 7622
+294.5 7718
+294.75 7922
+295 7810
+295.25 7709
+295.5 7784
+295.75 7745
+296 7644
+296.25 7642
+296.5 7512
+296.75 7609
+297 7791
+297.25 7664
+297.5 7414
+297.75 7515
+298 7596
+298.25 7627
+298.5 7578
+298.75 7628
+299 7569
+299.25 7374
+299.5 7429
+299.75 7468
+300 7370
+300.25 7448
+300.5 7331
+300.75 7592
+301 7374
+301.25 7214
+301.5 7484
+301.75 7449
+302 7282
+302.25 7230
+302.5 7328
+302.75 7071
+303 7348
+303.25 7135
+303.5 7224
+303.75 7300
+304 7399
+304.25 7224
+304.5 7244
+304.75 7208
+305 7085
+305.25 7036
+305.5 7257
+305.75 7153
+306 6989
+306.25 6795
+306.5 7012
+306.75 6993
+307 7047
+307.25 7085
+307.5 6900
+307.75 6823
+308 6737
+308.25 6897
+308.5 6852
+308.75 7083
+309 6903
+309.25 6895
+309.5 6826
+309.75 6820
+310 6811
+310.25 6907
+310.5 6804
+310.75 6522
+311 6559
+311.25 6618
+311.5 6688
+311.75 6701
+312 6632
+312.25 6548
+312.5 6667
+312.75 6580
+313 6519
+313.25 6607
+313.5 6338
+313.75 6559
+314 6529
+314.25 6385
+314.5 6425
+314.75 6346
+315 6458
+315.25 6318
+315.5 6260
+315.75 6212
+316 6277
+316.25 6176
+316.5 6219
+316.75 6363
+317 6160
+317.25 6304
+317.5 6070
+317.75 6201
+318 6177
+318.25 6108
+318.5 6033
+318.75 5911
+319 5864
+319.25 5951
+319.5 5995
+319.75 5901
+320 6010
+320.25 5815
+320.5 5753
+320.75 5996
+321 5886
+321.25 5830
+321.5 5816
+321.75 5627
+322 5870
+322.25 5621
+322.5 5559
+322.75 5697
+323 5679
+323.25 5544
+323.5 5478
+323.75 5637
+324 5690
+324.25 5486
+324.5 5325
+324.75 5452
+325 5328
+325.25 5432
+325.5 5564
+325.75 5209
+326 5194
+326.25 5150
+326.5 5252
+326.75 5311
+327 5056
+327.25 5097
+327.5 5312
+327.75 5208
+328 5030
+328.25 4895
+328.5 5167
+328.75 5078
+329 4928
+329.25 5029
+329.5 4921
+329.75 4866
+330 4851
+330.25 4971
+330.5 4965
+330.75 4756
+331 4830
+331.25 4924
+331.5 4578
+331.75 4746
+332 4801
+332.25 4654
+332.5 4736
+332.75 4795
+333 4822
+333.25 4698
+333.5 4701
+333.75 4652
+334 4351
+334.25 4609
+334.5 4523
+334.75 4423
+335 4573
+335.25 4883
+335.5 4723
+335.75 4337
+336 4560
+336.25 4593
+336.5 4807
+336.75 4531
+337 4442
+337.25 4470
+337.5 4425
+337.75 4531
+338 4267
+338.25 4399
+338.5 4248
+338.75 4383
+339 4350
+339.25 4346
+339.5 4390
+339.75 4632
+340 4394
+340.25 4330
+340.5 4231
+340.75 4441
+341 4371
+341.25 4360
+341.5 4383
+341.75 4538
+342 4197
+342.25 4176
+342.5 4356
+342.75 4335
+343 4234
+343.25 4170
+343.5 4184
+343.75 4384
+344 4472
+344.25 4256
+344.5 4466
+344.75 4355
+345 4351
+345.25 4556
+345.5 4298
+345.75 4225
+346 4508
+346.25 4502
+346.5 4557
+346.75 4384
+347 4371
+347.25 4533
+347.5 4385
+347.75 4628
+348 4396
+348.25 4668
+348.5 4687
+348.75 4254
+349 4565
+349.25 4804
+349.5 4687
+349.75 4724
+350 4639
+350.25 4570
+350.5 4544
+350.75 4738
+351 4801
+351.25 4728
+351.5 4914
+351.75 4843
+352 4826
+352.25 4962
+352.5 5069
+352.75 4863
+353 4951
+353.25 5046
+353.5 5156
+353.75 5211
+354 5139
+354.25 4968
+354.5 5138
+354.75 5196
+355 5241
+355.25 5325
+355.5 5324
+355.75 5280
+356 5180
+356.25 5445
+356.5 5225
+356.75 5468
+357 5401
+357.25 5586
+357.5 5684
+357.75 5657
+358 5600
+358.25 5847
+358.5 5801
+358.75 5667
+359 5802
+359.25 5822
+359.5 5899
+359.75 6019
+360 5936
+360.25 5993
+360.5 6071
+360.75 6071
+361 6135
+361.25 6222
+361.5 6196
+361.75 6219
+362 6386
+362.25 6342
+362.5 6462
+362.75 6449
+363 6670
+363.25 6545
+363.5 6722
+363.75 6663
+364 6678
+364.25 6709
+364.5 6865
+364.75 6765
+365 6972
+365.25 6997
+365.5 6991
+365.75 7078
+366 7225
+366.25 7159
+366.5 7295
+366.75 7440
+367 7392
+367.25 7443
+367.5 7485
+367.75 7604
+368 7718
+368.25 7726
+368.5 7732
+368.75 7787
+369 8029
+369.25 7979
+369.5 8120
+369.75 8211
+370 8189
+370.25 8371
+370.5 8318
+370.75 8419
+371 8399
+371.25 8576
+371.5 8579
+371.75 8714
+372 8934
+372.25 8884
+372.5 8952
+372.75 8892
+373 9054
+373.25 9118
+373.5 9234
+373.75 9307
+374 9389
+374.25 9520
+374.5 9382
+374.75 9615
+375 9685
+375.25 9807
+375.5 9809
+375.75 10012
+376 9949
+376.25 10165
+376.5 10160
+376.75 10361
+377 10418
+377.25 10527
+377.5 10587
+377.75 10720
+378 10795
+378.25 10832
+378.5 10931
+378.75 11099
+379 11352
+379.25 11250
+379.5 11380
+379.75 11488
+380 11551
+380.25 11693
+380.5 11781
+380.75 12018
+381 12026
+381.25 12158
+381.5 12153
+381.75 12321
+382 12376
+382.25 12542
+382.5 12561
+382.75 12914
+383 12831
+383.25 13004
+383.5 13033
+383.75 13120
+384 13339
+384.25 13526
+384.5 13534
+384.75 13639
+385 13778
+385.25 13924
+385.5 14011
+385.75 14125
+386 14245
+386.25 14357
+386.5 14611
+386.75 14578
+387 14794
+387.25 14943
+387.5 15004
+387.75 15132
+388 15217
+388.25 15346
+388.5 15625
+388.75 15701
+389 15763
+389.25 15872
+389.5 16082
+389.75 16198
+390 16334
+390.25 16618
+390.5 16750
+390.75 16922
+391 16897
+391.25 17153
+391.5 17363
+391.75 17306
+392 17508
+392.25 17645
+392.5 17947
+392.75 18077
+393 18306
+393.25 18360
+393.5 18564
+393.75 18681
+394 18947
+394.25 19077
+394.5 19257
+394.75 19386
+395 19603
+395.25 19819
+395.5 19840
+395.75 20018
+396 20306
+396.25 20537
+396.5 20696
+396.75 20890
+397 21025
+397.25 21099
+397.5 21508
+397.75 21590
+398 21695
+398.25 22046
+398.5 22099
+398.75 22208
+399 22456
+399.25 22739
+399.5 22910
+399.75 23068
+400 23223
+400.25 23332
+400.5 23529
+400.75 23716
+401 23938
+401.25 24060
+401.5 24153
+401.75 24483
+402 24617
+402.25 24823
+402.5 24967
+402.75 25185
+403 25435
+403.25 25604
+403.5 25578
+403.75 25931
+404 26126
+404.25 26394
+404.5 26468
+404.75 26635
+405 26737
+405.25 27056
+405.5 27230
+405.75 27451
+406 27857
+406.25 27866
+406.5 28176
+406.75 28139
+407 28467
+407.25 28640
+407.5 28746
+407.75 29143
+408 29168
+408.25 29527
+408.5 29637
+408.75 29858
+409 30049
+409.25 30302
+409.5 30569
+409.75 30645
+410 30831
+410.25 30924
+410.5 31204
+410.75 31548
+411 31698
+411.25 31887
+411.5 32216
+411.75 32411
+412 32610
+412.25 32535
+412.5 32945
+412.75 32846
+413 33200
+413.25 33433
+413.5 33480
+413.75 33777
+414 34095
+414.25 34190
+414.5 34531
+414.75 34834
+415 34903
+415.25 35085
+415.5 35414
+415.75 35564
+416 35706
+416.25 35778
+416.5 36112
+416.75 36431
+417 36596
+417.25 36893
+417.5 37139
+417.75 37287
+418 37558
+418.25 37587
+418.5 37957
+418.75 38212
+419 38475
+419.25 38640
+419.5 38902
+419.75 39044
+420 39293
+420.25 39645
+420.5 39675
+420.75 39886
+421 40236
+421.25 40299
+421.5 40898
+421.75 40977
+422 41146
+422.25 41209
+422.5 41438
+422.75 41659
+423 42024
+423.25 41937
+423.5 42254
+423.75 42509
+424 42569
+424.25 42830
+424.5 43004
+424.75 43220
+425 43491
+425.25 43775
+425.5 43958
+425.75 44066
+426 44106
+426.25 44366
+426.5 44656
+426.75 44818
+427 44920
+427.25 45175
+427.5 45289
+427.75 45205
+428 45653
+428.25 45663
+428.5 46031
+428.75 45880
+429 46284
+429.25 46275
+429.5 46321
+429.75 46875
+430 46801
+430.25 47034
+430.5 47183
+430.75 47159
+431 47497
+431.25 47738
+431.5 47623
+431.75 47944
+432 48068
+432.25 48045
+432.5 48481
+432.75 48552
+433 48455
+433.25 48794
+433.5 48981
+433.75 48824
+434 49361
+434.25 49335
+434.5 49562
+434.75 49363
+435 49796
+435.25 49830
+435.5 50195
+435.75 50058
+436 50080
+436.25 50471
+436.5 50242
+436.75 50212
+437 50999
+437.25 50705
+437.5 50718
+437.75 51066
+438 51272
+438.25 51313
+438.5 51585
+438.75 51472
+439 51653
+439.25 51846
+439.5 51777
+439.75 51924
+440 52109
+440.25 52208
+440.5 52280
+440.75 52293
+441 52356
+441.25 52457
+441.5 52557
+441.75 52914
+442 53001
+442.25 52673
+442.5 52891
+442.75 52803
+443 53133
+443.25 52993
+443.5 53312
+443.75 53499
+444 53570
+444.25 53376
+444.5 53727
+444.75 53590
+445 53466
+445.25 53330
+445.5 53550
+445.75 53855
+446 53945
+446.25 54100
+446.5 53803
+446.75 54042
+447 53727
+447.25 54205
+447.5 54320
+447.75 54323
+448 54336
+448.25 54364
+448.5 54198
+448.75 54445
+449 54593
+449.25 54669
+449.5 54570
+449.75 54814
+450 54889
+450.25 55016
+450.5 54631
+450.75 55023
+451 54904
+451.25 55003
+451.5 54709
+451.75 54692
+452 54913
+452.25 54882
+452.5 54780
+452.75 54816
+453 54985
+453.25 54709
+453.5 54940
+453.75 54965
+454 54944
+454.25 54897
+454.5 54881
+454.75 54860
+455 54838
+455.25 54970
+455.5 54914
+455.75 54792
+456 54852
+456.25 54810
+456.5 54653
+456.75 54691
+457 54697
+457.25 54499
+457.5 54411
+457.75 54379
+458 54456
+458.25 54476
+458.5 54507
+458.75 54318
+459 54179
+459.25 54368
+459.5 53982
+459.75 53776
+460 53869
+460.25 53863
+460.5 53765
+460.75 53687
+461 53612
+461.25 53421
+461.5 53163
+461.75 53220
+462 53073
+462.25 52805
+462.5 52643
+462.75 52655
+463 52297
+463.25 52346
+463.5 52125
+463.75 52124
+464 51893
+464.25 51713
+464.5 51601
+464.75 51196
+465 51182
+465.25 50770
+465.5 50676
+465.75 50469
+466 50213
+466.25 50146
+466.5 49932
+466.75 49547
+467 49358
+467.25 49033
+467.5 48863
+467.75 48688
+468 48330
+468.25 48011
+468.5 47847
+468.75 47529
+469 47213
+469.25 47164
+469.5 46779
+469.75 46505
+470 46188
+470.25 45749
+470.5 45325
+470.75 45059
+471 44709
+471.25 44313
+471.5 44104
+471.75 43981
+472 43437
+472.25 43051
+472.5 42721
+472.75 42370
+473 41989
+473.25 41733
+473.5 41243
+473.75 40789
+474 40495
+474.25 39942
+474.5 39694
+474.75 39259
+475 38765
+475.25 38218
+475.5 37894
+475.75 37467
+476 36981
+476.25 36510
+476.5 36003
+476.75 35534
+477 35156
+477.25 34646
+477.5 34092
+477.75 33757
+478 33338
+478.25 32856
+478.5 32487
+478.75 31972
+479 31378
+479.25 30972
+479.5 30621
+479.75 30125
+480 29636
+480.25 29219
+480.5 28809
+480.75 28426
+481 27950
+481.25 27596
+481.5 27063
+481.75 26732
+482 26271
+482.25 25872
+482.5 25391
+482.75 24929
+483 24544
+483.25 24180
+483.5 23794
+483.75 23353
+484 22833
+484.25 22532
+484.5 22123
+484.75 21593
+485 21333
+485.25 20952
+485.5 20411
+485.75 20085
+486 19771
+486.25 19386
+486.5 18940
+486.75 18564
+487 18211
+487.25 17827
+487.5 17433
+487.75 17152
+488 16794
+488.25 16455
+488.5 16035
+488.75 15691
+489 15367
+489.25 14995
+489.5 14678
+489.75 14362
+490 14025
+490.25 13750
+490.5 13415
+490.75 13103
+491 12797
+491.25 12457
+491.5 12191
+491.75 11964
+492 11835
+492.25 11548
+492.5 11298
+492.75 11013
+493 10718
+493.25 10489
+493.5 10199
+493.75 9944
+494 9634
+494.25 9399
+494.5 9098
+494.75 8913
+495 8611
+495.25 8326
+495.5 8195
+495.75 7887
+496 7707
+496.25 7520
+496.5 7320
+496.75 7033
+497 6821
+497.25 6602
+497.5 6485
+497.75 6171
+498 6090
+498.25 5889
+498.5 5721
+498.75 5508
+499 5400
+499.25 5182
+499.5 5068
+499.75 4893
+500 4767
+500.25 4534
+500.5 4461
+500.75 4285
+501 4204
+501.25 4053
+501.5 3875
+501.75 3753
+502 3654
+502.25 3487
+502.5 3412
+502.75 3333
+503 3151
+503.25 3151
+503.5 3037
+503.75 2899
+504 2794
+504.25 2746
+504.5 2654
+504.75 2530
+505 2503
+505.25 2359
+505.5 2327
+505.75 2211
+506 2144
+506.25 2030
+506.5 2033
+506.75 2005
+507 1863
+507.25 1858
+507.5 1718
+507.75 1776
+508 1702
+508.25 1587
+508.5 1611
+508.75 1561
+509 1466
+509.25 1385
+509.5 1383
+509.75 1374
+510 1299
+510.25 1314
+510.5 1200
+510.75 1148
+511 1116
+511.25 1032
+511.5 1108
+511.75 995
+512 966
+512.25 941
+512.5 920
+512.75 908
+513 846
+513.25 848
+513.5 846
+513.75 737
+514 782
+514.25 724
+514.5 716
+514.75 704
+515 624
+515.25 616
+515.5 574
+515.75 602
+516 582
+516.25 547
+516.5 506
+516.75 525
+517 485
+517.25 488
+517.5 487
+517.75 431
+518 396
+518.25 411
+518.5 418
+518.75 365
+519 401
+519.25 361
+519.5 375
+519.75 346
+520 340
+520.25 326
+520.5 357
+520.75 292
+521 306
+521.25 270
+521.5 273
+521.75 251
+522 212
+522.25 253
+522.5 285
+522.75 233
+523 251
+523.25 247
+523.5 236
+523.75 235
+524 214
+524.25 188
+524.5 212
+524.75 201
+525 214
+525.25 169
+525.5 136
+525.75 182
+526 222
+526.25 147
+526.5 164
+526.75 133
+527 191
+527.25 176
+527.5 141
+527.75 156
+528 208
+528.25 179
+528.5 117
+528.75 116
+529 152
+529.25 121
+529.5 153
+529.75 178
+530 129
+530.25 102
+530.5 163
+530.75 118
+531 130
+531.25 82
+531.5 83
+531.75 99
+532 126
+532.25 153
+532.5 70
+532.75 109
+533 101
+533.25 72
+533.5 72
+533.75 114
+534 68
+534.25 71
+534.5 90
+534.75 177
+535 107
+535.25 107
+535.5 80
+535.75 92
+536 121
+536.25 37
+536.5 15
+536.75 54
+537 120
+537.25 104
+537.5 59
+537.75 40
+538 81
+538.25 126
+538.5 102
+538.75 80
+539 66
+539.25 65
+539.5 32
+539.75 83
+540 66
+540.25 64
+540.5 92
+540.75 84
+541 58
+541.25 72
+541.5 14
+541.75 78
+542 9
+542.25 71
+542.5 40
+542.75 118
+543 57
+543.25 100
+543.5 89
+543.75 64
+544 61
+544.25 86
+544.5 68
+544.75 76
+545 46
+545.25 85
+545.5 71
+545.75 61
+546 31
+546.25 68
+546.5 84
+546.75 68
+547 45
+547.25 94
+547.5 125
+547.75 33
+548 104
+548.25 70
+548.5 59
+548.75 33
+549 21
+549.25 1
+549.5 55
+549.75 41
+550 61
+550.25 75
+550.5 71
+550.75 81
+551 34
+551.25 63
+551.5 68
+551.75 56
+552 27
+552.25 61
+552.5 69
+552.75 45
+553 71
+553.25 90
+553.5 55
+553.75 105
+554 20
+554.25 47
+554.5 21
+554.75 10
+555 57
+555.25 77
+555.5 20
+555.75 56
+556 60
+556.25 105
+556.5 15
+556.75 8
+557 -8
+557.25 69
+557.5 18
+557.75 47
+558 6
+558.25 42
+558.5 27
+558.75 39
+559 12
+559.25 20
+559.5 41
+559.75 9
+560 52
+560.25 67
+560.5 39
+560.75 72
+561 40
+561.25 52
+561.5 73
+561.75 39
+562 -4
+562.25 72
+562.5 64
+562.75 52
+563 109
+563.25 12
+563.5 49
+563.75 -25
+564 9
+564.25 35
+564.5 59
+564.75 78
+565 15
+565.25 27
+565.5 52
+565.75 98
+566 10
+566.25 -3
+566.5 40
+566.75 -2
+567 16
+567.25 64
+567.5 82
+567.75 19
+568 28
+568.25 37
+568.5 6
+568.75 64
+569 35
+569.25 19
+569.5 18
+569.75 -33
+570 45
+570.25 -6
+570.5 19
+570.75 12
+571 9
+571.25 -6
+571.5 -1
+571.75 3
+572 47
+572.25 39
+572.5 16
+572.75 33
+573 10
+573.25 32
+573.5 18
+573.75 29
+574 68
+574.25 52
+574.5 9
+574.75 21
+575 34
+575.25 24
+575.5 7
+575.75 -63
+576 24
+576.25 32
+576.5 54
+576.75 19
+577 13
+577.25 11
+577.5 59
+577.75 31
+578 78
+578.25 -16
+578.5 39
+578.75 -12
+579 13
+579.25 21
+579.5 77
+579.75 25
+580 2
+580.25 -3
+580.5 -6
+580.75 0
+581 24
+581.25 -27
+581.5 29
+581.75 -11
+582 17
+582.25 -18
+582.5 -10
+582.75 51
+583 27
+583.25 -5
+583.5 17
+583.75 -66
+584 0
+584.25 19
+584.5 21
+584.75 20
+585 -21
+585.25 -8
+585.5 49
+585.75 -12
+586 4
+586.25 60
+586.5 29
+586.75 16
+587 54
+587.25 -10
+587.5 15
+587.75 -22
+588 -39
+588.25 15
+588.5 46
+588.75 29
+589 -31
+589.25 44
+589.5 -37
+589.75 12
+590 56
+590.25 51
+590.5 44
+590.75 22
+591 46
+591.25 -2
+591.5 59
+591.75 27
+592 77
+592.25 38
+592.5 74
+592.75 56
+593 -8
+593.25 0
+593.5 25
+593.75 54
+594 18
+594.25 110
+594.5 17
+594.75 -16
+595 10
+595.25 -71
+595.5 -25
+595.75 57
+596 5
+596.25 -29
+596.5 52
+596.75 37
+597 30
+597.25 24
+597.5 85
+597.75 28
+598 36
+598.25 2
+598.5 -48
+598.75 67
+599 -31
+599.25 8
+599.5 56
+599.75 71
+600 58
+600.25 40
+600.5 -8
+600.75 5
+601 17
+601.25 8
+601.5 73
+601.75 91
+602 42
+602.25 2
+602.5 64
+602.75 -16
+603 22
+603.25 55
+603.5 -33
+603.75 6
+604 -2
+604.25 -12
+604.5 71
+604.75 24
+605 53
+605.25 8
+605.5 28
+605.75 37
+606 29
+606.25 -16
+606.5 59
+606.75 11
+607 37
+607.25 8
+607.5 -6
+607.75 -12
+608 25
+608.25 69
+608.5 78
+608.75 64
+609 18
+609.25 7
+609.5 37
+609.75 81
+610 54
+610.25 2
+610.5 29
+610.75 2
+611 -1
+611.25 21
+611.5 48
+611.75 -5
+612 32
+612.25 2
+612.5 39
+612.75 12
+613 12
+613.25 -9
+613.5 50
+613.75 6
+614 0
+614.25 79
+614.5 19
+614.75 20
+615 85
+615.25 -10
+615.5 29
+615.75 36
+616 84
+616.25 31
+616.5 14
+616.75 4
+617 84
+617.25 -14
+617.5 46
+617.75 24
+618 -3
+618.25 -3
+618.5 0
+618.75 -23
+619 -20
+619.25 69
+619.5 30
+619.75 24
+620 -2
+620.25 89
+620.5 -31
+620.75 3
+621 62
+621.25 27
+621.5 29
+621.75 46
+622 54
+622.25 -19
+622.5 48
+622.75 4
+623 51
+623.25 -26
+623.5 69
+623.75 -97
+624 64
+624.25 -31
+624.5 78
+624.75 -17
+625 28
+625.25 -42
+625.5 77
+625.75 57
+626 15
+626.25 40
+626.5 -65
+626.75 -14
+627 77
+627.25 -7
+627.5 36
+627.75 2
+628 15
+628.25 -23
+628.5 13
+628.75 14
+629 47
+629.25 -70
+629.5 -54
+629.75 33
+630 28
+630.25 42
+630.5 -13
+630.75 -13
+631 29
+631.25 51
+631.5 59
+631.75 44
+632 -29
+632.25 51
+632.5 26
+632.75 71
+633 54
+633.25 60
+633.5 29
+633.75 90
+634 0
+634.25 11
+634.5 15
+634.75 13
+635 32
+635.25 75
+635.5 78
+635.75 -24
+636 13
+636.25 47
+636.5 -18
+636.75 -10
+637 0
+637.25 0
+637.5 29
+637.75 32
+638 -9
+638.25 -19
+638.5 5
+638.75 61
+639 36
+639.25 11
+639.5 27
+639.75 56
+640 4
+640.25 43
+640.5 15
+640.75 -59
+641 -19
+641.25 76
+641.5 32
+641.75 -21
+642 -35
+642.25 39
+642.5 20
+642.75 39
+643 -22
+643.25 -29
+643.5 -12
+643.75 17
+644 -3
+644.25 32
+644.5 54
+644.75 -25
+645 -26
+645.25 11
+645.5 91
+645.75 -3
+646 -24
+646.25 -56
+646.5 -49
+646.75 -47
+647 93
+647.25 36
+647.5 0
+647.75 86
+648 34
+648.25 34
+648.5 -23
+648.75 25
+649 -25
+649.25 -49
+649.5 -35
+649.75 78
+650 86
+650.25 -25
+650.5 -16
+650.75 77
+651 -16
+651.25 35
+651.5 3
+651.75 -19
+652 8
+652.25 19
+652.5 -30
+652.75 -23
+653 5
+653.25 23
+653.5 79
+653.75 6
+654 -46
+654.25 -15
+654.5 -17
+654.75 60
+655 78
+655.25 -25
+655.5 51
+655.75 -48
+656 53
+656.25 93
+656.5 54
+656.75 -45
+657 14
+657.25 98
+657.5 -2
+657.75 42
+658 -13
+658.25 52
+658.5 59
+658.75 74
+659 -3
+659.25 54
+659.5 60
+659.75 -27
+660 30
+660.25 25
+660.5 -6
+660.75 8
+661 24
+661.25 67
+661.5 5
+661.75 46
+662 24
+662.25 -33
+662.5 26
+662.75 106
+663 -18
+663.25 62
+663.5 37
+663.75 81
+664 37
+664.25 104
+664.5 17
+664.75 110
+665 -21
+665.25 74
+665.5 51
+665.75 35
+666 -78
+666.25 49
+666.5 43
+666.75 42
+667 55
+667.25 65
+667.5 48
+667.75 -49
+668 48
+668.25 86
+668.5 68
+668.75 2
+669 31
+669.25 -21
+669.5 16
+669.75 26
+670 87
+670.25 181
+670.5 87
+670.75 44
+671 107
+671.25 43
+671.5 88
+671.75 28
+672 13
+672.25 73
+672.5 7
+672.75 76
+673 44
+673.25 80
+673.5 14
+673.75 12
+674 32
+674.25 11
+674.5 5
+674.75 -23
+675 -18
+675.25 12
+675.5 -56
+675.75 -7
+676 47
+676.25 33
+676.5 0
+676.75 58
+677 158
+677.25 46
+677.5 64
+677.75 17
+678 30
+678.25 -80
+678.5 21
+678.75 -21
+679 -1
+679.25 5
+679.5 86
+679.75 36
+680 -20
+680.25 -34
+680.5 53
+680.75 6
+681 21
+681.25 41
+681.5 59
+681.75 39
+682 51
+682.25 8
+682.5 46
+682.75 43
+683 11
+683.25 11
+683.5 -19
+683.75 8
+684 15
+684.25 -16
+684.5 33
+684.75 32
+685 -36
+685.25 32
+685.5 11
+685.75 25
+686 49
+686.25 -53
+686.5 0
+686.75 -11
+687 -6
+687.25 -22
+687.5 8
+687.75 -18
+688 45
+688.25 -41
+688.5 17
+688.75 11
+689 32
+689.25 -40
+689.5 54
+689.75 34
+690 35
+690.25 50
+690.5 19
+690.75 -58
+691 -59
+691.25 70
+691.5 -55
+691.75 8
+692 21
+692.25 8
+692.5 40
+692.75 -27
+693 -41
+693.25 11
+693.5 21
+693.75 -24
+694 48
+694.25 13
+694.5 24
+694.75 -16
+695 -9
+695.25 0
+695.5 3
+695.75 16
+696 -3
+696.25 70
+696.5 31
+696.75 -48
+697 -6
+697.25 52
+697.5 12
+697.75 44
+698 50
+698.25 -7
+698.5 4
+698.75 -4
+699 8
+699.25 35
+699.5 -61
+699.75 -32
+700 103
diff --git a/Modules/Biophotonics/python/iMC/mc/data/colon_default.mci b/Modules/Biophotonics/python/iMC/mc/data/colon_default.mci
new file mode 100644
index 0000000000..9017b775cb
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/data/colon_default.mci
@@ -0,0 +1,14 @@
+1.0 # file version
+1 # number of runs
+
+temp.mco A # output filename, ASCII/Binary
+1000000 # No. of photons
+0.002 2 # dz, dr
+500 1 1 # No. of dz, dr & da.
+
+2 # No. of layers
+# n mua mus g d # One line for each layer
+1.0 # n for medium above.
+1.380 1.78741 20.00000 0.000 0.050
+1.380 1.78741 20.00000 0.000 0.050
+1.0 # n for medium below.
diff --git a/Modules/Biophotonics/python/iMC/mc/data/correct.mci b/Modules/Biophotonics/python/iMC/mc/data/correct.mci
new file mode 100644
index 0000000000..3548fe2f84
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/data/correct.mci
@@ -0,0 +1,15 @@
+1.0 # file version
+1 # number of runs
+
+temp.mco A # output filename, ASCII/Binary
+1000000 # No. of photons
+0.002 2 # dz, dr
+500 1 1 # No. of dz, dr & da.
+
+3 # No. of layers
+# n mua mus g d # One line for each layer
+1.0 # n for medium above.
+1.000 0.02100 0.03200 4.300 540.000
+1.000 0.01000 0.01000 1.000 100.000
+100.100 1.01100 1.02100 103.100 10410.000
+1.0 # n for medium below.
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/data/haemoglobin.txt b/Modules/Biophotonics/python/iMC/mc/data/haemoglobin.txt
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/data/haemoglobin.txt
rename to Modules/Biophotonics/python/iMC/mc/data/haemoglobin.txt
diff --git a/Modules/Biophotonics/python/iMC/mc/dfmanipulations.py b/Modules/Biophotonics/python/iMC/mc/dfmanipulations.py
new file mode 100644
index 0000000000..6bb2c76258
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/dfmanipulations.py
@@ -0,0 +1,45 @@
+'''
+Created on Oct 19, 2015
+
+@author: wirkert
+'''
+
+from scipy.interpolate import interp1d
+import pandas as pd
+
+
+def fold_by_sliding_average(df, window_size):
+ """take a batch and apply a sliding average with given window size to
+ the reflectances.
+ window_size is elements to the left and to the right.
+ There will be some boundary effect on the edges."""
+ # next line does the folding.
+ df.reflectances = pd.rolling_mean(df.reflectances.T, window_size,
+ center=True).T
+ # let's get rid of NaN columns which are created at the boundaries
+ df.dropna(axis="columns", inplace=True)
+ return df
+
+
+def switch_reflectances(df, new_wavelengths, new_reflectances):
+ df.drop(df["reflectances"].columns, axis=1, level=1, inplace=True)
+ for i, nw in enumerate(new_wavelengths):
+ df["reflectances", nw] = new_reflectances[:, i]
+ return df
+
+
+def interpolate_wavelengths(df, new_wavelengths):
+ """ interpolate image data to fit new_wavelengths. Current implementation
+ performs simple linear interpolation. Neither existing nor new _wavelengths
+ need to be sorted. """
+ # build an interpolator using the inormation provided by the dataframes
+ # reflectance column
+ interpolator = interp1d(df.reflectances.columns.astype(float),
+ df.reflectances.as_matrix(), assume_sorted=False,
+ bounds_error=False)
+ # use this to create new reflectances
+ new_reflectances = interpolator(new_wavelengths)
+ # build a new dataframe out of this information and set the original df
+ # to the new information. This seems hacky, can't it be done easier?
+ switch_reflectances(df, new_wavelengths, new_reflectances)
+ return df
diff --git a/Modules/Biophotonics/python/iMC/mc/factories.py b/Modules/Biophotonics/python/iMC/mc/factories.py
new file mode 100644
index 0000000000..dd6c317f9c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/factories.py
@@ -0,0 +1,115 @@
+'''
+Created on Oct 15, 2015
+
+@author: wirkert
+'''
+
+from mc.tissuemodels import AbstractTissue, GenericTissue, PhantomTissue
+from mc.batches import AbstractBatch
+from mc.batches import GenericBatch, LessGenericBatch, GenericMeanScatteringBatch
+from mc.batches import ColonMuscleBatch, ColonMuscleMeanScatteringBatch
+from mc.batches import VisualizationBatch, IntralipidPhantomBatch
+
+
+class AbstractMcFactory(object):
+ '''
+ Monte Carlo Factory.
+ Will create fitting models and batches, dependent on your task
+ '''
+
+ def create_tissue_model(self):
+ return AbstractTissue()
+
+ def create_batch_to_simulate(self):
+ return AbstractBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class GenericMcFactory(AbstractMcFactory):
+
+ def create_tissue_model(self):
+ return GenericTissue()
+
+ def create_batch_to_simulate(self):
+ return GenericBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class LessGenericMcFactory(GenericMcFactory):
+
+ def create_batch_to_simulate(self):
+ return LessGenericBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class ColonMuscleMcFactory(GenericMcFactory):
+
+ def create_batch_to_simulate(self):
+ return ColonMuscleBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class GenericMeanScatteringFactory(GenericMcFactory):
+
+ def create_batch_to_simulate(self):
+ return GenericMeanScatteringBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class ColonMuscleMeanScatteringFactory(GenericMcFactory):
+
+ def create_batch_to_simulate(self):
+ return ColonMuscleMeanScatteringBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class VisualizationMcFactory(AbstractMcFactory):
+
+ def create_tissue_model(self):
+ return GenericTissue()
+
+ def create_batch_to_simulate(self):
+ return VisualizationBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
+
+
+class PhantomFactory(AbstractMcFactory):
+
+ def create_tissue_model(self):
+ return PhantomTissue()
+
+ def create_batch_to_simulate(self):
+ return IntralipidPhantomBatch()
+
+ def __init__(self):
+ '''
+ Constructor
+ '''
diff --git a/Modules/Biophotonics/python/iMC/mc/plot.py b/Modules/Biophotonics/python/iMC/mc/plot.py
new file mode 100644
index 0000000000..2706a15c2b
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/plot.py
@@ -0,0 +1,43 @@
+'''
+Created on Oct 16, 2015
+
+@author: wirkert
+'''
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class PlotFunctor(object):
+ """helping functor necessary because we need to save color for plotting"""
+
+ def __init__(self, axes, wavelengths, nr_plot_elements):
+ self.axes = axes
+ self.sortedIndices = sorted(range(len(wavelengths)),
+ key=lambda k: wavelengths[k])
+ self.sortedWavelenghts = wavelengths[self.sortedIndices]
+ self.nr_plot_elements = nr_plot_elements
+ self.i = 0
+
+
+ def __call__(self, r):
+ pass
+ # set color so it slowly moves from blue to red
+ plt_color = (1. / float(self.nr_plot_elements) * self.i,
+ 0.,
+ 1. - (1. / float(self.nr_plot_elements) * self.i))
+ self.axes.plot(self.sortedWavelenghts, r[self.sortedIndices], "-o",
+ color=plt_color)
+ self.i += 1
+ return self.i
+
+def plot(batch, axes=None):
+ if axes is None:
+ axes = plt.gca()
+
+ f = PlotFunctor(axes, batch._wavelengths, batch.reflectances.shape[0])
+
+ np.apply_along_axis(f,
+ axis=1,
+ arr=batch.reflectances)
diff --git a/Modules/Biophotonics/python/iMC/mc/sim.py b/Modules/Biophotonics/python/iMC/mc/sim.py
new file mode 100644
index 0000000000..f629a25d99
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/sim.py
@@ -0,0 +1,211 @@
+'''
+Created on Sep 8, 2015
+
+This file contains methods which wrap the mcml simulation so it can be
+conveniently called from python. One example for a mcml simulation would be
+gpumcml:
+https://code.google.com/p/gpumcml/
+
+@author: wirkert
+'''
+
+import os
+import contextlib
+import logging
+
+import subprocess32
+
+""" helper method to change to the correct path and back again """
+@contextlib.contextmanager
+def cd(newPath):
+ savedPath = os.getcwd()
+ os.chdir(newPath)
+ yield
+ os.chdir(savedPath)
+
+
+class MciWrapper(object):
+ '''
+ this class provides a wrapper to the mcml monte carlo file.
+ Its purpose is to create a .mci file which the mcml simulation can use to
+ create the simulation
+ '''
+
+ def set_mci_filename(self, mci_filename):
+ self.mci_filename = mci_filename
+
+ def set_mco_filename(self, mco_filename):
+ """path of the mco file.
+ This can be either a path relative to the mcml executable
+ or an absolute path.
+ BUG: it seems that it can only be relative file name
+ """
+ self.mco_filename = mco_filename
+
+ def set_nr_photons(self, nr_photons):
+ self.nr_photons = nr_photons
+
+ def add_layer(self, n=None, ua=None, us=None, g=None, d=None):
+ """adds a layer below the currently existing ones.
+
+ Arguments:
+ n: Refraction index of medium
+ ua: absorption coefficient [1/m]
+ us: scattering coefficient [1/m]
+ g: anisotropy factor
+ d: thickness of layer [m]
+ """
+ if n is None:
+ n = 1.
+ if ua is None:
+ ua = 0.
+ if us is None:
+ us = 0.
+ if g is None:
+ g = 1.
+ if d is None:
+ d = 500.*10 ** -6
+ self.layers.append([n, ua, us, g, d])
+
+ def set_layer(self, layer_nr, n, ua, us, g, d):
+ """set a layer with a specific layer_nr (stariting with layer_nr 0).
+ Note that the layer must already exist, otherwise an error will occure
+ """
+ self.layers[layer_nr] = [n, ua, us, g, d]
+
+ def set_file_version(self, file_version):
+ self.file_version = file_version
+
+ def set_nr_runs(self, nr_runs):
+ self.nr_runs = nr_runs
+
+ def set_dz_dr(self, dz, dr):
+ self.dz = dz
+ self.dr = dr
+
+ def set_nr_dz_dr_da(self, nr_dz, nr_dr, nr_da):
+ self.nr_dz = nr_dz
+ self.nr_dr = nr_dr
+ self.nr_da = nr_da
+
+ def set_n_medium_above(self, n_above):
+ self.n_above = n_above
+
+ def set_n_medium_below(self, n_below):
+ self.n_below = n_below
+
+ def create_mci_file(self):
+ """this method creates the mci file at the location self.mci_filename"""
+ open(self.mci_filename, 'a').close()
+ f = open(self.mci_filename, 'w')
+ # write general information
+ f.write(str(self.file_version) + " # file version\n")
+ f.write(str(self.nr_runs) + " # number of runs\n\n")
+ # write the data for run
+ f.write(self.mco_filename + " A # output filename, ASCII/Binary\n")
+ f.write(str(self.nr_photons) + " # No. of photons\n")
+ f.write(repr(self.dz) + " " + repr(self.dr) + " # dz, dr\n")
+ f.write(repr(self.nr_dz) + " " +
+ repr(self.nr_dr) + " " +
+ repr(self.nr_da) + " # No. of dz, dr & da.\n\n")
+ # write layer information
+ f.write(str(len(self.layers)) + " # No. of layers\n")
+ f.write("# n mua mus g d # One line for each layer\n")
+ f.write(repr(self.n_above) + " # n for medium above.\n")
+ for layer in self.layers:
+
+ # factors (/100.; *100.) to convert to mcml expected units:
+ f.write("%.3f" % layer[0] + " " + # n
+ "%.5f" % (layer[1] / 100.) + " " + # ua
+ "%.5f" % (layer[2] / 100.) + " " + # us
+ "%.3f" % layer[3] + " " + # g
+ "%.3f" % (layer[4] * 100.) + "\n") # d
+ f.write(repr(self.n_below) + " # n for medium below.\n")
+ f.close()
+ if not os.path.isfile(self.mci_filename):
+ raise IOError("input file for monte carlo simulation not " +
+ "succesfully created")
+
+ def __init__(self):
+ # set standard parameters
+ self.file_version = 1.0
+ self.nr_photons = 10**6
+ self.nr_runs = 1
+ self.dz = 0.002
+ self.dr = 2
+ self.nr_dz = 500
+ self.nr_dr = 1
+ self.nr_da = 1
+ self.n_above = 1.0
+ self.n_below = 1.0
+ # initialize to 0 layers
+ self.layers = []
+
+
+class SimWrapper(object):
+
+ def set_mci_filename(self, mci_filename):
+ """the full path to the input file. E.g. ./data/my.mci
+ """
+ self.mci_filename = mci_filename
+
+ def set_mcml_executable(self, mcml_executable):
+ """ the full path of the excutable. E.g. ./mcml/mcml.exe"""
+ self.mcml_executable = mcml_executable
+
+ def run_simulation(self):
+ """this method runs a monte carlo simulation"""
+ mcml_path, mcml_file = os.path.split(self.mcml_executable)
+ abs_mci_filename = os.path.abspath(self.mci_filename)
+ # note: the -A option makes gpumcml much faster, but is not available
+ # in original mcml. Maybe a switch should be introduced here
+ args = ("./" + mcml_file, "-A", abs_mci_filename)
+ # switch to folder where mcml resides in and execute it.
+ with cd(mcml_path):
+ try:
+ popen = subprocess32.Popen(args, stdout=subprocess32.PIPE)
+ popen.wait(timeout=100)
+ except:
+ logging.error("couldn't run simulation")
+ # popen.kill()
+
+ def __init__(self):
+ pass
+
+
+def get_diffuse_reflectance(mco_filename):
+ """
+ extract reflectance from mco file.
+ Attention: mco_filename specifies full path.
+
+ Returns: the reflectance
+ """
+ with open(mco_filename) as myFile:
+ for line in myFile:
+ if "Diffuse reflectance" in line:
+ return float(line.split(' ', 1)[0])
+
+
+def get_specular_reflectance(mco_filename):
+ """
+ extract reflectance from mco file.
+ Attention: mco_filename specifies full path.
+
+ Returns: the reflectance
+ """
+ with open(mco_filename) as myFile:
+ for line in myFile:
+ if "Specular reflectance" in line:
+ return float(line.split(' ', 1)[0])
+
+
+def get_total_reflectance(mco_filename):
+ """
+ extract reflectance from mco file.
+ Attention: mco_filename specifies full path.
+
+ Returns: the reflectance
+ """
+ return get_diffuse_reflectance(mco_filename) + \
+ get_specular_reflectance(mco_filename)
+
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/generate/__init__.py b/Modules/Biophotonics/python/iMC/mc/test/__init__.py
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/generate/__init__.py
rename to Modules/Biophotonics/python/iMC/mc/test/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/mc/test/test_dfmanipulations.py b/Modules/Biophotonics/python/iMC/mc/test/test_dfmanipulations.py
new file mode 100644
index 0000000000..7e62886813
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/test/test_dfmanipulations.py
@@ -0,0 +1,78 @@
+'''
+Created on Oct 19, 2015
+
+@author: wirkert
+'''
+import unittest
+
+import numpy as np
+from pandas.util.testing import assert_frame_equal
+
+from mc.batches import ColonMuscleBatch
+import mc.dfmanipulations as dfmani
+
+class Test(unittest.TestCase):
+
+ def setUp(self):
+ # create a colon batch with 2 samples
+ self.test_batch = ColonMuscleBatch()
+ self.test_batch.create_parameters(2)
+
+ # artificially add 10 fake "reflectances" to this batch
+ # at 10 fake "wavelengths"
+ WAVELENGHTS = np.linspace(450, 720, 10)
+ reflectance1 = np.arange(0, 30, 3)
+ reflectance2 = np.arange(30, 60, 3)
+ for w in WAVELENGHTS:
+ self.test_batch.df["reflectances", w] = np.NAN
+ for r1, r2, w in zip(reflectance1, reflectance2, WAVELENGHTS):
+ self.test_batch.df["reflectances", w][0] = r1
+ self.test_batch.df["reflectances", w][1] = r2
+
+ # shortcut to dataframe that we are interested in:
+ self.df = self.test_batch.df
+
+ def test_sliding_average(self):
+ # by test design folding should not alter elements (only at boundaries,
+ # which are excluded by array slicing:
+ expected_elements = self.df.reflectances.iloc[:, 1:-1].copy()
+ dfmani.fold_by_sliding_average(self.df, 3)
+
+ assert_frame_equal(self.df.reflectances, expected_elements)
+
+ def test_interpolation(self):
+ new_wavelengths = [465, 615, 555]
+
+ dfmani.interpolate_wavelengths(self.df, new_wavelengths)
+
+ expected = np.array([[1.5, 16.5, 10.5], [31.5, 46.5, 40.5]])
+ np.testing.assert_almost_equal(self.df.reflectances.as_matrix(),
+ expected,
+ err_msg="test if interpolation " +
+ "works fine on batches")
+
+ def test_select_n(self):
+ """ this is less a test and more a showing of how to select n elements
+ from a dataframe."""
+ # draw one sample. Look into documentation for sample to see all the
+ # options. Sample is quite powerfull.
+ self.df = self.df.sample(1)
+ self.assertEqual(self.df.shape[0], 1,
+ "one sample selected")
+
+ def test_sortout_bands(self):
+ """ this is less a test and more a showing of how to sortout specific
+ bands from a dataframe """
+ # drop the 510 and 720 nm band
+ band_names_to_sortout = [510, 720]
+ self.df.drop(band_names_to_sortout, axis=1, level=1, inplace=True)
+
+ df_r = self.df["reflectances"]
+ self.assertTrue(not (510 in df_r.columns))
+ self.assertTrue(not 720 in df_r.columns)
+ self.assertTrue(690 in df_r.columns)
+
+
+if __name__ == "__main__":
+ # import sys;sys.argv = ['', 'Test.testName']
+ unittest.main()
diff --git a/Modules/Biophotonics/python/iMC/mc/test/test_sim.py b/Modules/Biophotonics/python/iMC/mc/test/test_sim.py
new file mode 100644
index 0000000000..313341c081
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/test/test_sim.py
@@ -0,0 +1,125 @@
+'''
+Created on Sep 8, 2015
+
+@author: wirkert
+'''
+import unittest
+import filecmp
+import os
+
+from mc.sim import MciWrapper, SimWrapper, \
+ get_total_reflectance, get_diffuse_reflectance
+
+
+path_to_gpumcml = "/home/wirkert/workspace/monteCarlo/gpumcml/" + \
+ "fast-gpumcml/gpumcml.sm_20"
+skip_gpu_tests = not os.path.exists(path_to_gpumcml)
+
+
+class Test(unittest.TestCase):
+
+ def setUp(self):
+ self.mci_filename = "temp.mci"
+ self.mco_filename = "temp.mco"
+ # create a mci_wrapper which shall create a mci file
+ self.mci_wrapper = MciWrapper()
+ self.mci_wrapper.set_mci_filename(self.mci_filename)
+ self.mci_wrapper.set_mco_filename(self.mco_filename)
+ self.mci_wrapper.set_nr_photons(10 ** 6)
+ self.mci_wrapper.add_layer(1.0, 2.1, 3.2, 4.3, 5.4)
+ self.mci_wrapper.add_layer(6.5, 7.8, 8.9, 9.10, 10.11)
+ self.mci_wrapper.add_layer(100.1001, 101.10001, 102.100001,
+ 103.1000001, 104.10000001)
+ self.mci_wrapper.set_layer(1, 1, 1, 1, 1, 1)
+ # expected mci file
+ self.correct_mci_filename = "./mc/data/correct.mci"
+ # path to the externaly installed mcml simulation. This is machine
+ # dependent. Thus tests depending on the execution of mcml will only
+ # be performed if this file exists.
+ # Should the file be located somewhere else on your computer,
+ # change this path to your actual location.
+
+ def tearDown(self):
+ os.remove(self.mci_filename)
+ mcml_path, mcml_file = os.path.split(path_to_gpumcml)
+ created_mco_file = mcml_path + "/" + self.mco_filename
+ if os.path.isfile(created_mco_file):
+ os.remove(created_mco_file)
+
+ def test_mci_wrapper(self):
+ self.mci_wrapper.create_mci_file()
+ self.assertTrue(os.path.isfile(self.mci_filename),
+ "mci file was created")
+ self.assertTrue(filecmp.cmp(self.mci_filename,
+ self.correct_mci_filename, shallow=False),
+ "the written mci file is the same as the stored " +
+ "reference file")
+
+ @unittest.skipIf(skip_gpu_tests, "skip if gpumcml not installed")
+ def test_sim_wrapper(self):
+ mcml_path, mcml_file = os.path.split(path_to_gpumcml)
+ if os.path.isfile(path_to_gpumcml):
+ self.mci_wrapper.create_mci_file()
+ sim_wrapper = SimWrapper()
+ sim_wrapper.set_mci_filename(self.mci_filename)
+ sim_wrapper.set_mcml_executable(path_to_gpumcml)
+ sim_wrapper.run_simulation()
+ self.assertTrue(os.path.isfile(os.path.join(mcml_path,
+ self.mco_filename)),
+ "mco file was created")
+
+ @unittest.skipIf(skip_gpu_tests, "skip if gpumcml not installed")
+ def test_mci_wrapper_book_example(self):
+ """see if our result matches the one from
+ Biomedical Optics
+ Principles and Imaging
+ page 55 (Table 3.1)"""
+ # create a book_p55_mci which shall create a mci file
+ book_p55_mci = MciWrapper()
+ book_p55_mci.set_mci_filename(self.mci_filename)
+ book_p55_mci.set_mco_filename(self.mco_filename)
+ book_p55_mci.set_nr_photons(10**6)
+ book_p55_mci.add_layer(1, 1000, 9000, 0.75, 0.0002)
+
+ mcml_path, mcml_file = os.path.split(path_to_gpumcml)
+ if os.path.isfile(path_to_gpumcml):
+ book_p55_mci.create_mci_file()
+ sim_wrapper = SimWrapper()
+ sim_wrapper.set_mci_filename(self.mci_filename)
+ sim_wrapper.set_mcml_executable(path_to_gpumcml)
+ sim_wrapper.run_simulation()
+ self.assertTrue(os.path.isfile(mcml_path + "/" + self.mco_filename),
+ "mco file was created")
+ refl = get_diffuse_reflectance(os.path.join(mcml_path,
+ self.mco_filename))
+ self.assertAlmostEqual(refl, 0.09734, 3,
+ "correct reflectance determined " +
+ "according to book table 3.1")
+
+ @unittest.skipIf(skip_gpu_tests, "skip if gpumcml not installed")
+ def test_mci_wrapper_book_example_2(self):
+ """see if our result matches the one from
+ Biomedical Optics
+ Principles and Imaging
+ page 56 (Table 3.2)"""
+ # create a book_p56_mci which shall create a mci file
+ book_p56_mci = MciWrapper()
+ book_p56_mci.set_mci_filename(self.mci_filename)
+ book_p56_mci.set_mco_filename(self.mco_filename)
+ book_p56_mci.set_nr_photons(10**6)
+ book_p56_mci.add_layer(1.5, 1000, 9000, 0., 1)
+
+ mcml_path, mcml_file = os.path.split(path_to_gpumcml)
+ if os.path.isfile(path_to_gpumcml):
+ book_p56_mci.create_mci_file()
+ sim_wrapper = SimWrapper()
+ sim_wrapper.set_mci_filename(self.mci_filename)
+ sim_wrapper.set_mcml_executable(path_to_gpumcml)
+ sim_wrapper.run_simulation()
+ self.assertTrue(os.path.isfile(mcml_path + "/" + self.mco_filename),
+ "mco file was created")
+ refl = get_total_reflectance(os.path.join(mcml_path,
+ self.mco_filename))
+ self.assertAlmostEqual(refl, 0.26, delta=0.01,
+ msg="correct reflectance determined " +
+ "according to book table 3.2")
diff --git a/Modules/Biophotonics/python/iMC/mc/test/test_tissuemodels.py b/Modules/Biophotonics/python/iMC/mc/test/test_tissuemodels.py
new file mode 100644
index 0000000000..bd708c2fe7
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/test/test_tissuemodels.py
@@ -0,0 +1,50 @@
+'''
+Created on Sep 9, 2015
+
+@author: wirkert
+'''
+
+import unittest
+import filecmp
+import os
+
+from mc.tissuemodels import GenericTissue
+
+this_dir, this_filename = os.path.split(__file__)
+DATA_PATH = os.path.join(this_dir, "..", "data")
+
+
+class TestTissueModels(unittest.TestCase):
+
+ def setUp(self):
+ self.mci_filename = "temp.mci"
+ self.mco_filename = "temp.mco"
+ # in this file we stored the expected result created from the
+ # "old" implementation of our algorithm:
+ self.correct_mci_filename = os.path.join(DATA_PATH, "colon_default.mci")
+
+ def tearDown(self):
+ os.remove(self.mci_filename)
+
+ def test_tissue_model(self):
+ # create nice colon model
+ tissue = GenericTissue(nr_layers=2)
+ tissue.set_mci_filename(self.mci_filename)
+ tissue.set_mco_filename(self.mco_filename)
+ tissue.wavelength = 500. * 10 ** -9
+ # just use the default parameters for this test
+ # now create the simulation file
+ tissue.create_mci_file()
+ # and assert its correct
+ self.assertTrue(os.path.isfile(self.mci_filename),
+ "mci file was created")
+ self.assertTrue(filecmp.cmp(self.mci_filename,
+ self.correct_mci_filename,
+ shallow=False),
+ "the written mci file is the same as the stored " +
+ "reference file")
+
+
+if __name__ == "__main__":
+ # import sys;sys.argv = ['', 'Test.testName']
+ unittest.main()
diff --git a/Modules/Biophotonics/python/iMC/mc/test/test_ua.py b/Modules/Biophotonics/python/iMC/mc/test/test_ua.py
new file mode 100644
index 0000000000..d29f2f5f4c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/test/test_ua.py
@@ -0,0 +1,40 @@
+'''
+Created on Sep 8, 2015
+
+@author: wirkert
+'''
+
+import unittest
+
+from mc.usuag import Ua
+
+class test_ua(unittest.TestCase):
+
+ def setUp(self):
+ self.ua_l2 = Ua()
+ self.ua532 = self.ua_l2(532.*10 ** -9) / 100.
+ self.ua800 = self.ua_l2(800.*10 ** -9) / 100.
+
+ def test_uA532(self):
+ self.assertTrue(3. < self.ua532 < 4., "test if calculated ua_l2 takes " +
+ "reasonable values " +
+ "(according to \"Determination of optical" +
+ " properties of normal and adenomatous human colon " +
+ "tissues in vitro using integrating sphere " +
+ "techniques\")")
+
+ def test_uA800(self):
+ self.assertTrue(0.05 < self.ua800 < 0.15, "test if calculated ua_l2 " +
+ "takes reasonable values " +
+ "(according to \"Differences in" +
+ " optical properties between healthy and " +
+ "pathological human colon tissues using a Ti:sapphire" +
+ " laser: an in vitro study using the Monte Carlo " +
+ "inversion technique\")")
+
+ def test_saO2_makes_difference(self):
+ self.ua_l2.saO2 = 1.0
+ self.assertNotAlmostEqual(self.ua532,
+ self.ua_l2(532.*10 ** -9) / 100.,
+ msg="changing oxygenation changes result")
+
diff --git a/Modules/Biophotonics/python/iMC/mc/test/test_usg.py b/Modules/Biophotonics/python/iMC/mc/test/test_usg.py
new file mode 100644
index 0000000000..2af36b493c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/test/test_usg.py
@@ -0,0 +1,26 @@
+'''
+Created on Oct 23, 2015
+
+@author: wirkert
+'''
+import unittest
+
+from mc.usuag import UsgJacques
+
+
+class TestUs(unittest.TestCase):
+
+ def setUp(self):
+ self.usg = UsgJacques()
+
+ def test_no_rayleigh_high_wavelengths(self):
+ self.usg.a_ray = 2.*100
+ self.usg.a_mie = 20.*100
+ w = 500. * 10 ** -9
+ print self.usg(w)[0] / 100.
+ # todo write test
+
+
+if __name__ == "__main__":
+ # import sys;sys.argv = ['', 'Test.testName']
+ unittest.main()
diff --git a/Modules/Biophotonics/python/iMC/mc/tissuemodels.py b/Modules/Biophotonics/python/iMC/mc/tissuemodels.py
new file mode 100644
index 0000000000..f6a31821c1
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/tissuemodels.py
@@ -0,0 +1,149 @@
+'''
+Created on Sep 9, 2015
+
+@author: wirkert
+'''
+
+import numpy as np
+
+from mc.sim import MciWrapper
+from mc.usuag import Ua, UsgJacques, UsgIntralipid
+
+
+class AbstractTissue(object):
+ '''
+ Initializes a abstract tissue model"
+ '''
+
+ def set_nr_photons(self, nr_photons):
+ self._mci_wrapper.set_nr_photons(nr_photons)
+
+ def set_mci_filename(self, mci_filename):
+ self._mci_wrapper.set_mci_filename(mci_filename)
+
+ def set_mco_filename(self, mco_filename):
+ self._mci_wrapper.set_mco_filename(mco_filename)
+
+ def get_mco_filename(self):
+ return self._mci_wrapper.mco_filename
+
+ def set_wavelength(self, wavelength):
+ self.wavelength = wavelength
+
+ def create_mci_file(self):
+ # set layers
+ for i, ua in enumerate(self.uas):
+ self._mci_wrapper.set_layer(i, # layer nr
+ self.ns[i], # refraction index
+ self.uas[i](self.wavelength), # ua
+ self.usgs[i](self.wavelength)[0], # us
+ self.usgs[i](self.wavelength)[1], # g
+ self.ds[i]) # d
+ # now that the layers have been updated: create file
+ self._mci_wrapper.create_mci_file()
+
+ def __str__(self):
+ """ Overwrite this method!
+ print the current model"""
+ model_string = ""
+ return model_string
+
+ def __init__(self, ns, uas, usgs, ds):
+ self._mci_wrapper = MciWrapper()
+
+ self.wavelength = 500.*10**9 # standard wavelength, should be set.
+ self.uas = uas
+ self.usgs = usgs
+ self.ds = ds
+ self.ns = ns
+ # initially create layers. these will be overwritten as soon
+ # as create_mci_file is called.
+ for i in enumerate(uas):
+ self._mci_wrapper.add_layer()
+
+
+class GenericTissue(AbstractTissue):
+ '''
+ Initializes a 3-layer generic tissue model
+ '''
+
+ def set_dataframe_row(self, df_row):
+ """take one example (one row) of a created batch and set the tissue to
+ resemble the structure specified by this row
+
+ Args:
+ df_row: one row of a dataframe created by a batch."""
+ layers = [l for l in df_row.index.levels[0] if "layer" in l]
+ for i, l in enumerate(layers):
+ self.set_layer(i,
+ df_row[l, "vhb"],
+ df_row[l, "sao2"],
+ df_row[l, "a_mie"],
+ df_row[l, "b_mie"],
+ df_row[l, "d"],
+ df_row[l, "n"],
+ df_row[l, "g"])
+
+ def set_layer(self, layer_nr=0,
+ bvf=None, saO2=None, a_mie=None, b_mie=None, d=None,
+ n=None, g=None):
+ """Helper function to set one layer."""
+ if bvf is None:
+ bvf = 0.02
+ if saO2 is None:
+ saO2 = 0.7
+ if a_mie is None:
+ a_mie = 10. * 100
+ if d is None:
+ d = 500. * 10 ** -6
+ if b_mie is None:
+ b_mie = 1.286
+ if n is None:
+ n = 1.38
+ if g is None:
+ g = 0.
+ # build obejct for absorption coefficient determination
+ self.uas[layer_nr].bvf = bvf
+ self.uas[layer_nr].saO2 = saO2
+ # and one for scattering coefficient
+ self.usgs[layer_nr].a_mie = a_mie
+ self.usgs[layer_nr].a_ray = 0.
+ self.usgs[layer_nr].b_mie = b_mie
+ self.usgs[layer_nr].g = g
+ self.ds[layer_nr] = d
+ self.ns[layer_nr] = n
+
+ def __str__(self):
+ """print the current model"""
+ model_string = ""
+ for i, ua in enumerate(self.uas):
+ layer_string = "layer " + str(i) + \
+ " - vhb: " + "%.1f" % (self.uas[i].bvf * 100.) + \
+ "%; sao2: " + "%.1f" % (self.uas[i].saO2 * 100.) + \
+ "%; a_mie: " + "%.2f" % (self.usgs[i].a_mie / 100.) + \
+ "cm^-1; a_ray: " + "%.2f" % (self.usgs[i].a_ray / 100.) + \
+ "cm^-1; b_mie: " + "%.3f" % self.usgs[i].b_mie + \
+ "; d: " + "%.0f" % (self.ds[i] * 10 ** 6) + "um" + \
+ "; n: " + "%.2f" % (self.ns[i]) + \
+ "; g: " + "%.2f" % self.usgs[i].g + "\n"
+ model_string += layer_string
+ return model_string
+
+ def __init__(self, nr_layers=3):
+ uas = []
+ usgs = []
+ for i in range(nr_layers):
+ uas.append(Ua())
+ usgs.append(UsgJacques())
+ ds = np.ones(nr_layers, dtype=float) * 500.*10 ** -6
+ ns = np.ones(nr_layers, dtype=float) * 1.38
+ super(GenericTissue, self).__init__(ns, uas, usgs, ds)
+
+
+class PhantomTissue(GenericTissue):
+
+ def __init__(self, nr_layers=1):
+ super(PhantomTissue, self).__init__(nr_layers=1)
+ self.usgs = [UsgIntralipid()]
+
+
diff --git a/Modules/Biophotonics/python/iMC/mc/usuag.py b/Modules/Biophotonics/python/iMC/mc/usuag.py
new file mode 100644
index 0000000000..d60d8173f6
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/mc/usuag.py
@@ -0,0 +1,217 @@
+'''
+Created on Sep 8, 2015
+
+@author: wirkert
+'''
+
+import math
+import os
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+
+this_dir, this_filename = os.path.split(__file__)
+DATA_PATH = os.path.join(this_dir, "data")
+
+def get_haemoglobin_extinction_coefficients(reference_filename=None):
+ """
+ helper method to get reference data for eHbO2 and eHb from Scott Prahls
+ reference file:
+ http://omlc.org/spectra/hemoglobin/summary.html
+ """
+ if reference_filename is None:
+ reference_filename = os.path.join(DATA_PATH, "haemoglobin.txt")
+ # table with wavelength at 1st row,
+ # HbO2 molar extinction coefficient [cm**-1/(moles/l)] at 2nd row,
+ # Hb molar extinction coefficient [cm**-1/(moles/l)] at 3rd row
+ haemoLUT = np.loadtxt(reference_filename, skiprows=2)
+ # we calculate everything in [m] instead of [nm] and [1/cm]
+ haemoLUT[:, 0] = haemoLUT[:, 0] * 10 ** -9
+ haemoLUT[:, 1:] = haemoLUT[:, 1:] * 10 ** 2
+ # get the data into an interpolation map for oxy and deoxy haemoglobin
+ eHbO2 = interp1d(haemoLUT[:, 0], haemoLUT[:, 1])
+ eHb = interp1d(haemoLUT[:, 0], haemoLUT[:, 2])
+ return eHbO2, eHb
+
+
+def get_beta_carotin_extinction_coefficients(reference_filename=None):
+ """
+ Reference data taken from
+ http://omlc.org/spectra/PhotochemCAD/data/041-abs.txt
+ """
+ if reference_filename is None:
+ reference_filename = os.path.join(DATA_PATH, "beta_carotin.txt")
+ # table with wavelength at 1st row,
+ # beta carotin molar extinction coefficient [cm**-1/(M)]
+ betaLUT = np.loadtxt(reference_filename, skiprows=2)
+ # we calculate everything in [m] instead of [nm] and [1/cm]
+ betaLUT[:, 0] = betaLUT[:, 0] * 10 ** -9
+ betaLUT[:, 1:] = betaLUT[:, 1:] * 10 ** 2
+ # get the data into an interpolation map
+ eBc = interp1d(betaLUT[:, 0], betaLUT[:, 1], bounds_error=False,
+ fill_value=0.)
+ return eBc
+
+
+def get_bilirubin_extinction_coefficients(reference_filename=None):
+ """
+ Reference data taken from
+ http://omlc.org/spectra/PhotochemCAD/data/041-abs.txt
+ """
+ if reference_filename is None:
+ reference_filename = os.path.join(DATA_PATH, "bilirubin.txt")
+ # table with wavelength at 1st row,
+ # beta carotin molar extinction coefficient [cm**-1/(M)]
+ biliLUT = np.loadtxt(reference_filename, skiprows=2)
+ # we calculate everything in [m] instead of [nm] and [1/cm]
+ biliLUT[:, 0] = biliLUT[:, 0] * 10 ** -9
+ biliLUT[:, 1:] = biliLUT[:, 1:] * 10 ** 2
+ # get the data into an interpolation map
+ eBili = interp1d(biliLUT[:, 0], biliLUT[:, 1], bounds_error=False,
+ fill_value=0.)
+ return eBili
+
+
+class Ua(object):
+
+ def __init__(self):
+ self.bvf = 0.02 # %
+ self.cHb = 120. # g*Hb/l
+ self.saO2 = 0. # %
+ self.eHbO2, self.eHb = \
+ get_haemoglobin_extinction_coefficients()
+
+ self.cBetaCarotinUgProDl = 0. # 2000.
+ # g / l
+ self.cBili = 0. # 1.23 * 10 ** -2
+ self.eBc = get_beta_carotin_extinction_coefficients()
+ self.eBili = get_bilirubin_extinction_coefficients()
+
+
+ def __call__(self, wavelength):
+ """ determine ua [1/m] as combination of
+ Haemoglobin extinction coefficients.
+ For more on this equation, please refer to
+ http://omlc.org/spectra/hemoglobin/
+ """
+ ua_haemoglobin = math.log(10) * self.cHb * \
+ (self.saO2 * self.eHbO2(wavelength) +
+ (1 - self.saO2) * self.eHb(wavelength)) \
+ / 64500. * self.bvf
+ ua_bilirubin = math.log(10) * self.cBili / 574.65 * \
+ self.eBili(wavelength)
+ # second line is to convert from ug/dl to g/ mole
+ ua_beta_carotin = math.log(10) * self.cBetaCarotinUgProDl / \
+ 536.8726 * 10 ** -5 * \
+ self.eBc(wavelength)
+
+ return ua_haemoglobin + ua_bilirubin + ua_beta_carotin
+
+
+class UaMuscle():
+ """helper class for setting ua in muscle layer.
+ for ua_sm in the muscle layer we don't use mie theory but the
+ approximation presented in
+ Rowe et al.
+ "Modelling and validation of spectral reflectance for the colon"
+ calculated to retrieve an absorption of 11.2 cm-1 at 515nm
+ """
+ def __init__(self):
+ self.ua = Ua()
+
+ def __call__(self, wavelength):
+ A = 1.7923385088285804
+ self.ua.bvf = 0.1 * A
+ self.ua.saO2 = 0.7
+ self.ua.cHb = 120.
+ return self.ua(wavelength)
+
+
+class UsgJacques(object):
+
+ def __init__(self):
+ """
+ To be set externally:
+
+ a':
+ """
+ self.a_ray = 0. * 100.
+ self.a_mie = 20. * 100.
+ self.b_mie = 1.286
+ self.g = 0.
+
+ def __call__(self, wavelength):
+ """
+ Calculate the scattering parameters relevant for monte carlo simulation.
+
+ Uses equation (2) from: Optical properties of biological tissues:
+ a Review
+
+ Args
+ ____
+ wavelength:
+ wavelength of the incident light [m]
+
+ Returns:
+ ____
+ (us, g)
+ scattering coefficient us [1/m] and anisotropy factor g
+ """
+ norm_wavelength = (wavelength / (500 * 10 ** -9))
+
+ us_ray = self.a_ray * norm_wavelength ** (-4)
+ us_mie = self.a_mie * norm_wavelength ** (-self.b_mie)
+
+ us_prime = (us_ray + us_mie) # * 100. to convert to m^-1
+ # actually we calculated the reduced scattering coefficent, so
+ # assume g is 0
+ us = us_prime / (1 - self.g)
+
+ return us, self.g
+
+
+class UsGMuscle(object):
+ """helper object for setting us in muscle layer.
+ for us in the muscle layer we don't use mie theory but the
+ approximation presented in
+ Rowe et al.
+ "Modelling and validation of spectral reflectance for the colon"
+ """
+
+ def __init__(self):
+ pass
+
+
+ def __call__(self, wavelength):
+ us = 168.52 * (wavelength * 10 ** 9) ** -0.332 / (1. - 0.96) * 100.
+ g = 0.96
+ return us, g
+
+
+class UsgIntralipid(object):
+ """helper object for setting us and g in intralipid
+ We use the formulas from
+ http://omlc.org/spectra/intralipid/ to calculate
+ """
+
+ def __init__(self):
+ self.a_ray = 0. * 100.
+ self.a_mie = 20. * 100.
+ self.b_mie = 2.33
+ self.g = 0.85
+
+ def __call__(self, wavelength):
+
+ norm_wavelength = (wavelength / (500 * 10 ** -9))
+
+ us_ray = self.a_ray * norm_wavelength ** (-4)
+ us_mie = self.a_mie * norm_wavelength ** (-self.b_mie)
+
+ us_prime = (us_ray + us_mie) # * 100. to convert to m^-1
+
+ g = 2.25 * (wavelength * 10**9)**-0.155
+
+ us = us_prime / (1 - g)
+
+ return us, g
diff --git a/Modules/Biophotonics/python/iMC/msi/__init__.py b/Modules/Biophotonics/python/iMC/msi/__init__.py
new file mode 100644
index 0000000000..0e9a801a5f
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/__init__.py
@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 14 15:54:35 2015
+
+@author: wirkert
+"""
+
diff --git a/Modules/Biophotonics/python/iMC/msi/data/Transmission_15-49-35-978_filter700nm.txt b/Modules/Biophotonics/python/iMC/msi/data/Transmission_15-49-35-978_filter700nm.txt
new file mode 100755
index 0000000000..5f619b446a
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/data/Transmission_15-49-35-978_filter700nm.txt
@@ -0,0 +1,2064 @@
+Data from Transmission_15-49-35-978.txt Node
+
+Date: Mon Jun 01 15:49:35 CEST 2015
+User: thomaskirchnerbackup
+Spectrometer: HR+C3363
+Autoset integration time: false
+Trigger mode: 0
+Integration Time (sec): 1.600000E-2
+Scans to average: 1
+Electric dark correction enabled: true
+Nonlinearity correction enabled: false
+Boxcar width: 0
+XAxis mode: Wavelengths
+Stop averaging: false
+Number of Pixels in Spectrum: 2048
+>>>>>Begin Spectral Data<<<<<
+187.255 70.50
+187.731 70.51
+188.206 70.51
+188.682 -0
+189.158 303.75
+189.634 135.85
+190.109 109.35
+190.585 9.89
+191.061 5400
+191.536 -476.47
+192.012 17100
+192.488 -54
+192.963 46.61
+193.439 -211.22
+193.914 114.18
+194.389 225
+194.865 137.65
+195.34 270
+195.816 -8100
+196.291 407.81
+196.766 -276.92
+197.242 51.43
+197.717 591.43
+198.192 -140.63
+198.667 135
+199.142 161.8
+199.618 -990
+200.093 139.75
+200.568 2.79
+201.043 -794.12
+201.518 101.61
+201.993 -50.4
+202.468 -3.35
+202.943 90
+203.418 -252.34
+203.893 -42.35
+204.368 112.5
+204.842 100.41
+205.317 331.58
+205.792 -203.77
+206.267 -900
+206.741 43.55
+207.216 -488.57
+207.691 69.74
+208.165 33.51
+208.64 276.92
+209.115 135
+209.589 33.51
+210.064 100.49
+210.538 -10800
+211.013 -0
+211.487 -144
+211.962 0
+212.436 185.05
+212.91 172.6
+213.385 14.33
+213.859 103.85
+214.333 96.43
+214.808 -582.35
+215.282 12600
+215.756 39.01
+216.23 -24.11
+216.704 -380.77
+217.178 40.15
+217.653 264.71
+218.127 11700
+218.601 -93.6
+219.075 81.82
+219.549 -14400
+220.023 308.22
+220.496 22.84
+220.97 -29.14
+221.444 -121.35
+221.918 -38.63
+222.392 28.72
+222.866 1800
+223.339 102.27
+223.813 106.21
+224.287 63.22
+224.76 -203.77
+225.234 -1042.11
+225.708 -38.79
+226.181 5.92
+226.655 94.41
+227.128 -138.46
+227.602 -43.9
+228.075 -26.21
+228.549 623.08
+229.022 56.25
+229.496 -25.23
+229.969 46.61
+230.442 119.58
+230.916 270
+231.389 26.87
+231.862 -787.5
+232.335 -0
+232.809 431.51
+233.282 -203.23
+233.755 14.06
+234.228 134.16
+234.701 -101.12
+235.174 76.34
+235.647 70.39
+236.12 43.71
+236.593 -32.37
+237.066 190.68
+237.539 210.28
+238.012 210.94
+238.485 14.34
+238.958 57.94
+239.43 308.57
+239.903 -55.1
+240.376 168.75
+240.849 321.43
+241.321 360
+241.794 -7.09
+242.267 -110.2
+242.739 30.58
+243.212 -31.03
+243.684 5.29
+244.157 -39.13
+244.629 9.57
+245.102 -1136.84
+245.574 -152.83
+246.047 -18.48
+246.519 0
+246.992 27.95
+247.464 -38.03
+247.936 8.74
+248.408 -371.74
+248.881 90
+249.353 2.51
+249.825 72.69
+250.297 157.98
+250.769 340.54
+251.242 -18.37
+251.714 -25.1
+252.186 163.64
+252.658 -668.57
+253.13 43.09
+253.602 -105.88
+254.074 29.89
+254.546 78.88
+255.017 22.31
+255.489 43.69
+255.961 27.36
+256.433 23.68
+256.905 -87.38
+257.377 29.03
+257.848 101.61
+258.32 -232.26
+258.792 -23.14
+259.263 225
+259.735 67.16
+260.206 -562.5
+260.678 450
+261.15 -16200
+261.621 104.13
+262.093 -100.93
+262.564 33.75
+263.035 119.74
+263.507 128.57
+263.978 43.71
+264.449 810
+264.921 72.97
+265.392 63
+265.863 474.55
+266.335 65.77
+266.806 26.03
+267.277 56.25
+267.748 -3600
+268.219 43.49
+268.69 64.29
+269.161 -411.43
+269.632 -41.12
+270.103 50.28
+270.574 43.9
+271.045 -373.58
+271.516 -15.08
+271.987 64.75
+272.458 60.27
+272.929 59.21
+273.4 -63.38
+273.87 741.18
+274.341 6.92
+274.812 -112.5
+275.282 12.16
+275.753 38.3
+276.224 124.14
+276.694 -578.57
+277.165 -33.96
+277.636 234.78
+278.106 3.86
+278.577 -48.65
+279.047 29.61
+279.517 -22.84
+279.988 -87.31
+280.458 11.16
+280.929 -10800
+281.399 -265.91
+281.869 -55.9
+282.34 246.58
+282.81 -37.76
+283.28 -388.64
+283.75 60.45
+284.22 -14.36
+284.691 -257.14
+285.161 102.27
+285.631 20.07
+286.101 168.75
+286.571 116.52
+287.041 67.92
+287.511 19.42
+287.981 -173.08
+288.451 84.37
+288.921 69.23
+289.39 -3.72
+289.86 0
+290.33 7.17
+290.8 21.6
+291.27 31500
+291.739 -102.27
+292.209 52.94
+292.679 20.22
+293.148 112.5
+293.618 49.54
+294.088 87.91
+294.557 55.45
+295.027 114.89
+295.496 900
+295.966 12.05
+296.435 -59.21
+296.904 331.58
+297.374 178.02
+297.843 -220.41
+298.313 -246.77
+298.782 450
+299.251 128.57
+299.72 11.25
+300.19 23.14
+300.659 44.55
+301.128 69.23
+301.597 -58.24
+302.066 -25.35
+302.535 19.78
+303.004 -60.67
+303.473 86.3
+303.942 293.48
+304.411 1125
+304.88 12.23
+305.349 -21.18
+305.818 121.62
+306.287 215.22
+306.756 -11.84
+307.225 60.34
+307.693 29.51
+308.162 37.89
+308.631 -37.76
+309.1 17.82
+309.568 68.82
+310.037 59.58
+310.506 81.38
+310.974 21.18
+311.443 105.08
+311.911 -8.85
+312.38 -115.2
+312.848 37.67
+313.317 63.38
+313.785 109.35
+314.254 21.11
+314.722 -43.2
+315.19 245.45
+315.659 -81.82
+316.127 258.9
+316.595 -16.77
+317.063 476.47
+317.532 -33.75
+318 63.53
+318.468 11.16
+318.936 101.61
+319.404 48.91
+319.872 0
+320.34 44.72
+320.808 -26.87
+321.276 71.05
+321.744 -92.52
+322.212 53.31
+322.68 16200
+323.148 -715.91
+323.616 214.68
+324.083 107.52
+324.551 3.14
+325.019 15.95
+325.487 -209.48
+325.954 11.18
+326.422 -18.6
+326.89 -101.61
+327.357 288
+327.825 120.47
+328.292 85.04
+328.76 -65.67
+329.228 -45.69
+329.695 -35.53
+330.162 -303.75
+330.63 0
+331.097 0
+331.565 41.54
+332.032 0
+332.499 -86.17
+332.967 52.43
+333.434 41.54
+333.901 246.77
+334.368 12.05
+334.835 83.01
+335.303 101.41
+335.77 -25.9
+336.237 296.34
+336.704 19.1
+337.171 -47.37
+337.638 -80.9
+338.105 27.41
+338.572 62.23
+339.039 -50.7
+339.506 64.73
+339.973 0
+340.439 -172.8
+340.906 -100.49
+341.373 -26.39
+341.84 34.24
+342.307 1440
+342.773 41.31
+343.24 6.54
+343.707 48.18
+344.173 -21.69
+344.64 -52.65
+345.106 12.23
+345.573 68.3
+346.039 -12.16
+346.506 33.4
+346.972 -20.66
+347.439 60.7
+347.905 13.35
+348.372 -1.5
+348.838 22.62
+349.304 58.7
+349.77 -16.32
+350.237 -14.32
+350.703 -42.57
+351.169 16.71
+351.635 10.62
+352.102 5.62
+352.568 -12.53
+353.034 7.15
+353.5 -6.18
+353.966 -37.23
+354.432 1.27
+354.898 17.31
+355.364 -65.77
+355.83 -25.55
+356.296 -26.71
+356.762 -7.26
+357.227 2.74
+357.693 9.59
+358.159 3.23
+358.625 -9.59
+359.09 -10.49
+359.556 7.01
+360.022 9.83
+360.488 9.76
+360.953 -9.1
+361.419 -7.91
+361.884 4.83
+362.35 4.13
+362.815 -0.86
+363.281 10.41
+363.746 -1.98
+364.212 -5.27
+364.677 0
+365.143 12.01
+365.608 0
+366.073 -9.66
+366.539 -1.3
+367.004 6.13
+367.469 13.65
+367.934 -8.58
+368.399 4.52
+368.865 0
+369.33 -4.49
+369.795 -10.07
+370.26 3.41
+370.725 -1.21
+371.19 6.18
+371.655 13.9
+372.12 8.63
+372.585 -7.93
+373.05 -1.84
+373.515 -3.98
+373.979 5.92
+374.444 2.8
+374.909 -7.58
+375.374 -0.98
+375.839 10.89
+376.303 4.17
+376.768 8.22
+377.233 0.44
+377.697 15.92
+378.162 -15.93
+378.626 -3.97
+379.091 -1.29
+379.556 -0.49
+380.02 -6.48
+380.485 -7.32
+380.949 0
+381.413 -2.81
+381.878 2.27
+382.342 -0.38
+382.806 4
+383.271 0.75
+383.735 5.76
+384.199 8
+384.663 5.29
+385.128 2.28
+385.592 2.08
+386.056 -5.6
+386.52 5.33
+386.984 6.92
+387.448 -4.68
+387.912 -8.79
+388.376 -0.71
+388.84 0.93
+389.304 2.74
+389.768 -3.72
+390.232 0.93
+390.696 2.48
+391.16 0
+391.623 -0.89
+392.087 4.05
+392.551 0.51
+393.015 2.94
+393.478 5.03
+393.942 7.63
+394.406 0.73
+394.869 0.47
+395.333 0.52
+395.796 2.78
+396.26 0.51
+396.723 -4.75
+397.187 0
+397.65 0.25
+398.114 2.78
+398.577 -1.45
+399.041 -6.15
+399.504 0
+399.967 1.95
+400.43 2.06
+400.894 -2.95
+401.357 -1.1
+401.82 -1.52
+402.283 2.15
+402.746 -0.86
+403.21 0.95
+403.673 0.42
+404.136 -3.42
+404.599 -1.46
+405.062 -0.79
+405.525 0.59
+405.988 3.17
+406.451 1.14
+406.913 -0.74
+407.376 -2.42
+407.839 3.43
+408.302 2.36
+408.765 1.76
+409.228 0.53
+409.69 -2.5
+410.153 -0.49
+410.616 1.49
+411.078 4.88
+411.541 1.27
+412.004 1.97
+412.466 -1.29
+412.929 -2.17
+413.391 -0.76
+413.854 -1.06
+414.316 0
+414.778 0.3
+415.241 -1.03
+415.703 -0.43
+416.166 0.29
+416.628 -3.02
+417.09 0.71
+417.552 -1.7
+418.015 -0.28
+418.477 -1.05
+418.939 1.9
+419.401 -0.13
+419.863 -1.23
+420.325 1.69
+420.787 0.39
+421.25 0.26
+421.712 -2.89
+422.174 -0.94
+422.635 1.26
+423.097 2.28
+423.559 -0.13
+424.021 2.43
+424.483 -1.65
+424.945 -2.66
+425.407 1.11
+425.868 1.76
+426.33 0.91
+426.792 1.99
+427.254 -1.2
+427.715 -0.59
+428.177 0.68
+428.638 2.35
+429.1 -1.49
+429.562 -0.67
+430.023 -1.57
+430.485 -0.85
+430.946 -0.87
+431.407 2.02
+431.869 -0.51
+432.33 0.61
+432.792 1.65
+433.253 -0.81
+433.714 -3.13
+434.175 0
+434.637 -1.85
+435.098 1.75
+435.559 1.45
+436.02 0
+436.481 -1.51
+436.942 -0.09
+437.404 0.26
+437.865 0.94
+438.326 -0.89
+438.787 -0.44
+439.248 0.51
+439.709 1.08
+440.169 0.57
+440.63 0.17
+441.091 -1.89
+441.552 0.97
+442.013 -1.9
+442.474 -2.27
+442.934 1.11
+443.395 0.81
+443.856 -0.38
+444.316 0.23
+444.777 0.55
+445.238 0.52
+445.698 0.29
+446.159 -0.53
+446.619 0.9
+447.08 2.23
+447.54 -1.09
+448.001 0.89
+448.461 0.51
+448.921 0.66
+449.382 -0.15
+449.842 0
+450.302 -2.32
+450.763 -1.75
+451.223 0.14
+451.683 0.15
+452.143 -0.58
+452.604 0.76
+453.064 -0.49
+453.524 -2.23
+453.984 0
+454.444 -0.07
+454.904 0.47
+455.364 -1.87
+455.824 0.59
+456.284 0.74
+456.744 -0.19
+457.204 -2.07
+457.664 0
+458.123 0.12
+458.583 -0.62
+459.043 -0.74
+459.503 0.18
+459.963 -0.42
+460.422 0.23
+460.882 1.68
+461.342 -0.62
+461.801 -0.45
+462.261 -1.45
+462.72 -0.44
+463.18 0.75
+463.639 -0.21
+464.099 -1.98
+464.558 -0.4
+465.018 -0.1
+465.477 -1.16
+465.936 -0.53
+466.396 0.38
+466.855 -0.38
+467.314 -0.09
+467.774 0
+468.233 -1.23
+468.692 -0.66
+469.151 -1.29
+469.61 -0.79
+470.07 -0.16
+470.529 -0.16
+470.988 0.47
+471.447 0.63
+471.906 0.31
+472.365 -0.44
+472.824 -0.44
+473.283 0
+473.742 0.14
+474.2 -0.03
+474.659 0.03
+475.118 0.07
+475.577 -0.33
+476.036 0.35
+476.494 0.16
+476.953 -0.18
+477.412 0.59
+477.87 -0.55
+478.329 -0.61
+478.788 0.64
+479.246 0.22
+479.705 -0.19
+480.163 -0.21
+480.622 -0.52
+481.08 -0.95
+481.539 -0.32
+481.997 0.19
+482.455 -0.15
+482.914 -0.24
+483.372 -0.36
+483.83 0.05
+484.289 -0.07
+484.747 -0.42
+485.205 -0.18
+485.663 0.02
+486.122 -0.17
+486.58 -0.1
+487.038 -0.25
+487.496 -0.14
+487.954 0.02
+488.412 0.02
+488.87 0.33
+489.328 0.19
+489.786 -0.1
+490.244 0.08
+490.702 -0.21
+491.159 -0.11
+491.617 0.11
+492.075 0.13
+492.533 0.34
+492.991 0.18
+493.448 0.23
+493.906 0.23
+494.364 0.31
+494.821 -0.12
+495.279 0.32
+495.737 0.13
+496.194 0.02
+496.652 0.21
+497.109 0.08
+497.567 -0.23
+498.024 -0.14
+498.481 -0.08
+498.939 0.11
+499.396 -0.06
+499.854 -0.14
+500.311 0.26
+500.768 0.27
+501.225 0.42
+501.683 0.29
+502.14 -0.3
+502.597 -0.22
+503.054 -0.04
+503.511 0.3
+503.968 -0.63
+504.425 -0.24
+504.882 0.19
+505.339 -0.26
+505.796 0.13
+506.253 0
+506.71 0.18
+507.167 0.08
+507.624 0.14
+508.081 0.05
+508.538 0.05
+508.995 -0.15
+509.451 0.04
+509.908 0.2
+510.365 -0.07
+510.821 -0.07
+511.278 -0.16
+511.735 0.03
+512.191 -0.29
+512.648 -0.17
+513.104 0.23
+513.561 0
+514.017 -0.24
+514.474 -0.01
+514.93 0.31
+515.387 0.02
+515.843 0.16
+516.299 -0.07
+516.756 0.12
+517.212 -0.02
+517.668 0.13
+518.125 0.08
+518.581 0.18
+519.037 0.09
+519.493 -0.1
+519.949 0.16
+520.405 0.13
+520.861 0.13
+521.317 0.16
+521.773 -0.02
+522.229 -0.11
+522.685 0.09
+523.141 0.48
+523.597 0.28
+524.053 0.14
+524.509 0.29
+524.965 -0.08
+525.421 -0.02
+525.876 -0.17
+526.332 0.01
+526.788 0.03
+527.244 -0.04
+527.699 -0.1
+528.155 0.05
+528.61 0.03
+529.066 0
+529.522 -0.07
+529.977 -0.14
+530.433 -0.05
+530.888 0.03
+531.344 0.08
+531.799 0.29
+532.254 -0.03
+532.71 -0.08
+533.165 -0.16
+533.62 -0.26
+534.076 -0.3
+534.531 0.03
+534.986 0.1
+535.441 -0.14
+535.897 -0.03
+536.352 0.1
+536.807 0.02
+537.262 0.27
+537.717 -0.1
+538.172 0
+538.627 0.07
+539.082 0.38
+539.537 -0.27
+539.992 -0.1
+540.447 0.04
+540.902 -0.08
+541.356 -0.16
+541.811 0.04
+542.266 0
+542.721 0.05
+543.176 -0.01
+543.63 0.09
+544.085 0.17
+544.54 -0.04
+544.994 -0.05
+545.449 0.08
+545.903 0.01
+546.358 -0.03
+546.812 -0.12
+547.267 -0.12
+547.721 -0.13
+548.176 -0.04
+548.63 0.08
+549.085 -0.07
+549.539 -0.11
+549.993 0.11
+550.448 -0.08
+550.902 -0.01
+551.356 -0.01
+551.81 -0.08
+552.264 -0.14
+552.719 0.13
+553.173 0.1
+553.627 -0.07
+554.081 0.03
+554.535 0.11
+554.989 -0.04
+555.443 0.04
+555.897 0.08
+556.351 0.12
+556.805 -0.06
+557.259 -0.23
+557.712 -0.03
+558.166 0.05
+558.62 0.15
+559.074 -0.31
+559.528 -0.14
+559.981 0.09
+560.435 0.09
+560.889 0.09
+561.342 -0.06
+561.796 0.25
+562.25 -0.1
+562.703 0.15
+563.157 -0.09
+563.61 0.01
+564.064 -0.16
+564.517 -0.14
+564.97 -0.19
+565.424 -0.04
+565.877 -0.2
+566.331 -0.01
+566.784 0.13
+567.237 0.04
+567.69 0.14
+568.144 0.17
+568.597 -0.04
+569.05 -0.07
+569.503 -0.04
+569.956 -0.11
+570.409 0
+570.862 0.06
+571.315 -0.04
+571.768 0.21
+572.221 0.07
+572.674 -0.07
+573.127 0.2
+573.58 -0.02
+574.033 0.08
+574.486 0
+574.939 0.07
+575.392 -0.08
+575.844 0.04
+576.297 0.05
+576.75 -0.15
+577.202 -0.05
+577.655 0.08
+578.108 -0.12
+578.56 -0.1
+579.013 -0.11
+579.465 0.23
+579.918 0.02
+580.37 0.21
+580.823 0.34
+581.275 0.18
+581.728 0.02
+582.18 -0.06
+582.632 0.14
+583.085 -0.13
+583.537 0.06
+583.989 0.02
+584.442 -0.05
+584.894 -0.02
+585.346 -0.03
+585.798 0.08
+586.25 0.05
+586.702 -0.05
+587.155 0.05
+587.607 0.02
+588.059 0.17
+588.511 0.01
+588.963 0.08
+589.415 -0.03
+589.866 0.05
+590.318 0.03
+590.77 0.02
+591.222 -0.02
+591.674 0.06
+592.126 0
+592.577 0.09
+593.029 -0.1
+593.481 0.04
+593.932 0
+594.384 -0.02
+594.836 -0.05
+595.287 0.02
+595.739 -0.11
+596.19 -0.02
+596.642 0.11
+597.093 0.15
+597.545 0.07
+597.996 -0.06
+598.448 0.02
+598.899 -0.04
+599.35 -0.07
+599.802 -0.01
+600.253 0.02
+600.704 -0.06
+601.155 -0.15
+601.607 -0.12
+602.058 -0.11
+602.509 -0.01
+602.96 -0.06
+603.411 0.11
+603.862 0.08
+604.313 0.2
+604.764 -0.06
+605.215 0.02
+605.666 -0.07
+606.117 -0.06
+606.568 0.11
+607.019 -0.13
+607.47 -0.02
+607.921 -0.12
+608.371 -0.23
+608.822 0.02
+609.273 0.06
+609.724 0.13
+610.174 0.08
+610.625 0.11
+611.076 0.06
+611.526 -0.06
+611.977 -0.06
+612.427 -0.02
+612.878 0.08
+613.328 0.01
+613.779 0.04
+614.229 0.05
+614.68 -0.07
+615.13 -0.06
+615.58 -0.15
+616.031 0.01
+616.481 0
+616.931 -0.15
+617.382 -0.12
+617.832 0.01
+618.282 0.17
+618.732 -0.02
+619.182 -0.07
+619.632 -0.28
+620.083 -0.04
+620.533 -0.14
+620.983 0.08
+621.433 0.05
+621.883 0.09
+622.333 0.05
+622.783 -0.11
+623.232 -0.11
+623.682 0.13
+624.132 0.09
+624.582 -0.01
+625.032 -0.08
+625.481 0.11
+625.931 -0.02
+626.381 0.02
+626.831 0
+627.28 0.08
+627.73 0.15
+628.179 -0.16
+628.629 0.02
+629.079 0.14
+629.528 0.08
+629.978 -0.13
+630.427 -0.15
+630.876 0.16
+631.326 0.04
+631.775 0.04
+632.225 0.09
+632.674 -0.07
+633.123 -0.12
+633.573 -0.03
+634.022 -0.05
+634.471 0.13
+634.92 0.17
+635.369 0.01
+635.818 0.01
+636.268 -0.14
+636.717 0.02
+637.166 0.11
+637.615 0.08
+638.064 -0.04
+638.513 -0.13
+638.962 -0.01
+639.411 0.14
+639.859 0.1
+640.308 -0.04
+640.757 0.15
+641.206 0.04
+641.655 -0.14
+642.103 0.01
+642.552 0.04
+643.001 0.07
+643.45 -0.04
+643.898 0.11
+644.347 0
+644.795 0.17
+645.244 0
+645.692 -0.03
+646.141 -0.03
+646.589 -0.07
+647.038 0.18
+647.486 0.03
+647.935 0.08
+648.383 0.11
+648.831 -0.06
+649.28 -0.03
+649.728 0.03
+650.176 -0.05
+650.625 -0.01
+651.073 0.07
+651.521 -0.04
+651.969 0.07
+652.417 0
+652.865 0.04
+653.313 -0.09
+653.761 -0.01
+654.209 0.11
+654.657 0.12
+655.105 0.16
+655.553 -0.13
+656.001 -0.06
+656.449 -0.04
+656.897 -0.06
+657.345 0.12
+657.793 0.06
+658.24 0.03
+658.688 -0.02
+659.136 0.05
+659.584 -0.09
+660.031 -0.05
+660.479 0.11
+660.926 0.17
+661.374 -0.04
+661.822 0.11
+662.269 0.03
+662.717 -0.09
+663.164 0.02
+663.611 0.12
+664.059 0.11
+664.506 0.08
+664.954 -0.03
+665.401 0.05
+665.848 -0.04
+666.296 0.02
+666.743 0.02
+667.19 0.13
+667.637 -0.07
+668.084 -0.06
+668.532 -0.11
+668.979 -0.1
+669.426 -0.03
+669.873 -0.02
+670.32 0.25
+670.767 -0.01
+671.214 -0.02
+671.661 0.22
+672.108 0.21
+672.555 0.14
+673.002 0.23
+673.448 0.15
+673.895 0.16
+674.342 0.04
+674.789 0.17
+675.235 0.12
+675.682 0.19
+676.129 0.03
+676.576 0.37
+677.022 0.15
+677.469 0.16
+677.915 -0.05
+678.362 0.24
+678.808 0.33
+679.255 0.2
+679.701 0.22
+680.148 0.21
+680.594 0.07
+681.041 0.21
+681.487 0.21
+681.933 0.36
+682.38 0.29
+682.826 0.5
+683.272 0.48
+683.718 0.49
+684.165 0.79
+684.611 1.09
+685.057 1.31
+685.503 1.83
+685.949 3.15
+686.395 4.55
+686.841 7.27
+687.287 11.74
+687.733 19.13
+688.179 29.95
+688.625 44.29
+689.071 56.79
+689.517 66.46
+689.963 72.42
+690.408 73.42
+690.854 75.79
+691.3 76.21
+691.746 77.76
+692.191 77.99
+692.637 79.37
+693.083 80.64
+693.528 83.42
+693.974 85.5
+694.419 85.33
+694.865 87.07
+695.311 86.82
+695.756 85.95
+696.201 85.16
+696.647 82.87
+697.092 82.21
+697.538 82.19
+697.983 82.97
+698.428 82.35
+698.874 82.57
+699.319 83.05
+699.764 83.78
+700.209 83.92
+700.655 84.64
+701.1 84.21
+701.545 84.33
+701.99 84.34
+702.435 85.04
+702.88 84.41
+703.325 86.05
+703.77 87.18
+704.215 88.7
+704.66 88.74
+705.105 88.61
+705.55 85.02
+705.995 79.77
+706.44 69.94
+706.884 58.82
+707.329 46.78
+707.774 35.81
+708.219 27.19
+708.663 19.34
+709.108 14.29
+709.553 10.15
+709.997 7.17
+710.442 5.26
+710.886 3.41
+711.331 2.8
+711.775 2.18
+712.22 1.45
+712.664 1.32
+713.109 0.94
+713.553 0.72
+713.998 0.73
+714.442 0.43
+714.886 0.27
+715.331 0.25
+715.775 0.54
+716.219 0.14
+716.663 0.47
+717.107 0.19
+717.552 0.09
+717.996 0.24
+718.44 0.14
+718.884 0.23
+719.328 0.27
+719.772 0.13
+720.216 0.17
+720.66 0.2
+721.104 0.08
+721.548 -0.05
+721.992 0.1
+722.436 0.08
+722.879 0.07
+723.323 0.4
+723.767 0.21
+724.211 0.08
+724.654 0.21
+725.098 0.06
+725.542 -0.13
+725.985 -0.12
+726.429 -0.12
+726.873 0.03
+727.316 0.06
+727.76 0.11
+728.203 0.08
+728.647 -0.01
+729.09 0.05
+729.534 0.09
+729.977 -0.01
+730.42 0.11
+730.864 0.11
+731.307 -0.07
+731.75 -0.11
+732.194 0.02
+732.637 0.01
+733.08 0.28
+733.523 0.24
+733.966 0
+734.41 -0.16
+734.853 0.03
+735.296 -0.11
+735.739 -0.07
+736.182 0.16
+736.625 0.21
+737.068 0.3
+737.511 -0.04
+737.954 -0.09
+738.396 0.19
+738.839 -0.24
+739.282 -0.08
+739.725 -0.15
+740.168 0.16
+740.61 -0.02
+741.053 -0.16
+741.496 0.01
+741.939 0.01
+742.381 0.01
+742.824 -0.13
+743.266 0.1
+743.709 0.27
+744.151 0.05
+744.594 -0.23
+745.036 -0.19
+745.479 0.08
+745.921 -0.12
+746.364 -0.12
+746.806 -0.17
+747.248 0.23
+747.691 0.32
+748.133 -0.11
+748.575 0.12
+749.017 0.06
+749.46 -0.01
+749.902 -0.21
+750.344 0.2
+750.786 -0.33
+751.228 -0.01
+751.67 0.01
+752.112 0.06
+752.554 0.18
+752.996 -0.05
+753.438 0.16
+753.88 -0.27
+754.322 -0.16
+754.764 0.19
+755.206 0.18
+755.648 0.06
+756.09 0.2
+756.531 -0.06
+756.973 0.31
+757.415 0.35
+757.856 -0.08
+758.298 0.32
+758.74 -0.02
+759.181 0.24
+759.623 0.04
+760.065 0.02
+760.506 -0.07
+760.948 -0.06
+761.389 -0.15
+761.83 0.12
+762.272 0.23
+762.713 0.32
+763.155 -0.19
+763.596 -0.45
+764.037 -0.04
+764.479 0.09
+764.92 0.01
+765.361 0.1
+765.802 0.22
+766.243 -0.03
+766.685 0.18
+767.126 -0.05
+767.567 0.53
+768.008 0.1
+768.449 0
+768.89 -0.1
+769.331 0.01
+769.772 -0.26
+770.213 0.14
+770.654 0
+771.095 -0.24
+771.535 0.05
+771.976 0.05
+772.417 0.03
+772.858 0.29
+773.299 -0.08
+773.739 0.01
+774.18 0.25
+774.621 0.39
+775.061 -0.04
+775.502 0.4
+775.942 0.41
+776.383 0.15
+776.824 0
+777.264 0.43
+777.705 0.43
+778.145 -0.07
+778.585 -0.08
+779.026 -0.27
+779.466 -0.03
+779.906 0.4
+780.347 0.03
+780.787 0.01
+781.227 -0.01
+781.668 -0.1
+782.108 0.46
+782.548 0.21
+782.988 0.59
+783.428 0
+783.868 -0.2
+784.308 -0.07
+784.748 -0.01
+785.188 0
+785.628 -0.22
+786.068 0.48
+786.508 0.28
+786.948 0.18
+787.388 -0.16
+787.828 -0.18
+788.268 -0.03
+788.708 0.23
+789.147 0.19
+789.587 0.38
+790.027 0.25
+790.467 0
+790.906 -0.18
+791.346 -0.03
+791.785 0.06
+792.225 -0.57
+792.665 0.2
+793.104 -0.11
+793.544 -0.2
+793.983 0.11
+794.422 0.3
+794.862 -0.11
+795.301 0.38
+795.741 -0.38
+796.18 0.06
+796.619 -0.11
+797.059 -0.1
+797.498 0.11
+797.937 0.08
+798.376 0
+798.815 0.43
+799.255 0.38
+799.694 0.08
+800.133 -0.05
+800.572 -0.49
+801.011 -0.2
+801.45 -0.03
+801.889 -0.03
+802.328 0.24
+802.767 -0.09
+803.206 0.55
+803.645 -0.31
+804.083 0.14
+804.522 0.3
+804.961 0.12
+805.4 -0.36
+805.839 0.14
+806.277 0.14
+806.716 -0.04
+807.155 0.16
+807.593 -0.3
+808.032 0.12
+808.471 -0.18
+808.909 0.29
+809.348 0.45
+809.786 0.09
+810.225 -0.23
+810.663 0.18
+811.101 0.23
+811.54 0.51
+811.978 0
+812.417 0.04
+812.855 0.2
+813.293 0.17
+813.731 -0.09
+814.17 -0.19
+814.608 0.06
+815.046 0.21
+815.484 -0.04
+815.922 -0.04
+816.36 0.1
+816.798 0.02
+817.236 0.35
+817.674 -0.09
+818.112 0
+818.55 0.2
+818.988 -0.08
+819.426 -0.36
+819.864 0
+820.302 0.18
+820.74 -0.22
+821.178 0.12
+821.615 0.1
+822.053 -0.1
+822.491 -0.18
+822.929 0.18
+823.366 0.25
+823.804 0.17
+824.241 0.39
+824.679 0.19
+825.117 0
+825.554 -0.1
+825.992 0.29
+826.429 -0.33
+826.867 0.23
+827.304 0
+827.741 0.34
+828.179 0.58
+828.616 0.11
+829.053 -0.11
+829.491 0.31
+829.928 0.29
+830.365 -0.22
+830.802 -0.13
+831.24 -0.57
+831.677 0.15
+832.114 -0.37
+832.551 0.02
+832.988 0.22
+833.425 0
+833.862 -0.45
+834.299 0.04
+834.736 -0.14
+835.173 -0.09
+835.61 -0.33
+836.047 -0.07
+836.484 0.19
+836.92 0.12
+837.357 -0.09
+837.794 0.35
+838.231 -0.31
+838.668 0.32
+839.104 -0.34
+839.541 0.2
+839.978 0.19
+840.414 -0.25
+840.851 0.1
+841.287 -0.17
+841.724 0.27
+842.16 -0.37
+842.597 -0.27
+843.033 0.3
+843.47 0.55
+843.906 -0.48
+844.342 -0.36
+844.779 -0.38
+845.215 0.66
+845.651 -0.55
+846.088 -0.36
+846.524 -0.03
+846.96 0.34
+847.396 -0.05
+847.832 -0.34
+848.269 0.24
+848.705 -0.71
+849.141 -0.21
+849.577 -0.03
+850.013 0.21
+850.449 -0.03
+850.885 0.08
+851.321 0.64
+851.757 0.68
+852.192 -0.3
+852.628 0.58
+853.064 0.36
+853.5 0.22
+853.936 -0.14
+854.372 0.25
+854.807 0.42
+855.243 0.23
+855.679 -0.06
+856.114 -0.38
+856.55 0.15
+856.985 0.29
+857.421 0.43
+857.857 0.48
+858.292 0.36
+858.728 0.72
+859.163 -0.12
+859.598 0.39
+860.034 0.59
+860.469 0.12
+860.905 -0.24
+861.34 0.9
+861.775 -0.12
+862.21 -0.55
+862.646 -0.24
+863.081 0.09
+863.516 0.62
+863.951 -0.84
+864.386 -0.25
+864.821 0.54
+865.257 0.06
+865.692 -0.03
+866.127 0.06
+866.562 -0.1
+866.997 0.46
+867.432 -0.36
+867.866 -0.3
+868.301 0.27
+868.736 0.48
+869.171 0.07
+869.606 0.03
+870.041 0.77
+870.475 -0.03
+870.91 -0.17
+871.345 0.44
+871.779 0.17
+872.214 -0.53
+872.649 0.14
+873.083 0.11
+873.518 0.04
+873.952 0.07
+874.387 -0.53
+874.821 -0.32
+875.256 -0.14
+875.69 -0.48
+876.125 -0.75
+876.559 0.11
+876.993 1.02
+877.428 -0.11
+877.862 0.22
+878.296 0.68
+878.731 -0.51
+879.165 0.43
+879.599 -1.17
+880.033 -0.11
+880.467 0.07
+880.901 0.56
+881.336 0.19
+881.77 0.8
+882.204 1.04
+882.638 -0.27
+883.072 -0.44
+883.506 0.08
+883.939 0.27
+884.373 0.2
+884.807 -0.12
+885.241 0.6
+885.675 0.28
+886.109 0.19
+886.542 0.87
+886.976 1.75
+887.41 -0.41
+887.844 0.72
+888.277 -0.61
+888.711 0.72
+889.144 0.04
+889.578 0.29
+890.012 0
+890.445 0.21
+890.879 -0.79
+891.312 0.21
+891.745 0.39
+892.179 0.34
+892.612 -0.92
+893.046 0.26
+893.479 0.9
+893.912 -0.49
+894.345 -0.31
+894.779 -0.39
+895.212 0.17
+895.645 0.84
+896.078 -0.18
+896.511 0
+896.945 0
+897.378 -0.09
+897.811 -0.91
+898.244 0.49
+898.677 0.19
+899.11 -0.8
+899.543 -0.09
+899.976 0.65
+900.409 -0.29
+900.841 -0.67
+901.274 -0.24
+901.707 1.15
+902.14 -0.5
+902.573 0.34
+903.005 0.5
+903.438 0.86
+903.871 -0.5
+904.303 -0.1
+904.736 -0.36
+905.169 0.71
+905.601 -0.62
+906.034 0.52
+906.466 -0.11
+906.899 0.89
+907.331 -0.46
+907.764 1.2
+908.196 0.05
+908.629 1.16
+909.061 0.16
+909.493 1.59
+909.926 1.5
+910.358 1.49
+910.79 -0.11
+911.222 2.14
+911.655 0.61
+912.087 -0.18
+912.519 -0.17
+912.951 0.53
+913.383 0.35
+913.815 -0.53
+914.247 -0.24
+914.679 2
+915.111 0.9
+915.543 -1.49
+915.975 -1.89
+916.407 0.55
+916.839 1
+917.271 -0.81
+917.703 -0.7
+918.134 0.19
+918.566 -0.82
+918.998 -0.58
+919.43 0.45
+919.861 0.06
+920.293 -0.13
+920.725 -0.39
+921.156 -0.26
+921.588 0.2
+922.019 0.07
+922.451 0.2
+922.882 0.49
+923.314 0
+923.745 -0.49
+924.177 0.42
+924.608 0.14
+925.039 0.63
+925.471 -3.04
+925.902 0.79
+926.333 -0.29
+926.765 0.52
+927.196 1.22
+927.627 0.36
+928.058 1.38
+928.489 1.27
+928.921 2.33
+929.352 -2.11
+929.783 -1.35
+930.214 -2.41
+930.645 0
+931.076 -0.77
+931.507 1.16
+931.938 1.15
+932.369 0.23
+932.8 -0.39
+933.23 0.16
+933.661 0.88
+934.092 1.68
+934.523 0.16
+934.954 0.41
+935.384 1.2
+935.815 -0.33
+936.246 0.81
+936.676 1.8
+937.107 -1.17
+937.538 -1.4
+937.968 1.54
+938.399 1.7
+938.829 -2.14
+939.26 -0.78
+939.69 -0.53
+940.121 -1.11
+940.551 -2.13
+940.981 0.61
+941.412 -1.23
+941.842 -0.44
+942.272 -0.45
+942.703 -2.33
+943.133 0.18
+943.563 -1.75
+943.993 -2.54
+944.423 0.27
+944.854 -0.85
+945.284 -1.04
+945.714 -0.47
+946.144 0.55
+946.574 0.58
+947.004 0.57
+947.434 1.08
+947.864 1.43
+948.294 0.6
+948.724 -0.42
+949.153 1.04
+949.583 0.82
+950.013 0.11
+950.443 0.11
+950.873 0.92
+951.302 1.37
+951.732 0.43
+952.162 -0.94
+952.591 -1.46
+953.021 2.59
+953.451 -2.59
+953.88 -1.14
+954.31 -0.23
+954.739 -0.12
+955.169 -2.41
+955.598 -1.05
+956.028 0.81
+956.457 -1.19
+956.886 -1.07
+957.316 2.25
+957.745 1.26
+958.174 0.63
+958.604 1.33
+959.033 -1.53
+959.462 -1.52
+959.891 -3.42
+960.321 0
+960.75 2.76
+961.179 3.52
+961.608 -2.31
+962.037 -2.28
+962.466 0.57
+962.895 0.14
+963.324 -0.96
+963.753 1.14
+964.182 0
+964.611 -0.43
+965.04 -4.87
+965.469 2.85
+965.897 -0.29
+966.326 -0.46
+966.755 -0.46
+967.184 2.18
+967.612 1.86
+968.041 -3.15
+968.47 -5.56
+968.898 1.3
+969.327 1.63
+969.756 3.69
+970.184 -0.5
+970.613 -0.16
+971.041 -3.54
+971.47 0.7
+971.898 -0.52
+972.327 1.9
+972.755 0.69
+973.183 -1.22
+973.612 -3.38
+974.04 3.44
+974.468 -2.12
+974.897 -1.66
+975.325 3.9
+975.753 1.33
+976.181 3.11
+976.609 0
+977.037 -2.63
+977.466 -0.81
+977.894 0.81
+978.322 -1.76
+978.75 0.19
+979.178 -0.98
+979.606 -1.1
+980.034 -3.35
+980.462 -1.11
+980.889 6.78
+981.317 -3.81
+981.745 -6.38
+982.173 -0.44
+982.601 1.75
+983.028 3.07
+983.456 3.13
+983.884 -2.93
+984.312 5.23
+984.739 0.25
+985.167 -0.24
+985.594 3.59
+986.022 3.31
+986.45 -7.18
+986.877 0.76
+987.305 0.26
+987.732 -6.62
+988.159 -5.36
+988.587 3.67
+989.014 1.57
+989.442 -2.17
+989.869 -6.23
+990.296 -2.88
+990.724 0.96
+991.151 -1.39
+991.578 -2.61
+992.005 0
+992.432 3.35
+992.859 -9.57
+993.287 4.06
+993.714 -0.94
+994.141 9.31
+994.568 -5.5
+994.995 4.01
+995.422 6.11
+995.849 10.28
+996.276 -0.35
+996.703 4.97
+997.129 2.86
+997.556 5.1
+997.983 0.34
+998.41 4.91
+998.837 4.97
+999.263 -1.38
+999.69 -3.33
+1000.117 -6.12
+1000.543 3.92
+1000.97 -9.06
+1001.397 -1.9
+1001.823 1.28
+1002.25 -2.51
+1002.676 -6.06
+1003.103 -1.61
+1003.529 -6.3
+1003.956 -1.49
+1004.382 0
+1004.809 0.36
+1005.235 3.54
+1005.661 6.18
+1006.088 -5.62
+1006.514 -1.94
+1006.94 -11.56
+1007.366 -3.57
+1007.793 -0.37
+1008.219 -7.33
+1008.645 -5.68
+1009.071 0.42
+1009.497 -11.95
+1009.923 4.68
+1010.349 2.5
+1010.775 4.38
+1011.201 -0.37
+1011.627 0.83
+1012.053 1.3
+1012.479 -6.09
+1012.905 -8.7
+1013.331 4.39
+1013.757 -2.78
+1014.182 -4.7
+1014.608 -5.59
+1015.034 2.86
+1015.46 7.87
+1015.885 2.81
+1016.311 14.54
+1016.737 2.86
+1017.162 1.02
+1017.588 -6.08
+1018.013 -10.6
+1018.439 5.79
+1018.865 3.54
+1019.29 -6.29
+1019.715 -6.88
+1020.141 1.56
+1020.566 -0.58
+1020.992 0.55
+1021.417 2.12
+1021.842 14.08
+1022.268 8.29
+1022.693 0.55
+1023.118 -13.02
+1023.543 4.47
+1023.969 -0.69
+1024.394 0
+1024.819 3.49
+1025.244 -3.87
+1025.669 -20.01
+1026.094 -7.1
+1026.519 7.23
+1026.944 3.64
+1027.369 9.1
+1027.794 7.98
+1028.219 11.93
+1028.644 15.23
+1029.069 -9.57
+1029.494 2.11
+1029.918 9.82
+1030.343 2.82
+1030.768 3.45
+1031.193 -7.7
+1031.617 13.55
+1032.042 -12.28
+1032.467 -13.25
+1032.891 9.24
+1033.316 0.84
+1033.741 -7.04
+1034.165 20.32
+1034.59 31.57
+1035.014 3.97
+1035.439 -6.09
+1035.863 12.65
+1036.288 3.28
+1036.712 2.02
+1037.136 3
+1037.561 -2.94
+1037.985 -6.86
+1038.409 9.1
+1038.834 3.37
+1039.258 12.76
+1039.682 12.08
+1040.106 32.3
+1040.53 -1.87
+1040.954 -24.08
+1041.379 3.85
+1041.803 -1.93
+1042.227 -20.24
+1042.651 15.72
+1043.075 17.92
+1043.499 -5.06
+1043.923 -10.36
+1044.346 -12.13
+1044.77 24.82
+1045.194 -21.95
+1045.618 3.58
+1046.042 16.51
+1046.466 -6.67
+1046.889 20.48
+1047.313 -6.99
+1047.737 15.57
+1048.16 12.78
+1048.584 -26.61
+1049.008 13.94
+1049.431 -13.27
+1049.855 4.12
+1050.278 10.99
+1050.702 20.35
+1051.125 21.65
+1051.549 -1.59
+1051.972 8.34
+1052.396 8.35
+1052.819 2.71
+1053.242 5.37
+1053.666 -20.87
+1054.089 13.2
+1054.512 8.08
+1054.936 -42.45
+1055.359 -22.08
+1055.782 -20.04
+1056.205 6.86
+1056.628 -56.12
+1057.051 -5.14
+1057.475 -5.18
+1057.898 -29.62
+1058.321 -37.82
+1058.744 -18.49
+1059.167 -1.39
+1059.59 -22.43
+1060.012 12.52
+1060.435 -2
+1060.858 17.13
+1061.281 -54.48
+1061.704 -23.87
+1062.127 -2.33
+1062.549 -8.36
+1062.972 8.35
+1063.395 -8.79
+1063.818 0
+1064.24 7.29
+1064.663 -12.27
+1065.086 -17.55
+1065.508 20.67
+1065.931 28.65
+1066.353 -75.74
+1066.776 -62.38
+1067.198 29.03
+1067.621 10.9
+1068.043 -6.16
+1068.465 -7.71
+1068.888 66.86
+1069.31 26.9
+1069.732 12.16
+1070.155 3.14
+1070.577 31.19
+1070.999 -55.31
+1071.421 27.58
+1071.844 0
+1072.266 50.94
+1072.688 -51.92
+1073.11 -12.3
+1073.532 12.16
+1073.954 -56.25
+1074.376 -34.18
+1074.798 27.11
+1075.22 66.89
+1075.642 43.03
+1076.064 -56.57
+1076.486 -16.73
+1076.908 10.76
+1077.33 40.22
+1077.751 342
+1078.173 50.2
+1078.595 40.15
+1079.017 -112.5
+1079.438 -3.35
+1079.86 14.62
+1080.282 42.49
+1080.703 -85.34
+1081.125 -35.5
+1081.546 79.79
+1081.968 -6.92
+1082.39 -192.86
+1082.811 7.16
+1083.232 -13.38
+1083.654 -86.17
+1084.075 -115.2
+1084.497 39.13
+1084.918 51.51
+1085.339 116.38
+1085.761 38.85
+1086.182 -132.17
+1086.603 37.67
+1087.024 -67.16
+1087.446 -194.78
+1087.867 105.88
+1088.288 60.45
+1088.709 -93.1
+1089.13 40.91
+1089.551 5.59
+1089.972 165.79
+1090.393 194.59
+1090.814 9.64
+1091.235 -135.85
+1091.656 120.9
+1092.077 229.09
+1092.498 22.66
+1092.919 89.74
+1093.34 -90
+1093.76 -8.74
+1094.181 -50.94
+1094.602 113.59
+1095.023 151.4
+1095.443 -110.2
+1095.864 267.57
+1096.285 165.31
+1096.705 -109.35
+1097.126 -100.8
+1097.546 52.43
+1097.967 104.85
+1098.387 -152.11
+1098.808 229.09
+1099.228 169.41
+1099.649 68.13
+1100.069 8.6
+1100.49 -36
+1100.91 18.27
+1101.33 201.72
+1101.751 60.34
+1102.171 33.54
+1102.591 13.71
+1103.011 -67.29
+1103.431 3.72
+1103.852 68.13
diff --git a/Modules/Biophotonics/python/iMC/msi/data/testMsi.nrrd b/Modules/Biophotonics/python/iMC/msi/data/testMsi.nrrd
new file mode 100644
index 0000000000..82708c6160
Binary files /dev/null and b/Modules/Biophotonics/python/iMC/msi/data/testMsi.nrrd differ
diff --git a/Modules/Biophotonics/python/iMC/msi/imgmani.py b/Modules/Biophotonics/python/iMC/msi/imgmani.py
new file mode 100644
index 0000000000..ceb06a581b
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/imgmani.py
@@ -0,0 +1,66 @@
+'''
+Created on Aug 28, 2015
+
+@author: wirkert
+'''
+
+import numpy as np
+
+
+def collapse_image(img):
+ """ helper method which transorms the n x m x nrWavelengths image to a
+ (n*m) x nrWavelength image.
+
+ note that this function doesn't take an object of class Msi but
+ msi.get_image() """
+ return img.reshape(-1, img.shape[-1])
+
+
+def remove_masked_elements(img):
+ """ helper method which removes masked pixels.
+ Note that by applying this method, the img loses it's shape."""
+ collapsed_image = collapse_image(img)
+ # if one reflectance is masked msis are defined to have all refl.
+ # masked. Thus we can just have a look at the first column
+ one_column = collapsed_image[:, 0]
+ if (isinstance(one_column, np.ma.masked_array)):
+ masked_elems = np.where(one_column.mask)
+ collapsed_image = np.delete(collapsed_image, masked_elems, 0)
+ return collapsed_image
+
+
+def select_n_reflectances(img, n):
+ """ randomly select n reflectances from image.
+ The output is of shape n x nr_wavelengths """
+ collapsed_image = collapse_image(img)
+ perms = np.random.permutation(collapsed_image.shape[0])
+ first_n_perms = perms[0:n]
+ return collapsed_image[first_n_perms, :]
+
+
+def get_bands(img, bands):
+ """get the bands bands (np.array) from the multispectral image.
+ Example: image is 2048x2048x8. get_bands(img, [0,3] will return
+ img[:,:,[0,3]]. The advantage of this function is that the image does not
+ need to be 2d + wavelength."""
+ original_shape = img.shape
+ collapsed_image = collapse_image(img)
+ img_bands = collapsed_image[ :, bands]
+ new_nr_bands = 1
+ if hasattr(bands, "__len__"):
+ new_nr_bands = len(bands)
+ new_shape = original_shape[:-1] + (new_nr_bands,)
+ return np.reshape(img_bands, new_shape)
+
+
+def sortout_bands(img, bands):
+ """delete bands bands (np.array) from the multispectral image.
+ Example: image is 2048x2048x8. sortout_bands(img, [0,3] will return
+ img[:,:,[1,2,4,5,6,7]]. The advantage of this function is that the image does not
+ need to be 2d + wavelength.
+
+ TODO SW: Test"""
+ all_bands = np.arange(img.shape[-1])
+ bands_to_get = np.setdiff1d(all_bands, bands)
+ return get_bands(img, bands_to_get)
+
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/helper/__init__.py b/Modules/Biophotonics/python/iMC/msi/io/__init__.py
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/helper/__init__.py
rename to Modules/Biophotonics/python/iMC/msi/io/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/msi/io/msireader.py b/Modules/Biophotonics/python/iMC/msi/io/msireader.py
new file mode 100644
index 0000000000..6bb7413ad8
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/msireader.py
@@ -0,0 +1,22 @@
+'''
+Created on Aug 25, 2015
+
+@author: wirkert
+'''
+
+import pickle
+
+class MsiReader(object):
+ '''
+ The MsiReader reads the Msi from the serialized python object.
+ This is the prefered way of reading an Msi.
+ '''
+
+ def __init__(self):
+ pass
+
+ def read(self, filename_to_read):
+ msi_file = open(filename_to_read, 'r')
+ msi = pickle.load(msi_file)
+ msi_file.close()
+ return msi
diff --git a/Modules/Biophotonics/python/iMC/msi/io/msiwriter.py b/Modules/Biophotonics/python/iMC/msi/io/msiwriter.py
new file mode 100644
index 0000000000..815c465a54
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/msiwriter.py
@@ -0,0 +1,25 @@
+'''
+Created on Aug 25, 2015
+
+@author: wirkert
+'''
+
+import pickle
+
+from writer import Writer
+
+class MsiWriter(Writer):
+ '''
+ The MsiReader writing the Msi as a serialized python object.
+ '''
+
+ def __init__(self, msiToWrite):
+ """
+ initialize the write with a specific multi spectral image (class Msi)
+ """
+ self.msiToWrite = msiToWrite
+
+ def write (self, uri):
+ f = open(uri, 'w')
+ pickle.dump(self.msiToWrite, f)
+ f.close()
diff --git a/Modules/Biophotonics/python/iMC/msi/io/nrrdreader.py b/Modules/Biophotonics/python/iMC/msi/io/nrrdreader.py
new file mode 100644
index 0000000000..637ac7ab43
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/nrrdreader.py
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 10 16:29:20 2015
+
+@author: wirkert
+"""
+
+import logging
+import numpy as np
+
+import SimpleITK as sitk
+
+from msi.io.reader import Reader
+from msi.msi import Msi
+
+
+class NrrdReader(Reader):
+
+ def __init__(self):
+ pass
+
+ def read(self, fileToRead):
+ """ read the nrrd image.
+ TODO: properties are not correctly extracted from nrrd."""
+
+ image = None
+
+ try:
+ reader = sitk.ImageFileReader()
+ reader.SetFileName(fileToRead)
+
+ image = reader.Execute()
+ image = sitk.GetArrayFromImage(image)
+
+ except RuntimeError as re:
+ # image could not be read
+ logging.warning("image " + fileToRead +
+ " could not be loaded: " +
+ str(re))
+ # rethrow exception after logging
+ raise
+
+ # if image is too low dimensional singleton dimensions
+ # are added when saving. Done because sitk can only handle dimensions
+ # 2,3,4. This removes these singleton dimensions again.
+ squeezed_image = np.squeeze(image)
+ msi = Msi(squeezed_image)
+ return msi
diff --git a/Modules/Biophotonics/python/iMC/msi/io/nrrdwriter.py b/Modules/Biophotonics/python/iMC/msi/io/nrrdwriter.py
new file mode 100644
index 0000000000..a07694a0e0
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/nrrdwriter.py
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 09:48:18 2015
+
+@author: wirkert
+"""
+
+import logging
+import numpy as np
+
+import SimpleITK as sitk
+
+from msi.io.writer import Writer
+
+
+class NrrdWriter(Writer):
+
+ def __init__(self, msiToWrite):
+ """
+ initialize the write with a specific multi spectral image (class Msi)
+ """
+ self.msiToWrite = msiToWrite
+
+ def write(self, uri):
+ """
+ write the msi image to the specified uri
+ """
+ img_to_write = self.msiToWrite.get_image()
+
+ # sitk can only write images of dimension 2,3,4. This hack is
+ # to fake 1d images as being 2d. 1d images e.g. occure after taking
+ # the mean of an image.
+ if len(img_to_write.shape) == 1:
+ img_to_write = np.reshape(img_to_write, (1, 1, img_to_write.shape[0]))
+
+ img = sitk.GetImageFromArray(img_to_write, isVector=True)
+ sitk.WriteImage(img, uri)
+ logging.info("written file " + uri + " to disk")
+ return None
diff --git a/Modules/Biophotonics/python/iMC/msi/io/pngreader.py b/Modules/Biophotonics/python/iMC/msi/io/pngreader.py
new file mode 100644
index 0000000000..48ee12e81e
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/pngreader.py
@@ -0,0 +1,58 @@
+'''
+Created on Sep 28, 2015
+
+@author: wirkert
+'''
+
+
+import os
+import itertools
+
+# PIL always rescales the image, thus PIL and skimage (which uses PIL) cannot
+# be used
+import png
+import numpy as np
+
+from msi.io.reader import Reader
+from msi.msi import Msi
+
+
+class PngReader(Reader):
+ """
+ Assumes bitdepth 16bit.
+ TODO SW: document and test"""
+
+ def __init__(self):
+ pass
+
+
+ def read(self, fileToRead):
+ """ read the msi from pngs.
+ The fileToRead is a string prefix, all files starting with this
+ prefix will be summarized to one msi"""
+
+ path, file_prefix = os.path.split(fileToRead)
+ files = os.listdir(path)
+ files_to_read = [os.path.join(path, f) for f in files
+ if f.startswith(file_prefix)]
+ files_to_read.sort()
+ image_array = [toImage(f)
+ for f in files_to_read]
+ image = reduce(lambda x, y: np.dstack((x, y)), image_array)
+
+ msi = Msi(image)
+ return msi
+
+
+def toImage(f):
+ reader = png.Reader(f)
+ column_count, row_count, pngdata, params = reader.asDirect()
+ plane_count = params['planes']
+ image_2d = np.vstack(itertools.imap(np.uint16, pngdata))
+ # this is needed for rgb images. probably better would be a mean in case
+ # we convert "real" rgb data. This is just for rgb images which
+ # contain the same values for r,g and b for every pixel.
+ image_3d = np.reshape(image_2d,
+ (row_count, column_count, plane_count))
+ return image_3d[:, :, 0]
+
diff --git a/Modules/Biophotonics/python/iMC/msi/io/reader.py b/Modules/Biophotonics/python/iMC/msi/io/reader.py
new file mode 100644
index 0000000000..99d6b678c3
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/reader.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 7 13:39:16 2015
+
+@author: wirkert
+"""
+
+
+class Reader:
+ """
+ Abstract reader base class
+ """
+
+ def __init__(self):
+ pass
+
+ def read(self, fileToRead):
+ return None
+
diff --git a/Modules/Biophotonics/python/iMC/msi/io/spectrometerreader.py b/Modules/Biophotonics/python/iMC/msi/io/spectrometerreader.py
new file mode 100644
index 0000000000..b182201d7a
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/spectrometerreader.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 7 12:04:18 2015
+
+@author: wirkert
+"""
+
+import numpy as np
+from msi.io.reader import Reader
+from msi.msi import Msi
+
+
+class SpectrometerReader(Reader):
+
+ def __init__(self):
+ pass
+
+ def read(self, file_to_read):
+ # our spectrometer like to follow german standards in files, we need
+ # to switch to english ones
+ transformed=""
+ replacements = {',': '.', '\r\n': ''}
+ with open(file_to_read) as infile:
+ for line in infile:
+ for src, target in replacements.iteritems():
+ line = line.replace(src, target)
+ transformed = "\n".join([transformed, line])
+
+ for num, line in enumerate(transformed.splitlines(), 1):
+ if ">>>>>Begin" in line:
+ break
+
+ for num_end, line in enumerate(transformed.splitlines(), 1):
+ if ">>>>>End" in line:
+ num_end -= 1
+ break
+ string_only_spectrum = "\n".join(transformed.splitlines()[num:num_end])
+ data_vector = np.fromstring(string_only_spectrum,
+ sep="\t").reshape(-1, 2)
+ msi = Msi(data_vector[:, 1],
+ {'wavelengths': data_vector[:, 0] * 10 ** -9})
+ return msi
+
diff --git a/Modules/Biophotonics/python/iMC/msi/io/tiffreader.py b/Modules/Biophotonics/python/iMC/msi/io/tiffreader.py
new file mode 100644
index 0000000000..fdc7bae5fb
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/tiffreader.py
@@ -0,0 +1,100 @@
+'''
+Created on Sep 28, 2015
+
+@author: wirkert
+'''
+
+
+import os
+
+import Image
+import scipy
+import numpy as np
+
+from msi.io.reader import Reader
+from msi.msi import Msi
+
+
+def sort_by_filter(s1, s2):
+ '''
+ Sorting function which takes two strings and sorts them lexigraphically by
+ the last character before the file extension.
+
+ say:
+
+ blabla_w2_F0.tiff < blabla_w0_F1.tiff
+
+ This is done to sort by the filter index, which is always written as the
+ last thing by the tiff writer.
+ '''
+ s1_prefix = os.path.splitext(s1)[0]
+ s2_prefix = os.path.splitext(s2)[0]
+
+ result = 0
+ if s1_prefix < s2_prefix:
+ result = 1
+ elif s1_prefix > s2_prefix:
+ result = -1
+
+ return result
+
+
+class TiffReader(Reader):
+ """
+ AAATTTEEENTION: Some big bug hiding somewhere here, ordering of files
+ is corrupted, no time now to fix. TODO SW
+
+ Assumes bitdepth 16bit on a 12bit camera.
+ TODO SW: document and test"""
+
+ # static member to globally set resizing for all images read by the reader
+ # 1.0 for no resizing
+ RESIZE_FACTOR = 1.0
+
+ def __init__(self, shift_bits=4):
+ self.shift_bits = shift_bits
+
+ def read(self, file_to_read, resize_factor=None,
+ sorting_function=sort_by_filter):
+ """ read the msi from tiffs.
+ The fileToRead is a string prefix, all files starting with this
+ prefix will be summarized to one msi. they will be sorted as specified
+ in the sorting_function
+
+ Args:
+ sorting_function: the function which defines the sorting of the
+ strings that match the prefix. Pass none if normal
+ lexicographical sorting is wished
+ file_to_read: the prefix of the tiff file which shall be read
+ """
+
+ if resize_factor is None:
+ resize_factor = TiffReader.RESIZE_FACTOR
+
+ path, file_prefix = os.path.split(file_to_read)
+ files = os.listdir(path)
+ files_to_read = [os.path.join(path, f) for f in files
+ if file_prefix[2:] in f]
+ files_to_read.sort(cmp=sorting_function)
+ image_array = [self.to_image(f, resize_factor=resize_factor)
+ for f in files_to_read]
+ image = reduce(lambda x, y: np.dstack((x, y)), image_array)
+
+ msi = Msi(image)
+ return msi
+
+ def to_image(self, f, resize_factor):
+ im = Image.open(f)
+ im_array = np.array(im)
+
+ im_array >>= self.shift_bits
+
+ if do_resize(resize_factor):
+ im_array = scipy.misc.imresize(im_array, resize_factor,
+ interp="bilinear", mode="F")
+
+ return im_array.astype('float')
+
+
+def do_resize(resize_factor):
+ return not np.isclose(resize_factor, 1.0) and (resize_factor is not None)
diff --git a/Modules/Biophotonics/python/iMC/msi/io/tiffringreader.py b/Modules/Biophotonics/python/iMC/msi/io/tiffringreader.py
new file mode 100644
index 0000000000..b0bf6177b9
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/tiffringreader.py
@@ -0,0 +1,100 @@
+'''
+Created on Nov 2, 2015
+
+@author: wirkert
+'''
+
+import os
+import logging
+
+import Image
+import scipy
+import numpy as np
+
+from msi.io.reader import Reader
+from msi.msi import Msi
+
+
+class TiffRingReader(Reader):
+ '''
+ TODO SW: document and test
+ '''
+
+ # static member to globally set resizing for all images read by the reader
+ # 1.0 for no resizing
+ RESIZE_FACTOR = 1.0
+
+ def __init__(self, shift_bits=4):
+ self.shift_bits = shift_bits
+
+ def read(self, fileToRead, n, resize_factor=None,
+ segmentation=None):
+ """ read the msi from tiffs.
+ The fileToRead is the first file to read,
+ then n files will be read to one msi from a
+ sorted file list
+
+ segmentation: tiff filename of the segmentation. If none, it will be
+ tried to get a segmentation from npy files with filenames like the
+ tiff files + _seg.tiff. If this fails, no segmentation will be
+ assumed
+ """
+
+ if resize_factor is None:
+ resize_factor = TiffRingReader.RESIZE_FACTOR
+
+ path, file_name = os.path.split(fileToRead)
+ files = os.listdir(path)
+ files_in_folder = [os.path.join(path, f) for f in files if
+ os.path.isfile(os.path.join(path, f)) and
+ f.endswith('.tiff')]
+
+ files_in_folder.sort()
+ position = files_in_folder.index(fileToRead)
+ # take n images from found position
+ image_array = [self.to_image(f, resize_factor)
+ for f in files_in_folder[position:position + n]]
+ image = reduce(lambda x, y: np.dstack((x, y)), image_array)
+
+ # in case of 1 dimensional image: add a fake last dimension, since
+ # we always assume the last dimension to be the wavelength domain.
+ # TODO SW: Test this and implement for other readers
+ if n is 1:
+ image = np.expand_dims(image, -1)
+
+ msi = Msi(image)
+
+ # we pass an explicic image as segmentation
+ if segmentation is not None:
+ segmentation = self.to_image(segmentation, resize_factor)
+ else: # otherwise: search for numpy segmentations
+ try:
+ segmentation_array = [to_segmentation(f)
+ for f in
+ files_in_folder[position:position + n]]
+ if do_resize(resize_factor):
+ segmentation = reduce(lambda x, y: x & y, segmentation_array)
+ segmentation = scipy.misc.imresize(segmentation, resize_factor,
+ interp="bilinear")
+ except:
+ logging.info("didn't find segmentation for all images")
+ return msi, segmentation
+
+ def to_image(self, f, resize_factor):
+ im = Image.open(f)
+ im_array = np.array(im)
+ im_array >>= self.shift_bits
+
+ if do_resize(resize_factor):
+ im_array= scipy.misc.imresize(im_array, resize_factor,
+ interp="bilinear", mode="F")
+ return im_array.astype('float')
+
+
+def to_segmentation(f):
+ seg = np.load(f + ".seg.npy")
+ return seg
+
+
+def do_resize(resize_factor):
+ return not np.isclose(resize_factor, 1.0) and (resize_factor is not None)
diff --git a/Modules/Biophotonics/python/iMC/msi/io/tiffwriter.py b/Modules/Biophotonics/python/iMC/msi/io/tiffwriter.py
new file mode 100644
index 0000000000..36506aa850
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/tiffwriter.py
@@ -0,0 +1,72 @@
+
+
+import logging
+
+import numpy as np
+from libtiff import TIFF
+
+from msi.io.writer import Writer
+
+
+class TiffWriter(Writer):
+ """
+ The tiff write will store nr_wavelength tiff files for one msi
+ """
+
+ def __init__(self, msi_to_write, convert_to_nm=True, scale_to_16_bit=False):
+ """
+ initialize the write with a specific multi spectral image (class Msi)
+ """
+ self.msi_to_write = msi_to_write
+ self.convert_to_nm = convert_to_nm
+ self.scale_to_16_bit = scale_to_16_bit
+
+ def write(self, uri_prefix):
+ """
+ write the msi image to the specified uri_prefix
+
+ Args:
+ uri_prefix: the prefix off the uri. E.g. C:\example the image
+ write will automatically extend this prefix path to include the
+ wavelengths information and add a suffix. Your final
+ file may look similar to: C:\example_w_470nm_F0.tiff
+ convert_to_nm: if the wavelengths are saved in m they are hard to
+ write as string. Thus they can be automatically expanded to nm.
+ """
+ img_to_write = self.msi_to_write.get_image()
+
+ max_image_value = np.max(img_to_write)
+
+ if self.scale_to_16_bit:
+ img_to_write *= 2**16 / max_image_value
+
+ nr_wavelengths = self.msi_to_write.get_wavelengths().size
+ for wavelength_index in np.arange(nr_wavelengths):
+ full_uri = self._build_full_uri(uri_prefix, wavelength_index)
+ self._write_single_image(full_uri,
+ img_to_write[:, :, wavelength_index])
+
+ logging.info("written file " + full_uri + " to disk")
+ return None
+
+ @staticmethod
+ def _write_single_image(full_uri, image_array):
+ """
+ internally used method to write single tiff image
+ """
+ tiff = TIFF.open(full_uri, mode='w')
+ tiff.write_image(image_array.astype('uint16'), write_rgb=False)
+ tiff.close()
+
+ def _build_full_uri(self, uri_prefix, wavelength_index):
+ """
+ Helper method to build full path of one image
+ Returns: full uri containing the desired properties.
+ """
+ wavelength = self.msi_to_write.get_wavelengths()[wavelength_index]
+ if self.convert_to_nm:
+ wavelength *= 10**9
+ full_uri = uri_prefix + "_w_" + str(wavelength) +\
+ "_F" + str(wavelength_index) + ".tiff"
+
+ return full_uri
diff --git a/Modules/Biophotonics/python/iMC/msi/io/writer.py b/Modules/Biophotonics/python/iMC/msi/io/writer.py
new file mode 100644
index 0000000000..9342ff00fe
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/io/writer.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 09:47:31 2015
+
+@author: wirkert
+"""
+
+
+class Writer():
+ """
+ Abstract writer base class
+ """
+
+ def __init__(self):
+ pass
+
+ def write(self, fileToWrite):
+ return None
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/msi/msi.py b/Modules/Biophotonics/python/iMC/msi/msi.py
new file mode 100644
index 0000000000..5638d44ad7
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/msi.py
@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 6 18:21:36 2015
+
+@author: wirkert
+"""
+
+import numpy as np
+
+
+class Msi():
+ """ a multi spectral image stack consisting of:
+
+ image: a rows x columns x nrWavelengths dimensional array
+ properties: additional, application dependent properties
+ """
+
+ def __init__(self, image=None, properties=None):
+ if image is None:
+ image = np.array([])
+ if properties is None:
+ properties = {}
+ self._image = image
+ self._properties = properties
+ self._assure_basic_properties()
+
+ self._test_image()
+
+ def get_image(self):
+ return self._image
+
+ def set_image(self, image, wavelengths=None):
+ """
+ Put a new image into this msi
+ Args:
+ image: the rows x columns x nrWavelengths dimensional array
+ np.array.
+ wavelengths: a np.array of size nrWavelengths. If the number of
+ wavelengths hasn't change this is not needed.
+ """
+ self._image = image
+ if wavelengths is not None:
+ self.set_wavelengths(wavelengths)
+ self._assure_basic_properties()
+ self._test_image()
+
+ def get_wavelengths(self):
+ """ shortcut to get the wavelengths property
+ The wavelengths are given in [m] units and need not be sorted. """
+ if 'wavelengths' not in self.get_properties():
+ return None
+ return self._properties['wavelengths']
+
+ def set_wavelengths(self, wavelengths):
+ """ shortcut to set the wavelengths property """
+ w_prop = {"wavelengths":wavelengths}
+ self.add_property(w_prop)
+ self._test_image()
+
+ def get_properties(self):
+ return self._properties
+
+ def add_property(self, newProperty):
+ """ add a new property(ies) to the existing properties """
+ self._properties.update(newProperty)
+ self._test_image()
+
+ def set_mask(self, mask):
+ """" applies a masked to the Msi. After this call, the image is of
+ type MaskedArray. If the image was already masked, the existing
+ masked will be "or ed" with the new mask. mask is a boolean array of
+ the same shape as self.get_image()
+
+ Args:
+ mask: a mask of the same size as the image. 1s stand for pixels
+ masked out, 0s for pixels not masked."""
+ if not isinstance(self.get_image(), np.ma.MaskedArray):
+ self.set_image(np.ma.masked_array(self.get_image(), mask,
+ fill_value=999999))
+ else:
+ self.get_image()[mask] = np.ma.masked
+
+ def __eq__(self, other):
+ """
+ overrite the == operator
+ Two Msi s are the same if they contain the same image and properties.
+ Note: properties not implemented yet!
+ """
+ if isinstance(other, Msi):
+ samesame = np.array_equal(other.get_image(), self.get_image())
+ return samesame
+ return NotImplemented
+
+ def __ne__(self, other):
+ """ != operator implemented by inverting to =="""
+ result = self.__eq__(other)
+ if result is NotImplemented:
+ return result
+ return not result
+
+ def _assure_basic_properties(self):
+ """
+ helper method to automatically add the basic properties:
+ wavelength
+ to the msi if not added explicicly. basic wavelengths will just be
+ integers from 0 to 1
+ """
+ if self._image.size > 0 and (
+ ("wavelengths" not in self._properties.keys() or
+ self._properties["wavelengths"].size == 0)):
+ self._properties["wavelengths"] = np.arange(self._image.shape[-1])
+ if self._image.size == 0 and "wavelengths" not in self._properties.keys():
+ self._properties["wavelengths"] = np.array([])
+
+ def _test_image(self):
+ """
+ helper method which tests for the integrity of the msi.
+ E.g. the number of wavelengths must match the number of bands.
+ """
+ # either both image and wavelength property are empty
+ if self._image.size == 0 and len(self._properties["wavelengths"]) != 0:
+ raise RuntimeError("dimension of image and wavelength mismatch: " +
+ "image size is zero, but wavelengths are set")
+ # or both are same
+ elif self._image.shape[-1] != len(self._properties["wavelengths"]):
+ raise RuntimeError("dimension of image and wavelength mismatch: " +
+ "image size and wavelenths do not match")
+
diff --git a/Modules/Biophotonics/python/iMC/msi/msimanipulations.py b/Modules/Biophotonics/python/iMC/msi/msimanipulations.py
new file mode 100644
index 0000000000..9169fa35c1
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/msimanipulations.py
@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 13:42:00 2015
+
+@author: wirkert
+"""
+
+import logging
+import copy
+import numpy as np
+
+from scipy.interpolate import interp1d
+
+from imgmani import collapse_image
+import imgmani
+from msi import Msi
+
+
+'''
+The msi manipulations module includes usefull convenience operations on msis.
+
+E.g. calculate_mean_spectrum to calculate the average spectrum on all the image
+data or interpolate_wavelengths to change to a different wavelenght set by
+simple interpolation.
+
+All methods take a msi and change it in place. They also return the same msi
+object for convenience (can e.g. be used to chain msi manipulations).
+'''
+
+
+def apply_segmentation(msi, segmentation):
+ """ applies a segmentation to an msi.
+
+ If the msi has imaging data of n x m x nr_wavelengths the segmentation
+ has to be a numpy array of n x m size. pixelvalues with values different
+ than zero will be included in the segmentation.
+ By applying the segmentation, not segmented elements will be np.ma.masked.
+
+ Alternatively, one can input a msi with the mentioned n x m numpy array
+ in from of a msi as segmentation (for convenience to be able to use the
+ same reader for msis and segmentations)
+ """
+ if (isinstance(segmentation, Msi)):
+ # expects just an image, but if a Msi is passed it's also ok
+ segmentation = segmentation.get_image()
+ segmentation = np.squeeze(segmentation)
+ mask = (0 == segmentation)
+ # mask needs to be expanded to cover all wavlengths
+ wholeMask = np.zeros_like(msi.get_image(), dtype="bool")
+ # doesn't seem elegant
+ for i in range(wholeMask.shape[-1]):
+ wholeMask[:, :, i] = mask
+
+ msi.set_mask(wholeMask)
+ return msi
+
+
+def calculate_mean_spectrum(msi):
+ """ reduce this image to only its mean spectrum.
+ If the msi.get_image() is a masked array these values will be ignored when
+ calculating the mean spectrum """
+ # reshape to collapse all but last dimension (which contains reflectances)
+ collapsedImage = collapse_image(msi.get_image())
+ msi.set_image(np.mean(collapsedImage, axis=0))
+ # returns the same msi.
+ return msi
+
+
+def interpolate_wavelengths(msi, newWavelengths):
+ """ interpolate image data to fit newWavelengths. Current implementation
+ performs simple linear interpolation. Neither existing nor new wavelengths
+ need to be sorted. """
+ interpolator = interp1d(msi.get_wavelengths(), msi.get_image(), assume_sorted=False)
+ msi.set_image(interpolator(newWavelengths), wavelengths=newWavelengths)
+ return msi
+
+
+def normalize_integration_times(msi):
+ """ divides by integration times """
+ if ('integration times' not in msi.get_properties()):
+ logging.warn("warning: trying to normalize integration times for "
+ "image without the integration time property")
+ return msi
+
+ original_shape = msi.get_image().shape
+ collapsed_image = collapse_image(msi.get_image())
+ collapsed_image = collapsed_image / msi.get_properties()['integration times']
+ msi.set_image(collapsed_image.reshape(original_shape))
+
+ msi.add_property({'integration times':
+ np.ones_like(msi.get_properties()['integration times'])})
+ return msi
+
+
+def dark_correction(msi, dark):
+ """" subtract dark current from multi spectral image.
+
+ The dark msi should either be of the same shape
+ as msi or 1xnr_wavelengths (see tests)."""
+ msi.set_image(msi.get_image() - dark.get_image())
+ return msi
+
+
+def flatfield_correction(msi, flatfield):
+ """ divide by flatfield to remove dependencies on light source form and
+ imaging system.
+
+ The flatfield msi should either be of the same shape
+ as msi or 1xnr_wavelengths (see tests)."""
+ # we copy the flatfield to ensure it is unchanged by the normalization
+ flatfield_copy = copy.copy(flatfield)
+ normalize_integration_times(flatfield_copy)
+ normalize_integration_times(msi)
+
+ msi.set_image(msi.get_image() / flatfield_copy.get_image())
+ return msi
+
+
+def image_correction(msi, flatfield, dark):
+ """ do the usual image correction:
+ msi = ((msi - dark) / integration_time) / ((flatfield - dark) / integration_time)
+ this function changes only the msi, flatfield and dark image
+ are left unchanged.
+ """
+ # we need a copy of flatfield since otherwise the dark correction
+ # changes the flatfield
+ dark_correction(msi, dark)
+ flatfield_copy = copy.copy(flatfield)
+ dark_correction(flatfield_copy, dark)
+ flatfield_correction(msi, flatfield_copy)
+ return msi
+
+
+def get_bands(msi, bands):
+ """
+ TODO SW: document and test
+ """
+ msi.set_image(imgmani.get_bands(msi.get_image(), bands))
+ if msi.get_wavelengths() is not None:
+ msi.set_wavelengths(msi.get_wavelengths()[bands])
+ return msi
+
diff --git a/Modules/Biophotonics/python/iMC/msi/normalize.py b/Modules/Biophotonics/python/iMC/msi/normalize.py
new file mode 100644
index 0000000000..880bbffed4
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/normalize.py
@@ -0,0 +1,53 @@
+
+import numpy as np
+from sklearn.preprocessing import Normalizer
+
+
+from imgmani import collapse_image
+
+
+class Normalize():
+
+ def __init__(self):
+ pass
+
+ def normalize(self, msi):
+ pass
+
+
+class NormalizeIQ(Normalize):
+ """Normalize by image quotient"""
+ def __init__(self, iqBand=None):
+ if iqBand is None:
+ iqBand = 0
+ self.iqBand = iqBand
+
+ def normalize(self, msi):
+ # todo: guard if iqBand is outside of image dimension
+ original_shape = msi.get_image().shape
+ collapsed_image = collapse_image(msi.get_image())
+ iqDimension = collapsed_image[ :, self.iqBand]
+ normalized_image = collapsed_image / iqDimension[:, None]
+ msi.set_image(np.reshape(normalized_image, original_shape))
+
+
+class NormalizeMean(Normalize):
+ """Normalize by image mean"""
+ def __init__(self):
+ pass
+
+ def normalize(self, msi, norm="l1"):
+ original_shape = msi.get_image().shape
+ collapsed_image = collapse_image(msi.get_image())
+ # temporarily save mask, since scipy normalizer removes mask
+ is_masked_array = isinstance(msi.get_image(), np.ma.MaskedArray)
+ if is_masked_array:
+ mask = msi.get_image().mask
+ normalizer = Normalizer(norm=norm)
+ normalized_image = normalizer.transform(collapsed_image)
+ if is_masked_array:
+ normalized_image = np.ma.MaskedArray(normalized_image, mask=mask)
+ msi.set_image(np.reshape(normalized_image, original_shape))
+
+
+standard_normalizer = NormalizeMean()
diff --git a/Modules/Biophotonics/python/iMC/msi/plot.py b/Modules/Biophotonics/python/iMC/msi/plot.py
new file mode 100644
index 0000000000..0ae653b2ce
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/plot.py
@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 11:13:31 2015
+
+@author: wirkert
+"""
+
+import copy
+import logging
+
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+import imgmani
+import msimanipulations as msimani
+
+def plot(msi, axes=None, color=None):
+ """
+ create a plot for the Msi with x axes being the wavelengths and
+ y-axes being the corresponding image values (e.g. reflectances, absorptions)
+ Takes image masks into account:
+ doesn't plot a spectrum containing masked elements
+ """
+ if axes is None:
+ axes = plt.gca()
+
+ sortedIndices = sorted(range(len(msi.get_wavelengths())),
+ key=lambda k: msi.get_wavelengths()[k])
+ sortedWavelenghts = msi.get_wavelengths()[sortedIndices]
+ # reshape to collapse all but last dimension (which contains reflectances)
+ collapsedImage = imgmani.collapse_image(msi.get_image())
+ # todo: simply use np.ma.compress_rows
+
+ # print "filtered ", filteredImage.shape
+ i = 0
+ for i in range(collapsedImage.shape[0]):
+ if (collapsedImage[i, 0] is not np.ma.masked):
+ axes.plot(sortedWavelenghts,
+ collapsedImage[i, :][sortedIndices], "-o", color=color)
+
+
+def plot_images(msi):
+ """plot the images as a 2d image array, one image for
+ each wavelength."""
+ nr_wavelengths = msi.get_image().shape[-1]
+ f, axarr = plt.subplots(1, nr_wavelengths)
+ for i, a in enumerate(axarr):
+ one_band_image = imgmani.get_bands(msi.get_image(), i)
+ im = a.imshow(np.squeeze(one_band_image))
+ a.set_title("band nr " + str(i), fontsize=5)
+ divider_dsp = make_axes_locatable(a)
+ cax_dsp = divider_dsp.append_axes("right", size="10%", pad=0.1)
+ cbar = plt.colorbar(im, cax=cax_dsp)
+ cbar.ax.tick_params(labelsize=5)
+ a.xaxis.set_visible(False)
+ a.yaxis.set_visible(False)
+
+
+def plotMeanError(msi, axes=None):
+ """
+ create a plot for the Msi with x axes being the wavelengths and
+ y-axes being the corresponding mean image values
+ (e.g. reflectances, absorptions). Plots also standard deviation bands
+ Takes image masks into account:
+ doesn't plot a spectrum containing masked elements
+ """
+ if axes is None:
+ axes = plt.gca()
+ # sort the wavelengths
+ sortedIndices = sorted(range(len(msi.get_wavelengths())),
+ key=lambda k: msi.get_wavelengths()[k])
+ sortedWavelenghts = msi.get_wavelengths()[sortedIndices]
+ # copy the msi, since it will be altered (mean will be built)
+ msi_copy = copy.deepcopy(msi)
+ image = msi_copy.get_image()
+ image = imgmani.collapse_image(image)
+ std_curve = np.ma.std(image, axis=0)
+ msimani.calculate_mean_spectrum(msi_copy)
+ # calculate std
+ logging.info("percentual std: " +
+ str(std_curve / msi_copy.get_image() * 100.))
+ # plot as errorbar
+ axes.errorbar(sortedWavelenghts, msi_copy.get_image()[sortedIndices],
+ yerr=std_curve, fmt='-o')
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/reader/__init__.py b/Modules/Biophotonics/python/iMC/msi/test/__init__.py
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/reader/__init__.py
rename to Modules/Biophotonics/python/iMC/msi/test/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/msi/test/helpers.py b/Modules/Biophotonics/python/iMC/msi/test/helpers.py
new file mode 100644
index 0000000000..4565f7e63a
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/helpers.py
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 09:53:52 2015
+
+@author: wirkert
+"""
+
+import numpy as np
+from msi.msi import Msi
+
+
+def getFakeMsi():
+
+ # build a fake multispectral image with 5 dimensions.
+ image = np.concatenate((np.ones((5, 5, 1)),
+ np.ones((5, 5, 1)) * 2,
+ np.ones((5, 5, 1)) * 3,
+ np.ones((5, 5, 1)) * 4,
+ np.ones((5, 5, 1)) * 5),
+ axis=-1)
+ msi = Msi(image)
+
+ msi.set_wavelengths(np.array([5, 4, 3, 2, 1]))
+
+ return msi
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_imgmani.py b/Modules/Biophotonics/python/iMC/msi/test/test_imgmani.py
new file mode 100644
index 0000000000..c6960958ca
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_imgmani.py
@@ -0,0 +1,96 @@
+'''
+Created on Aug 28, 2015
+
+@author: wirkert
+'''
+import unittest
+import numpy as np
+
+import msi.msimanipulations as msimani
+import msi.imgmani as imgmani
+import msi.test.helpers as helpers
+from msi.imgmani import remove_masked_elements, select_n_reflectances
+
+
+class TestImgMani(unittest.TestCase):
+
+ def setUp(self):
+ self.msi = helpers.getFakeMsi()
+ # set one pixel to special values
+ self.specialValue = np.arange(self.msi.get_image().shape[-1]) * 2
+ self.msi.get_image()[2, 2, :] = self.specialValue
+ # create a segmentation which sets all elements to invalid but the
+ # one pixel with the special value
+ self.segmentation = np.zeros(self.msi.get_image().shape[0:-1])
+ self.segmentation[2, 2] = 1
+ # apply this segmentation to the msi
+ msimani.apply_segmentation(self.msi, self.segmentation)
+ self.image = self.msi.get_image()
+
+ def tearDown(self):
+ self.msi = None
+ self.specialValue = None
+ self.segmentation = None
+ self.image = None
+
+ def test_collapse_image(self):
+ image = self.image
+ newShapedImage = imgmani.collapse_image(image)
+
+ self.assertEqual(newShapedImage.shape,
+ (image.shape[0] * image.shape[1], image.shape[2]),
+ "collapsed image has correct shape")
+ np.testing.assert_equal(newShapedImage[2 * 5 + 2, :],
+ self.msi.get_image()[2, 2, :],
+ "values have been correctly transformed")
+
+ def test_collapse_image_retains_data(self):
+ newShapedImage = imgmani.collapse_image(self.image)
+ self.msi.get_image()[2, 2, 0] = 5000.
+
+ self.assertEqual(newShapedImage[2 * 5 + 2, 0], 5000.,
+ "collapse_image does not copy data")
+
+ def test_remove_masked_elements(self):
+ value = self.msi.get_image()[2, 2, :]
+ image_without_masked = remove_masked_elements(self.image)
+ np.testing.assert_array_equal(image_without_masked[0, :], value,
+ "mask correctly removed")
+ self.assertEqual(image_without_masked.shape,
+ (1, self.image.shape[-1]),
+ "shape of image without mask correct")
+
+ def test_select_n_reflectances_selects(self):
+ n = 10
+ new_image = select_n_reflectances(self.image, n)
+ self.assertEqual(new_image.shape, (n, self.image.shape[-1]),
+ "correct shape after selection")
+
+ def test_select_n_reflectances_permutes(self):
+ image_shape = self.image.shape
+ new_first_layer = np.random.random_sample(image_shape[0:-1])
+ self.image[:, :, 0] = new_first_layer
+ shuffled_image = select_n_reflectances(self.image,
+ image_shape[0] * image_shape[1])
+ # restore_shape
+ shuffled_image = np.reshape(shuffled_image, image_shape)
+ self.assertFalse(np.allclose(shuffled_image[:, :, 0],
+ new_first_layer),
+ "image has been shuffled")
+
+ def test_get_bands_from_int(self):
+ new_image_bands = imgmani.get_bands(self.image, 2)
+ self.assertEqual(new_image_bands.shape, (5, 5, 1),
+ "new image has correct shape")
+ self.assertEqual(new_image_bands[2, 2, :], self.specialValue[2],
+ "new image has correct values")
+
+ def test_get_bands_from_array(self):
+ new_image_bands = imgmani.get_bands(self.image, np.array([0, 1, 2]))
+ self.assertEqual(new_image_bands.shape, (5, 5, 3),
+ "new image has correct shape")
+ np.testing.assert_allclose(new_image_bands[2, 2, :],
+ self.specialValue[:3],
+ err_msg="new image has correct values")
+
+
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_msi.py b/Modules/Biophotonics/python/iMC/msi/test/test_msi.py
new file mode 100644
index 0000000000..128a0691df
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_msi.py
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Mar 27 19:12:40 2015
+
+@author: wirkert
+"""
+
+import unittest
+import numpy as np
+
+from msi.msi import Msi
+from msi.test import helpers
+
+
+class TestMsi(unittest.TestCase):
+
+ def setUp(self):
+ self.msi = helpers.getFakeMsi()
+
+ def tearDown(self):
+ pass
+
+ def test_create(self):
+ self.assertTrue(True, "Created msi during setup")
+
+ def test_add_property(self):
+ self.msi.add_property({'test':np.array([1, 2, 3])})
+ self.assertTrue(np.array_equal(self.msi.get_properties()['test'],
+ np.array([1, 2, 3])), "property successfully added to msi")
+
+ def test_properties_not_shared(self):
+ msi1 = Msi()
+ msi2 = Msi()
+ msi1.add_property({"integration time": np.array([1, 2, 3])})
+
+ self.assertTrue('integration time' not in msi2.get_properties())
+
+ def test_add_dummy_wavelengths_automatically(self):
+ msi_no_wavelengths_set = Msi()
+ msi_no_wavelengths_set.set_image(self.msi.get_image())
+
+ nr_wavelengths = msi_no_wavelengths_set.get_image().shape[-1]
+
+ np.testing.assert_equal(msi_no_wavelengths_set.get_wavelengths(),
+ np.arange(nr_wavelengths),
+ "correct dummy wavelength values set")
+
+
+
+
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_msimanipulations.py b/Modules/Biophotonics/python/iMC/msi/test/test_msimanipulations.py
new file mode 100644
index 0000000000..9b895a6cf4
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_msimanipulations.py
@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 13:52:23 2015
+
+@author: wirkert
+"""
+
+
+import unittest
+import copy
+import numpy as np
+
+from msi.test import helpers
+import msi.msimanipulations as mani
+
+
+class TestMsiManipulations(unittest.TestCase):
+
+ def setUp(self):
+ self.msi = helpers.getFakeMsi()
+ self.specialmsi = helpers.getFakeMsi()
+
+ # set one pixel to special values
+ self.specialValue = np.arange(self.specialmsi.get_image().shape[-1]) * 2
+ self.specialmsi.get_image()[2, 2, :] = self.specialValue
+
+ # create a segmentation which sets all elements to invalid but the
+ # one pixel with the special value
+ self.segmentation = np.zeros(self.specialmsi.get_image().shape[0:-1])
+ self.segmentation[2, 2] = 1
+
+ def tearDown(self):
+ pass
+
+ def test_apply_segmentation(self):
+
+ mani.apply_segmentation(self.specialmsi, self.segmentation)
+
+ validImageEntries = self.specialmsi.get_image() \
+ [~self.specialmsi.get_image().mask]
+
+ np.testing.assert_equal(validImageEntries, self.specialValue,
+ "image has been correctly segmented")
+
+ def test_calculate_mean_spectrum(self):
+
+ mani.calculate_mean_spectrum(self.specialmsi)
+
+ np.testing.assert_equal(np.array([0.96, 2., 3.04, 4.08, 5.12]),
+ self.specialmsi.get_image(),
+ "mean spectrum is correctly calculated on image with " +
+ "no mask applied")
+
+ def test_calculate_mean_spectrum_masked_image(self):
+
+ mani.apply_segmentation(self.specialmsi, self.segmentation)
+ mani.calculate_mean_spectrum(self.specialmsi)
+
+ np.testing.assert_equal(self.specialValue, self.specialmsi.get_image(),
+ "mean spectrum is correctly calculated on image with " +
+ "mask applied")
+
+ def test_interpolate(self):
+ # create not sorted new wavelengths
+ newWavelengths = np.array([4.0, 2.5, 3.5, 1.5])
+ mani.interpolate_wavelengths(self.msi, newWavelengths)
+
+ np.testing.assert_equal(newWavelengths, self.msi.get_wavelengths(),
+ "wavelengths correctly updated")
+ # check if first image pixel was correctly calculated
+ # (hopefully true for all then)
+ np.testing.assert_equal(np.array([2.0, 3.5, 2.5, 4.5]),
+ self.msi.get_image()[0, 0, :],
+ "image elements correctly interpolated")
+
+ def test_normalize_integration_times(self):
+ old_shape = self.msi.get_image().shape
+ integration_times = np.array([1., 2., 3., 4., 5.])
+ self.msi.add_property({'integration times': integration_times})
+ mani.normalize_integration_times(self.msi)
+
+ np.testing.assert_equal(self.msi.get_image()[1, 3, :],
+ np.ones_like(integration_times),
+ "normalized integration times")
+ np.testing.assert_equal(self.msi.get_properties()['integration times'],
+ np.ones_like(integration_times),
+ "integration time property set to ones")
+ self.assertEqual(self.msi.get_image().shape, old_shape,
+ "shape did not change from normalizing")
+
+ def test_normalize_integration_times_none_given(self):
+ msi_copy = copy.deepcopy(self.msi)
+ mani.normalize_integration_times(msi_copy)
+ np.testing.assert_equal(msi_copy.get_image(), self.msi.get_image(),
+ "nothing change by normalizing without" + \
+ "integration times given")
+
+ def test_dark_correction(self):
+ desired_image_data = copy.copy(self.msi.get_image())
+ desired_image_data -= 1
+
+ dark = copy.copy(self.msi)
+ dark.set_image(np.ones_like(dark.get_image()))
+
+ mani.dark_correction(self.msi, dark)
+
+ np.testing.assert_equal(self.msi.get_image(),
+ desired_image_data,
+ "dark image correctly accounted for")
+ np.testing.assert_equal(dark.get_image(),
+ np.ones_like(dark.get_image()),
+ "dark image unchanged by dark correction")
+
+ def test_dark_correction_with_single_value(self):
+ desired_image_data = copy.copy(self.specialmsi.get_image())
+ desired_image_data -= 1
+
+ dark = copy.copy(self.specialmsi)
+ dark.set_image(np.ones_like(dark.get_image()))
+ mani.calculate_mean_spectrum(dark)
+
+ mani.dark_correction(self.specialmsi, dark)
+
+ np.testing.assert_equal(self.specialmsi.get_image(),
+ desired_image_data,
+ "dark image correctly accounted for from singular dark value")
+ np.testing.assert_equal(dark.get_image(),
+ np.ones_like(dark.get_image()),
+ "dark image unchanged by dark correction")
+
+ def test_flatfield_correction(self):
+ desired_image_data = np.ones_like(self.specialmsi.get_image())
+ desired_image_data[2, 2, 0] = np.nan
+
+ mani.flatfield_correction(self.specialmsi, self.specialmsi)
+
+ np.testing.assert_equal(self.specialmsi.get_image(),
+ desired_image_data,
+ "correct image by itself should lead to only 1s ")
+
+ def test_flatfield_correction_differing_integration_times(self):
+ MSI_INTEGRATION_TIME = 3.0
+ FLATFIELD_INTEGRATION_TIME = 2.0
+ desired_image_data = np.ones_like(self.specialmsi.get_image()) * \
+ FLATFIELD_INTEGRATION_TIME / MSI_INTEGRATION_TIME
+ desired_image_data[2, 2, 0] = np.nan
+ self.specialmsi.add_property({"integration times":
+ np.ones_like(
+ self.specialmsi.get_image()[0, 0, :])
+ * MSI_INTEGRATION_TIME})
+ flatfield = copy.deepcopy(self.specialmsi)
+ flatfield.add_property({"integration times":
+ np.ones_like(
+ flatfield.get_image()[0, 0, :])
+ * FLATFIELD_INTEGRATION_TIME})
+ # for testing if flatfield does not changed by correction we copy it
+ flatfield_copy = copy.deepcopy(flatfield)
+
+ mani.flatfield_correction(self.specialmsi, flatfield_copy)
+
+ np.testing.assert_almost_equal(self.specialmsi.get_image(),
+ desired_image_data, 15,
+ "corrected image is a division of integration times")
+ np.testing.assert_equal(flatfield.get_image(),
+ flatfield_copy.get_image(),
+ "flatfield doesn't change by correction")
+
+ def test_flatfield_correction_with_single_value(self):
+ desired_image_data = np.ones_like(self.msi.get_image())
+ flatfield = copy.copy(self.msi)
+ mani.calculate_mean_spectrum(flatfield)
+ unchanged_flatfield = copy.deepcopy(flatfield)
+
+ mani.flatfield_correction(self.msi, flatfield)
+
+ np.testing.assert_equal(self.msi.get_image(),
+ desired_image_data,
+ "flatfield correctly accounted for from singular reference value")
+ np.testing.assert_equal(flatfield, unchanged_flatfield,
+ "flatfield not changed by algorithm")
+
+ def test_image_correction(self):
+ dark = copy.copy(self.msi)
+ dark.set_image(np.ones_like(dark.get_image()) * 0.5)
+ flatfield = copy.copy(self.msi)
+ flatfield_copy = copy.deepcopy(flatfield)
+ dark_copy = copy.deepcopy(dark)
+
+ mani.image_correction(self.msi, flatfield, dark)
+
+ np.testing.assert_equal(flatfield.get_image(),
+ flatfield_copy.get_image(),
+ "image correction didn't change flatfield")
+ np.testing.assert_equal(dark.get_image(), dark_copy.get_image(),
+ "image correction didn't change dark image")
+ np.testing.assert_almost_equal(self.msi.get_image(),
+ np.ones_like(self.msi.get_image()),
+ 15, "image correctly corrected :-)")
+
+
+
+
+
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_msireaderwriter.py b/Modules/Biophotonics/python/iMC/msi/test/test_msireaderwriter.py
new file mode 100644
index 0000000000..a3bed221b0
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_msireaderwriter.py
@@ -0,0 +1,40 @@
+'''
+Created on Aug 25, 2015
+
+@author: wirkert
+'''
+import unittest
+import os
+import numpy as np
+
+import msi.test.helpers as helpers
+from msi.io.msiwriter import MsiWriter
+from msi.io.msireader import MsiReader
+
+
+class Test(unittest.TestCase):
+
+ def setUp(self):
+ self.msi = helpers.getFakeMsi()
+ self.test_file_path = "test_msi.msi"
+
+ def tearDown(self):
+ # remove the hopefully written file
+ os.remove(self.test_file_path)
+
+ def test_read_and_write(self):
+ reader = MsiReader()
+ writer = MsiWriter(self.msi)
+ writer.write(self.test_file_path)
+ read_msi = reader.read(self.test_file_path)
+
+ np.testing.assert_array_equal(self.msi.get_image(),
+ read_msi.get_image(),
+ "data array of msi stays same" +
+ "after read and write")
+ np.testing.assert_array_equal(
+ self.msi.get_properties()["wavelengths"],
+ read_msi.get_properties()["wavelengths"],
+ "properties of msi stay same after read and write")
+
+
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_normalize.py b/Modules/Biophotonics/python/iMC/msi/test/test_normalize.py
new file mode 100644
index 0000000000..72f2a844c6
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_normalize.py
@@ -0,0 +1,74 @@
+'''
+Created on Aug 20, 2015
+
+@author: wirkert
+'''
+import unittest
+import numpy as np
+
+import msi.normalize as norm
+import msi.test.helpers as helpers
+
+
+class TestNormalize(unittest.TestCase):
+
+ def setUp(self):
+ self.specialmsi = helpers.getFakeMsi()
+ # set one pixel to special values
+ self.specialValue = np.arange(self.specialmsi.get_image().shape[-1]) * 2
+ self.specialmsi.get_image()[2, 2, :] = self.specialValue
+
+ def tearDown(self):
+ pass
+
+ def test_normalizeIQ(self):
+ original_shape = self.specialmsi.get_image().shape # shape should stay
+ # value 4.0 is in band 3
+ desired_matrix = self.specialmsi.get_image() / 4.0
+ # except for special value, where it is 8
+ desired_matrix[2, 2, :] = self.specialmsi.get_image()[2, 2, :] / 6.0
+ # the same after normalization
+ iq_normalizer = norm.NormalizeIQ(3)
+ iq_normalizer.normalize(self.specialmsi)
+
+ self.assertEqual(self.specialmsi.get_image().shape, original_shape,
+ "shape not changed by normalization")
+ np.testing.assert_equal(self.specialmsi.get_image(),
+ desired_matrix,
+ "msi correctly normalized by iq")
+
+ def test_normalizeMean(self):
+ original_shape = self.specialmsi.get_image().shape # shape should stay
+ desired_matrix = self.specialmsi.get_image() / 15.0
+ desired_matrix[2, 2, :] = self.specialmsi.get_image()[2, 2, :] / 20.0
+ # the same after normalization
+ mean_normalizer = norm.NormalizeMean()
+ mean_normalizer.normalize(self.specialmsi)
+
+ self.assertEqual(self.specialmsi.get_image().shape, original_shape,
+ "shape not changed by normalization")
+ np.testing.assert_equal(self.specialmsi.get_image(),
+ desired_matrix,
+ "msi correctly normalized by mean")
+
+ def test_normalizeMean_with_masked_elemnets(self):
+ original_shape = self.specialmsi.get_image().shape # shape should stay
+ # set mask so it masks the special value
+ mask = np.zeros_like(self.specialmsi.get_image())
+ mask [2, 2, :] = 1
+ mask = mask.astype(bool)
+ masked_msi_image = np.ma.MaskedArray(self.specialmsi.get_image(),
+ mask=mask)
+ self.specialmsi.set_image(masked_msi_image)
+ desired_matrix = masked_msi_image / 15.0
+ # the same after normalization
+ mean_normalizer = norm.NormalizeMean()
+ mean_normalizer.normalize(self.specialmsi)
+
+ self.assertEqual(self.specialmsi.get_image().shape, original_shape,
+ "shape not changed by normalization")
+ np.testing.assert_equal(self.specialmsi.get_image(),
+ desired_matrix,
+ "msi correctly normalized by mean")
+ np.testing.assert_equal(mask, self.specialmsi.get_image().mask)
+
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_nrrdreader.py b/Modules/Biophotonics/python/iMC/msi/test/test_nrrdreader.py
new file mode 100644
index 0000000000..da5083a125
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_nrrdreader.py
@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 10 16:43:31 2015
+
+@author: wirkert
+"""
+
+import unittest
+from msi.io.nrrdreader import NrrdReader
+import numpy as np
+
+
+class TestNrrdReader(unittest.TestCase):
+
+ def setUp(self):
+ self.nrrdReader = NrrdReader()
+ self.msi = self.nrrdReader.read('./msi/data/testMsi.nrrd')
+
+ def test_read_does_not_crash(self):
+ # if we got this far, at least an image was read.
+ self.assertTrue(len(self.msi.get_image().shape) == 3,
+ "read image has correct basic shape dimensions")
+ self.assertTrue(self.msi.get_image().shape[-1] == 5,
+ "read image has correct number of image stacks")
+ self.assertTrue(np.array_equal(self.msi.get_image()[2, 2, :],
+ np.array([1, 2, 3, 4, 5])),
+ "read image contains correct data")
+
+ def test_read_non_existing_image_returns_exception(self):
+ with self.assertRaises(RuntimeError):
+ self.nrrdReader.read("./msi/data/asdf.nrrd")
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_nrrdwriter.py b/Modules/Biophotonics/python/iMC/msi/test/test_nrrdwriter.py
new file mode 100644
index 0000000000..c442b76159
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_nrrdwriter.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 13 09:52:47 2015
+
+@author: wirkert
+"""
+
+import unittest
+import os
+import numpy as np
+
+import msi.msimanipulations as msimani
+from msi.io.nrrdreader import NrrdReader
+from msi.io.nrrdwriter import NrrdWriter
+from msi.test import helpers
+
+
+class TestNrrdWriter(unittest.TestCase):
+
+ def setUp(self):
+ # setup file and the path where it shall be written to
+ self.msi = helpers.getFakeMsi()
+ self.fileUriToWrite = "testfile.nrrd"
+
+ def tearDown(self):
+ # remove the hopefully written file
+ os.remove(self.fileUriToWrite)
+
+ def test_imageWriterCreatesFile(self):
+ writer = NrrdWriter(self.msi)
+ writer.write(self.fileUriToWrite)
+ self.assertTrue(os.path.isfile(self.fileUriToWrite),
+ "file was written to disk")
+
+ def test_imageWriterCreatesCorrectFile(self):
+
+ writer = NrrdWriter(self.msi)
+ writer.write(self.fileUriToWrite)
+
+ reader = NrrdReader()
+ msi = reader.read(self.fileUriToWrite)
+ self.assertTrue(msi == helpers.getFakeMsi(),
+ "image correctly written and read")
+
+ def test_write_one_d_image_works(self):
+ writer = NrrdWriter(self.msi)
+ msimani.calculate_mean_spectrum(self.msi)
+ writer.write(self.fileUriToWrite)
+
+ reader = NrrdReader()
+ msi = reader.read(self.fileUriToWrite)
+ np.testing.assert_array_equal(msi.get_image(),
+ np.array([1, 2, 3, 4, 5]),
+ "1d image correctly written and read")
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_spectrometerreader.py b/Modules/Biophotonics/python/iMC/msi/test/test_spectrometerreader.py
new file mode 100644
index 0000000000..b993a434bf
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_spectrometerreader.py
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 7 18:02:08 2015
+
+@author: wirkert
+"""
+
+import unittest
+
+from msi.io.spectrometerreader import SpectrometerReader
+
+
+class TestSpectrometer(unittest.TestCase):
+
+ def setUp(self):
+ self.exampleFileName = "./msi/data/Transmission_15-49-35-978_filter700nm.txt"
+ self.reader = SpectrometerReader()
+
+ def tearDown(self):
+ pass
+
+ def test_create(self):
+ self.assertTrue(True, "Created empty reader during setup")
+
+ def test_read_spectrum(self):
+ msi = self.reader.read(self.exampleFileName)
+
+ self.assertAlmostEqual(msi.get_image()[0],
+ 70.50,
+ msg="first spectral element is read correctly")
+ self.assertAlmostEqual(msi.get_image()[-1],
+ 68.13,
+ msg="last sprectral element is read correctly")
+ self.assertTrue(msi.get_image().size == 2048,
+ "correct number of elements read")
+
+ def test_read_wavelengths(self):
+ msi = self.reader.read(self.exampleFileName)
+
+ self.assertAlmostEqual(msi.get_wavelengths()[0],
+ 187.255 * 10 ** -9,
+ msg="first wavelength element is read correctly")
+ self.assertAlmostEqual(msi.get_wavelengths()[-1],
+ 1103.852 * 10 ** -9,
+ msg="last wavelength element is read correctly")
+ self.assertTrue(msi.get_wavelengths().size == 2048,
+ "correct number of elements read")
diff --git a/Modules/Biophotonics/python/iMC/msi/test/test_tiffwriter.py b/Modules/Biophotonics/python/iMC/msi/test/test_tiffwriter.py
new file mode 100644
index 0000000000..a2e880b80c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/msi/test/test_tiffwriter.py
@@ -0,0 +1,40 @@
+
+import unittest
+import os
+
+from msi.io.tiffwriter import TiffWriter
+from msi.io.tiffreader import TiffReader
+from msi.test import helpers
+
+
+class TestTiffWriter(unittest.TestCase):
+
+ def setUp(self):
+ # setup file and the path where it shall be written to
+ self.msi = helpers.getFakeMsi()
+ self.msi.set_image(self.msi.get_image())
+ self.fileUriToWrite = os.path.join(os.getcwd(), "testfiles")
+
+ def tearDown(self):
+ # remove the hopefully written files
+ folder, file_prefix = os.path.split(self.fileUriToWrite)
+ image_files = [f for f in os.listdir(folder) if
+ os.path.isfile(os.path.join(folder, f))]
+ image_files = [f for f in image_files if f.startswith(file_prefix)]
+ # expand to full path
+ image_files = [os.path.join(folder, f) for f in image_files]
+ for f in image_files:
+ os.remove(f)
+
+ def test_imageWriterCreatesFile(self):
+ writer = TiffWriter(self.msi, convert_to_nm=False)
+ writer.write(self.fileUriToWrite)
+
+ def test_imageWriterCreatesCorrectFile(self):
+ writer = TiffWriter(self.msi, convert_to_nm=False)
+ writer.write(self.fileUriToWrite)
+
+ reader = TiffReader(shift_bits=0)
+ msi = reader.read(self.fileUriToWrite)
+ self.assertTrue(msi == helpers.getFakeMsi(),
+ "image correctly written and read")
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/setup/__init__.py b/Modules/Biophotonics/python/iMC/regression/__init__.py
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/setup/__init__.py
rename to Modules/Biophotonics/python/iMC/regression/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/regression/domain_adaptation.py b/Modules/Biophotonics/python/iMC/regression/domain_adaptation.py
new file mode 100644
index 0000000000..316f378aa9
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/regression/domain_adaptation.py
@@ -0,0 +1,88 @@
+'''
+Created on Oct 20, 2015
+
+@author: wirkert
+'''
+
+import numpy as np
+from sklearn.cross_validation import KFold
+from sklearn.grid_search import GridSearchCV
+from sklearn.linear_model.logistic import LogisticRegressionCV
+from sklearn.ensemble.forest import RandomForestClassifier
+
+
+def prepare_data_for_weights_estimation(X_s, X_t):
+ nr_s = X_s.shape[0]
+ nr_t = X_t.shape[0]
+ source_labels = np.zeros(nr_s)
+ target_labels = np.ones(nr_t)
+ X_all = np.concatenate((X_s, X_t))
+ all_labels = np.concatenate((source_labels, target_labels))
+ return X_all, all_labels
+
+
+def estimate_weights_random_forests(X_s, X_t, X_w):
+
+ X_all, all_labels = prepare_data_for_weights_estimation(X_s, X_t)
+ # train logistic regression
+ kf = KFold(X_all.shape[0], 10, shuffle=True)
+ param_grid_rf = [
+ {"n_estimators": np.array([500]),
+ "max_depth": np.array([6]),
+ # "max_features": np.array([1, 2, 4, 8, 16]),
+ "min_samples_leaf": np.array([100])}]
+ rf = GridSearchCV(RandomForestClassifier(50, max_depth=10,
+ class_weight="auto", n_jobs=-1),
+ param_grid_rf, cv=kf, n_jobs=-1)
+ rf = RandomForestClassifier(100, max_depth=6, min_samples_leaf=200,
+ class_weight="auto", n_jobs=-1)
+ rf.fit(X_all, all_labels)
+ # print "best parameters for rf weights determination: ", rf.best_estimator_
+ probas = rf.predict_proba(X_w)
+ weights = probas[:, 1] / probas[:, 0]
+ return weights
+
+
+def estimate_weights_logistic_regresssion(X_s, X_t):
+ """ estimate a logistic regressor to predict the probability of a sample
+ to be generated by one class or the other.
+ If one class is over or under represented weights will be adapted.
+
+ Parameters:
+ X_s: samples from the source domain
+ X_t: samples from the target domain
+
+ Returns:
+ weigths for X_s """
+ X_all, all_labels = prepare_data_for_weights_estimation(X_s, X_t)
+
+ kf = KFold(X_all.shape[0], 10, shuffle=True)
+ best_lr = LogisticRegressionCV(class_weight="auto",
+ Cs=np.logspace(4, 8, 10),
+ fit_intercept=False)
+ best_lr.fit(X_all, all_labels)
+
+ weights = X_s.shape[0] / X_t.shape[0] * np.exp(np.dot(X_s, best_lr.coef_.T)
+ + best_lr.intercept_)
+ return weights
+
+
+def resample(X, y, w, nr_samples=None):
+ """bootstrapping: resample with replacement according to weights
+
+ Returns:
+ (X_new, w_new): the chosen samples and the new weights.
+ by design these new weights are all equal to 1."""
+ if (nr_samples is None):
+ nr_samples = X.shape[0]
+ w = w / np.sum(w) # normalize
+ # create index array with samples to draw:
+ total_nr_samples = X.shape[0] # nr total samples
+ chosen_samples = np.random.choice(total_nr_samples,
+ size=nr_samples,
+ replace=True, p=np.squeeze(w))
+ if y.ndim == 1:
+ y_chosen = y[chosen_samples]
+ else:
+ y_chosen = y[chosen_samples, :]
+ return X[chosen_samples, :], y_chosen, np.ones(nr_samples)
diff --git a/Modules/Biophotonics/python/iMC/regression/estimation.py b/Modules/Biophotonics/python/iMC/regression/estimation.py
new file mode 100644
index 0000000000..b4c9dd1c59
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/regression/estimation.py
@@ -0,0 +1,134 @@
+
+
+"""
+
+The MultiSpectral Imaging Toolkit (MSITK)
+
+Copyright (c) German Cancer Research Center,
+Computer Assisted Interventions.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE for details
+
+"""
+'''
+Created on Oct 21, 2015
+
+@author: wirkert
+'''
+
+import math
+import logging
+import time
+
+import tensorflow as tf
+import numpy as np
+import SimpleITK as sitk
+
+from regression.tensorflow_estimator import multilayer_perceptron, cnn
+import msi.imgmani as imgmani
+
+
+def SAMDistance(x, y):
+ return math.acos(np.dot(x, y) / (np.linalg.norm(x) * np.linalg.norm(y)))
+
+
+def estimate_image(msi, regressor):
+ """given an Msi and an regressor estimate the parmaeters for this image
+
+ Paramters:
+ msi: multi spectral image
+ regressor: regressor, must implement the predict method"""
+
+ # estimate parameters
+ collapsed_msi = imgmani.collapse_image(msi.get_image())
+ # in case of nan values: set to 0
+ collapsed_msi[np.isnan(collapsed_msi)] = 0.
+ collapsed_msi[np.isinf(collapsed_msi)] = 0.
+
+ start = time.time()
+ estimated_parameters = regressor.predict(collapsed_msi)
+ end = time.time()
+ estimation_time = end - start
+ logging.info("time necessary for estimating image parameters: " +
+ str(estimation_time) + "s")
+ # restore shape
+ feature_dimension = 1
+ if len(estimated_parameters.shape) > 1:
+ feature_dimension = estimated_parameters.shape[-1]
+
+ estimated_paramters_as_image = np.reshape(
+ estimated_parameters, (msi.get_image().shape[0],
+ msi.get_image().shape[1],
+ feature_dimension))
+ # save as sitk nrrd.
+ sitk_img = sitk.GetImageFromArray(estimated_paramters_as_image,
+ isVector=True)
+ return sitk_img, estimation_time
+
+
+def estimate_image_tensorflow(msi, model_checkpoint_dir):
+ # estimate parameters
+ collapsed_msi = imgmani.collapse_image(msi.get_image())
+ # in case of nan values: set to 0
+ collapsed_msi[np.isnan(collapsed_msi)] = 0.
+ collapsed_msi[np.isinf(collapsed_msi)] = 0.
+
+
+ tf.reset_default_graph()
+
+ keep_prob = tf.placeholder("float")
+ nr_wavelengths = len(msi.get_wavelengths())
+ x = tf.placeholder("float", [None, nr_wavelengths, 1, 1])
+
+ x_test_image = np.reshape(msi.get_image(), [-1, nr_wavelengths, 1, 1])
+
+ # Construct the desired model
+ # pred, regularizers = multilayer_perceptron(x, nr_wavelengths, 100, 1,
+ # keep_prob)
+ pred = cnn(x, 1, keep_prob)
+
+ # Initializing the variables
+ init = tf.initialize_all_variables()
+
+ saver = tf.train.Saver()
+
+ with tf.Session() as sess:
+ sess.run(tf.initialize_all_variables())
+ # restore model:
+ ckpt = tf.train.get_checkpoint_state(model_checkpoint_dir)
+
+ if ckpt and ckpt.model_checkpoint_path:
+ saver.restore(sess, ckpt.model_checkpoint_path)
+
+ start = time.time()
+ estimated_parameters = pred.eval({x: x_test_image,
+ keep_prob:1.0})
+ end = time.time()
+ estimation_time = end - start
+ logging.info("time necessary for estimating image parameters: " +
+ str(estimation_time) + "s")
+ # restore shape
+ feature_dimension = 1
+ if len(estimated_parameters.shape) > 1:
+ feature_dimension = estimated_parameters.shape[-1]
+
+ estimated_paramters_as_image = np.reshape(
+ estimated_parameters, (msi.get_image().shape[0],
+ msi.get_image().shape[1],
+ feature_dimension))
+ # save as sitk nrrd.
+ sitk_img = sitk.GetImageFromArray(estimated_paramters_as_image,
+ isVector=True)
+
+ return sitk_img, estimation_time
+
+
+def standard_score(estimator, X, y):
+ """our standard scoring method is the median absolute error"""
+ return np.median(np.abs(estimator.predict(X) - y))
+
diff --git a/Modules/Biophotonics/python/iMC/regression/linear.py b/Modules/Biophotonics/python/iMC/regression/linear.py
new file mode 100644
index 0000000000..dcd96977a7
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/regression/linear.py
@@ -0,0 +1,95 @@
+'''
+Created on Oct 19, 2015
+
+@author: wirkert
+'''
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+from mc.usuag import get_haemoglobin_extinction_coefficients
+
+class LinearSaO2Unmixing(object):
+ '''
+ classdocs
+ '''
+
+ def __init__(self):
+ # oxygenated haemoglobin extinction coefficients
+ eHb02 = 0
+ eHb = 0
+
+ # oxygenated haemoglobin extinction coefficients
+ eHbO2 = np.array([34772.8,
+ 27840.93333,
+ 23748.8 ,
+ 21550.8 ,
+ 21723.46667,
+ 28064.8 ,
+ 39131.73333,
+ 45402.93333,
+ 42955.06667,
+ 40041.73333,
+ 42404.4 ,
+ 36333.6 ,
+ 22568.26667,
+ 6368.933333,
+ 1882.666667,
+ 1019.333333,
+ 664.6666667,
+ 473.3333333,
+ 376.5333333,
+ 327.2 ,
+ 297.0666667],)
+ # deoxygenated haemoglobin extinction coefficients
+ eHb = [18031.73333 ,
+ 15796.8 ,
+ 17365.33333 ,
+ 21106.53333 ,
+ 26075.06667 ,
+ 32133.2 ,
+ 39072.66667 ,
+ 46346.8 ,
+ 51264 ,
+ 50757.33333 ,
+ 45293.33333 ,
+ 36805.46667 ,
+ 26673.86667 ,
+ 17481.73333 ,
+ 10210.13333 ,
+ 7034 ,
+ 5334.533333 ,
+ 4414.706667 ,
+ 3773.96 ,
+ 3257.266667 ,
+ 2809.866667]
+ nr_total_wavelengths = len(eHb)
+ # to account for scattering losses we allow a constant offset
+ scattering = np.ones(nr_total_wavelengths)
+ # put eHbO2, eHb and scattering term in one measurement matrix
+ self.H = np.vstack((eHbO2, eHb, scattering)).T
+ self.lsq_solution_matrix = np.dot(np.linalg.inv(np.dot(self.H.T,
+ self.H)),
+ self.H.T)
+
+
+ def fit(self, X, y, weights=None):
+ """only implemented to fit to the standard sklearn framework."""
+ pass
+
+ def predict(self, X):
+ """predict like in sklearn:
+
+ Parameters:
+ X: nrsamples x nr_features matrix of samples to predict for
+ regression
+
+ Returns:
+ y: array of shape [nr_samples] with values for predicted
+ oxygenation """
+ # do least squares estimation
+ oxy_test, deoxy, s = np.dot(self.lsq_solution_matrix, X.T)
+ # calculate oxygenation = oxygenated blood / total blood
+ saO2 = oxy_test / (oxy_test + deoxy)
+
+ return np.clip(saO2, 0., 1.)
diff --git a/Modules/Biophotonics/python/iMC/regression/preprocessing.py b/Modules/Biophotonics/python/iMC/regression/preprocessing.py
new file mode 100644
index 0000000000..494f7a82db
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/regression/preprocessing.py
@@ -0,0 +1,94 @@
+'''
+Created on Oct 26, 2015
+
+@author: wirkert
+'''
+
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import Normalizer
+
+
+def preprocess2(df, nr_samples=None, snr=None, movement_noise_sigma=None,
+ magnification=None, bands_to_sortout=None):
+
+ # first set 0 reflectances to nan
+ df["reflectances"] = df["reflectances"].replace(to_replace=0.,
+ value=np.nan)
+ # remove nan
+ df.dropna(inplace=True)
+
+ # extract nr_samples samples from data
+ if nr_samples is not None:
+ df = df.sample(nr_samples)
+
+ # get reflectance and oxygenation
+ X = df.reflectances
+ if bands_to_sortout is not None and bands_to_sortout.size > 0:
+ X.drop(X.columns[bands_to_sortout], axis=1, inplace=True)
+ snr = np.delete(snr, bands_to_sortout)
+ X = X.values
+ y = df.layer0[["sao2", "vhb"]]
+
+ # do data magnification
+ if magnification is not None:
+ X_temp = X
+ y_temp = y
+ for i in range(magnification - 1):
+ X = np.vstack((X, X_temp))
+ y = pd.concat([y, y_temp])
+
+ # add noise to reflectances
+ camera_noise = 0.
+ if snr is not None:
+ sigmas = X / snr
+ noises = np.random.normal(loc=0., scale=1, size=X.shape)
+ camera_noise = sigmas*noises
+
+ movement_noise = 0.
+ if movement_noise_sigma is not None:
+ nr_bands = X.shape[1]
+ nr_samples = X.shape[0]
+ # we assume no correlation between neighboring bands
+ CORRELATION_COEFFICIENT = 0.0
+ movement_variance = movement_noise_sigma ** 2
+ movement_variances = np.ones(nr_bands) * movement_variance
+ movement_covariances = np.ones(nr_bands-1) * CORRELATION_COEFFICIENT * \
+ movement_variance
+ movement_covariance_matrix = np.diag(movement_variances) + \
+ np.diag(movement_covariances, -1) + \
+ np.diag(movement_covariances, 1)
+ # percentual sample errors
+ sample_errors_p = np.random.multivariate_normal(mean=np.zeros(nr_bands),
+ cov=movement_covariance_matrix,
+ size=nr_samples)
+ # errors w.r.t. the curve height.
+ movement_noise = X * sample_errors_p
+
+ X += camera_noise + movement_noise
+
+ X = np.clip(X, 0.00001, 1.)
+ # do normalizations
+ X = normalize(X)
+ return X, y
+
+
+def preprocess(batch, nr_samples=None, snr=None, movement_noise_sigma=None,
+ magnification=None, bands_to_sortout=None):
+ X, y = preprocess2(batch, nr_samples, snr, movement_noise_sigma,
+ magnification, bands_to_sortout)
+
+ return X, y["sao2"]
+
+
+def normalize(X):
+ # normalize reflectances
+ normalizer = Normalizer(norm='l1')
+ X = normalizer.transform(X)
+ # reflectances to absorption
+ absorptions = -np.log(X)
+ X = absorptions
+ # get rid of sorted out bands
+ normalizer = Normalizer(norm='l2')
+ X = normalizer.transform(X)
+ return X
diff --git a/Modules/Biophotonics/python/iMC/regression/tensorflow_dataset.py b/Modules/Biophotonics/python/iMC/regression/tensorflow_dataset.py
new file mode 100644
index 0000000000..4bc2065aac
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/regression/tensorflow_dataset.py
@@ -0,0 +1,83 @@
+"""Functions for downloading and reading ipcai data."""
+from __future__ import print_function
+
+import os
+
+import numpy
+import pandas as pd
+
+from regression.preprocessing import preprocess
+
+
+class DataSet(object):
+ def __init__(self, images, labels, fake_data=False):
+ if fake_data:
+ self._num_examples = 10000
+ else:
+ assert images.shape[0] == labels.shape[0], (
+ "images.shape: %s labels.shape: %s" % (images.shape,
+ labels.shape))
+ self._num_examples = images.shape[0]
+ images = images.astype(numpy.float32)
+ self._images = images
+ self._labels = labels
+ if self._labels.ndim == 1:
+ self._labels = self._labels[:, numpy.newaxis]
+ self._epochs_completed = 0
+ self._index_in_epoch = 0
+
+ @property
+ def images(self):
+ return self._images
+
+ @property
+ def labels(self):
+ return self._labels
+
+ @property
+ def num_examples(self):
+ return self._num_examples
+
+ @property
+ def epochs_completed(self):
+ return self._epochs_completed
+
+ def next_batch(self, batch_size, fake_data=False):
+ """Return the next `batch_size` examples from this data set."""
+ if fake_data:
+ fake_image = [1.0 for _ in xrange(784)]
+ fake_label = 0
+ return [fake_image for _ in xrange(batch_size)], [
+ fake_label for _ in xrange(batch_size)]
+ start = self._index_in_epoch
+ self._index_in_epoch += batch_size
+ if self._index_in_epoch > self._num_examples:
+ # Finished epoch
+ self._epochs_completed += 1
+ # Shuffle the data
+ perm = numpy.arange(self._num_examples)
+ numpy.random.shuffle(perm)
+ self._images = self._images[perm]
+ self._labels = self._labels[perm]
+
+ # Start next epoch
+ start = 0
+ self._index_in_epoch = batch_size
+ assert batch_size <= self._num_examples
+ end = self._index_in_epoch
+ return self._images[start:end], self._labels[start:end]
+
+
+def read_data_set(dataframe_filename, fake_data=False):
+
+ if fake_data:
+ data_set = DataSet([], [], fake_data=True)
+ return data_set
+
+ df_data_set = pd.read_csv(os.path.join(dir, dataframe_filename),
+ header=[0, 1])
+
+ data_set_images, data_set_labels = preprocess(df_data_set, snr=10.)
+ data_set_labels = data_set_labels.values
+ data_set = DataSet(data_set_images, data_set_labels)
+ return data_set
diff --git a/Modules/Biophotonics/python/iMC/regression/tensorflow_estimator.py b/Modules/Biophotonics/python/iMC/regression/tensorflow_estimator.py
new file mode 100644
index 0000000000..b5025563ec
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/regression/tensorflow_estimator.py
@@ -0,0 +1,88 @@
+
+
+import tensorflow as tf
+
+
+def weight_variable(shape):
+ initial = tf.truncated_normal(shape, stddev=0.1)
+ return tf.Variable(initial)
+
+
+def bias_variable(shape):
+ initial = tf.constant(0.1, shape=shape)
+ return tf.Variable(initial)
+
+
+def conv2d(x, W, padding='SAME'):
+ return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding=padding)
+
+
+def max_pool1d(x, poolsize=2):
+ return tf.nn.max_pool(x, ksize=[1, poolsize, 1, 1],
+ strides=[1, poolsize, 1, 1], padding='SAME')
+
+
+def add_cnn_layer(input, n_inputs, n_outputs, kernel_size, padding='SAME'):
+ #w = weight_variable([n_inputs, n_outputs])
+ #b = bias_variable([n_outputs])
+ W = weight_variable([kernel_size, 1, n_inputs, n_outputs])
+ b = bias_variable([n_outputs])
+ # Hidden layer with RELU activation
+ #new_layer = tf.nn.relu(tf.add(tf.matmul(input, w), b))
+ h_conv = tf.nn.relu(conv2d(input, W, padding=padding) + b)
+ # Add dropout regularization
+ #new_layer_with_dropout = tf.nn.dropout(new_layer, keep_prob)
+ h_pool = max_pool1d(h_conv)
+ return h_pool, W
+
+
+def add_fully_connected_layer(_X, n_inputs, n_outputs, keep_prob):
+ W = weight_variable([n_inputs, n_outputs])
+ b = bias_variable([n_outputs])
+ # Hidden layer with RELU activation
+ new_layer = tf.nn.relu(tf.add(tf.matmul(_X, W), b))
+ # Add dropout regularization
+ new_layer_with_dropout = tf.nn.dropout(new_layer, keep_prob)
+
+ return new_layer_with_dropout, W
+
+
+# this is my exemplary convolutional network
+def cnn(_X, n_classes, keep_prob):
+ # two convolutional layers
+ layer_1, _ = add_cnn_layer(_X, 1, 32, 3, padding='VALID')
+ layer_2, _ = add_cnn_layer(layer_1, 32, 32, 2, padding='VALID')
+ # flatten last one to be able to apply it to fully connected layer
+ final_number_of_dimensions = 1*32
+ layer_2_flat = tf.reshape(layer_2, [-1, final_number_of_dimensions])
+
+ # fully connected layer to bring information together
+ fc_dim = 5
+ h_fc1_drop, _ = add_fully_connected_layer(layer_2_flat,
+ final_number_of_dimensions,
+ fc_dim, keep_prob)
+
+ # return linear output layer
+ W_fc2 = weight_variable([fc_dim, n_classes])
+ b_fc2 = bias_variable([n_classes])
+ return tf.matmul(h_fc1_drop, W_fc2) + b_fc2
+
+
+# and this is the simpler multilayer perceptron
+def multilayer_perceptron(x, n_bands, n_hidden, n_classes, keep_prob):
+ flattend_input = tf.reshape(x, [-1, n_bands])
+ layer_1, W_1 = add_fully_connected_layer(flattend_input, n_bands, n_hidden,
+ keep_prob)
+ layer_2, W_2 = add_fully_connected_layer(layer_1, n_hidden, n_hidden,
+ keep_prob)
+ last_hidden_layer, W_3 = add_fully_connected_layer(layer_2, n_hidden, n_hidden,
+ keep_prob)
+
+ W_out = weight_variable([n_hidden, n_classes])
+ b_out = bias_variable([n_classes])
+
+ regularizers = (tf.nn.l2_loss(W_1) + tf.nn.l2_loss(W_2) +
+ tf.nn.l2_loss(W_3) + tf.nn.l2_loss(W_out))
+
+ return tf.matmul(last_hidden_layer, W_out) + b_out, regularizers
+
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/tests/__init__.py b/Modules/Biophotonics/python/iMC/scripts/basic_checks/__init__.py
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/tests/__init__.py
rename to Modules/Biophotonics/python/iMC/scripts/basic_checks/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/basic_checks/script_evaluate_color_checkerboard.py b/Modules/Biophotonics/python/iMC/scripts/basic_checks/script_evaluate_color_checkerboard.py
new file mode 100644
index 0000000000..fcf5bea72e
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/basic_checks/script_evaluate_color_checkerboard.py
@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 14 11:09:18 2015
+
+@author: wirkert
+"""
+
+
+import Image
+import ImageEnhance
+import logging
+import datetime
+import copy
+
+from scipy.interpolate import interp1d
+from sklearn.preprocessing import normalize
+from sklearn.metrics import r2_score
+
+from msi.io.nrrdreader import NrrdReader
+import msi.normalize as norm
+from ipcai2016.tasks_common import *
+import commons
+from ipcai2016 import tasks_mc
+import msi.plot as msiplot
+from msi.io.spectrometerreader import SpectrometerReader
+from msi.normalize import standard_normalizer
+from msi.io.tiffringreader import TiffRingReader
+
+TiffRingReader.RESIZE_FACTOR = 0.5
+
+sc = commons.ScriptCommons()
+
+sc.add_dir("COLORCHECKER_DATA",
+ os.path.join(sc.get_dir("DATA_FOLDER"), "colorchecker_laparoscope"))
+
+sc.add_dir("COLORCHECKER_RESULTS",
+ os.path.join(sc.get_dir("RESULTS_FOLDER"),
+ "colorchecker_laparoscope"))
+
+sc.add_dir("FLAT_FOLDER",
+ os.path.join(sc.get_dir("DATA_FOLDER"),
+ "colorchecker_laparoscope_flatfield"))
+
+sc.add_dir("SPECTROMETER_REFERENCE_DATA",
+ os.path.join(sc.get_dir("DATA_FOLDER"),
+ "spectrometer_reflectance_new"))
+
+sc.add_dir("FILTER_TRANSMISSIONS",
+ os.path.join(sc.get_dir("DATA_FOLDER"),
+ "filter_transmissions"))
+
+
+class CheckColorCheckerBoards(luigi.Task):
+ image_name = luigi.Parameter()
+
+ def requires(self):
+ return Flatfield(flatfield_folder=sc.get_full_dir("FLAT_FOLDER")), \
+ SingleMultispectralImage(image=self.image_name), \
+ Dark(dark_folder=sc.get_full_dir("DARK_FOLDER")), \
+ SpectrometerToSpectrocam(spectrometer_measurement=
+ os.path.join(sc.get_full_dir("SPECTROMETER_REFERENCE_DATA"),
+ os.path.split(self.image_name)[1][0:8] + ".txt"))
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("COLORCHECKER_RESULTS"),
+ os.path.split(self.image_name)[1] +
+ "_" + "_color_check" + ".png"))
+
+ def run(self):
+
+ print "... read data"
+
+ segmentation_file = os.path.join(
+ sc.get_full_dir("COLORCHECKER_DATA"), "seg.tiff")
+ segmentation_file2 = os.path.join(
+ sc.get_full_dir("COLORCHECKER_DATA"), "seg2.tiff")
+
+ nrrd_reader = NrrdReader()
+ tiff_ring_reader = TiffRingReader()
+ # read the flatfield
+ flat = nrrd_reader.read(self.input()[0].path)
+ dark = nrrd_reader.read(self.input()[2].path)
+ # read the msi
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+ msi, segmentation = tiff_ring_reader.read(self.input()[1].path,
+ nr_filters,
+ segmentation=segmentation_file)
+ msi_copy = copy.deepcopy(msi) # copy to be able to apply both
+ # segmentations
+ msimani.apply_segmentation(msi, segmentation)
+ msi2, segmentation2 = tiff_ring_reader.read(self.input()[1].path,
+ nr_filters,
+ segmentation=segmentation_file2)
+ msimani.apply_segmentation(msi2, segmentation2)
+
+ msimani.apply_segmentation(msi_copy, segmentation + segmentation2)
+
+ # read the spectrometer measurement
+ msi_spectrometer = nrrd_reader.read(self.input()[3].path)
+
+ # correct by flatfield and dark image
+ #msimani.image_correction(msi, flat, dark)
+ #msimani.image_correction(msi2, flat, dark)
+ #msimani.image_correction(msi_copy, flat, dark)
+ msimani.dark_correction(msi, dark)
+ msimani.dark_correction(msi2, dark)
+ msimani.dark_correction(msi_copy, dark)
+
+ # create artificial rgb
+ rgb_image = msi_copy.get_image()[:, :, [2, 3, 1]]
+ rgb_image /= np.max(rgb_image)
+ rgb_image *= 255.
+
+ # preprocess the image
+ # sortout unwanted bands
+ print "... apply normalizations"
+ # normalize to get rid of lighting intensity
+ norm.standard_normalizer.normalize(msi)
+ norm.standard_normalizer.normalize(msi2)
+
+ print "... plot"
+
+ # plot of the rgb image
+ rgb_image = rgb_image.astype(np.uint8)
+ im = Image.fromarray(rgb_image, 'RGB')
+ enh_brightness = ImageEnhance.Brightness(im)
+ im = enh_brightness.enhance(2.)
+ plotted_image = np.array(im)
+
+ plt.figure()
+ f, (ax_rgb, ax_spectra) = plt.subplots(1, 2)
+ plot_image(plotted_image, ax_rgb, title="false rgb")
+
+ msiplot.plotMeanError(msi, ax_spectra)
+ msiplot.plotMeanError(msi2, ax_spectra)
+
+ standard_normalizer.normalize(msi_spectrometer)
+ msiplot.plot(msi_spectrometer, ax_spectra)
+
+ mean_spectrometer = msi_spectrometer.get_image()
+ mean_msi = msimani.calculate_mean_spectrum(msi).get_image()
+ mean_msi2 = msimani.calculate_mean_spectrum(msi2).get_image()
+ r2_msi = r2_score(mean_spectrometer, mean_msi)
+ r2_msi2 = r2_score(mean_spectrometer, mean_msi2)
+
+ ax_spectra.legend(["spectrocam 1 r2: " + str(r2_msi),
+ "spectrocam 2 r2: " + str(r2_msi2), "spectrometer"],
+ bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
+ ncol=2, mode="expand", borderaxespad=0.,
+ fontsize=5)
+
+ plt.savefig(self.output().path,
+ dpi=250, bbox_inches='tight')
+
+
+class CameraQEFile(luigi.Task):
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("DATA_FOLDER"),
+ "camera_quantum_efficiency.csv"))
+
+
+class SpectrometerToSpectrocam(luigi.Task):
+
+ spectrometer_measurement = luigi.Parameter()
+
+ def requires(self):
+ # all wavelengths must have been measured for transmission and stored in
+ # wavelength.txt files (e.g. 470.txt)
+ filenames = ((sc.other["RECORDED_WAVELENGTHS"] * 10**9).astype(int)).astype(str)
+ filenames = map(lambda name: tasks_mc.FilterTransmission(os.path.join(sc.get_full_dir("FILTER_TRANSMISSIONS"),
+ name) + ".txt"),
+ filenames)
+
+ return tasks_mc.SpectrometerFile(self.spectrometer_measurement), \
+ filenames, CameraQEFile()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ os.path.split(self.spectrometer_measurement)[1] +
+ "_spectrocam.nrrd"))
+
+ def run(self):
+ # load spectrometer measurement
+ spectrometer_reader = SpectrometerReader()
+ spectrometer_msi = spectrometer_reader.read(self.input()[0].path)
+
+ # the wavelengths recorded by the spectrometer
+ spectrometer_wavelengths = spectrometer_msi.get_wavelengths()
+
+ spectrometer_white = spectrometer_reader.read(os.path.join(
+ sc.get_full_dir("DATA_FOLDER"), "spectrometer_whitebalance",
+ "white_IL_1_OO_20ms.txt"))
+ spectrometer_dark = spectrometer_reader.read(os.path.join(
+ sc.get_full_dir("DATA_FOLDER"), "spectrometer_whitebalance",
+ "dark_1_OO_20ms.txt"))
+ msimani.dark_correction(spectrometer_white, spectrometer_dark)
+ white_interpolator = interp1d(spectrometer_white.get_wavelengths(),
+ spectrometer_white.get_image(),
+ bounds_error=False, fill_value=0.)
+ white_interpolated = white_interpolator(spectrometer_wavelengths)
+
+ camera_qe = pd.read_csv(self.input()[2].path)
+ camera_qe_interpolator = interp1d(camera_qe["wavelengths"] * 10**-9,
+ camera_qe["quantum efficiency"],
+ bounds_error=False,
+ fill_value=0.)
+ camera_qe_interpolated = \
+ camera_qe_interpolator(spectrometer_wavelengths)
+
+ # camera batch creation:
+ new_reflectances = []
+ for band in self.input()[1]:
+ df_filter = pd.read_csv(band.path)
+ interpolator = interp1d(df_filter["wavelengths"],
+ df_filter["reflectances"],
+ assume_sorted=False, bounds_error=False)
+ # use this to create new reflectances
+ interpolated_filter = interpolator(spectrometer_wavelengths)
+ # if a wavelength cannot be interpolated, set it to 0
+ interpolated_filter = np.nan_to_num(interpolated_filter)
+ # account for cameras quantum efficiency
+ interpolated_filter *= camera_qe_interpolated * white_interpolated
+ # normalize band response
+ #normalize(interpolated_filter.reshape(1, -1), norm='l1', copy=False)
+ folded_reflectance = np.dot(spectrometer_msi.get_image(),
+ interpolated_filter)
+ new_reflectances.append(folded_reflectance)
+ plt.plot(interpolated_filter)
+ new_reflectances = np.array(new_reflectances).T
+ spectrometer_msi.set_image(new_reflectances,
+ wavelengths=sc.other["RECORDED_WAVELENGTHS"])
+
+ # write it
+ nrrd_writer = NrrdWriter(spectrometer_msi)
+ nrrd_writer.write(self.output().path)
+
+if __name__ == '__main__':
+
+ # create a folder for the results if necessary
+ sc.set_root("/media/wirkert/data/Data/2020_Current_Works/")
+ sc.create_folders()
+
+ # root folder there the data lies
+ logging.basicConfig(filename=os.path.join(sc.get_full_dir("LOG_FOLDER"),
+ "color_checker" +
+ str(datetime.datetime.now()) +
+ '.log'), level=logging.INFO)
+ luigi.interface.setup_interface_logging()
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+
+ files = get_image_files_from_folder(sc.get_full_dir("COLORCHECKER_DATA"),
+ suffix="F0.tiff", fullpath=True)
+
+ for f in files:
+ main_task = CheckColorCheckerBoards(image_name=f)
+ w.add(main_task)
+
+ w.run()
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/commons.py b/Modules/Biophotonics/python/iMC/scripts/commons.py
new file mode 100644
index 0000000000..48e060132c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/commons.py
@@ -0,0 +1,97 @@
+"""
+This file contains a singleton class which manages the paths set for evaluating
+the scripts.
+
+Also it contains some utility methods.
+"""
+
+import os
+
+import numpy as np
+
+
+class ScriptCommons(object):
+ """
+ The commonly shared paths to the data/log/results... folders.
+ + additional commonly available data as recorded wavelengths
+ this is a singleton pattern copied from
+ http://python-3-patterns-idioms-test.readthedocs.org/en/latest/Singleton.html
+ """
+
+ class __ScriptCommons_Singleton:
+
+ def __init__(self):
+
+ self.root = os.path.join("..", "..")
+
+ self.dirs = {"LOG_FOLDER": "log",
+ "DATA_FOLDER": "data",
+ "RESULTS_FOLDER": "results"}
+
+ self.dirs["FLAT_FOLDER"] = os.path.join(self.dirs["DATA_FOLDER"],
+ "flatfields")
+ self.dirs["DARK_FOLDER"] = os.path.join(self.dirs["DATA_FOLDER"],
+ "dark")
+
+ self.dirs["INTERMEDIATES_FOLDER"] = os.path.join(
+ self.dirs["RESULTS_FOLDER"], "intermediate")
+
+ self.dirs["MC_DATA_FOLDER"] = os.path.join(
+ self.dirs["INTERMEDIATES_FOLDER"], "mc_data")
+
+ self.other = {"RECORDED_WAVELENGTHS": np.array([580, 470,
+ 660, 560,
+ 480, 511,
+ 600, 700])
+ * 10 ** -9}
+
+ def create_folders(self):
+ """
+ Create all folders listed in self.folders if not existing
+ """
+ for f in self.dirs:
+ create_folder_if_necessary(self.get_full_dir(f))
+
+ def set_root(self, root):
+ self.root = root
+
+ def get_root(self):
+ return self.root
+
+ def add_dir(self, key, new_dir):
+ """
+ Add/replace a directory to the singletons list.
+ Directories can be returned with get_dir and with their full path by
+ calling get_full_dir
+
+ :param key: the key under which it shall be retrievable
+ :param new_dir: the directory to add to the list
+ """
+ self.dirs[key] = new_dir
+
+ def get_dir(self, key):
+ return self.dirs[key]
+
+ def get_full_dir(self, key):
+ return os.path.join(self.get_root(), self.get_dir(key))
+
+ instance = None
+
+ def __new__(cls): # __new__ always a classmethod
+ if not ScriptCommons.instance:
+ ScriptCommons.instance = ScriptCommons.__ScriptCommons_Singleton()
+ return ScriptCommons.instance
+
+ def __getattr__(self, name):
+ return getattr(self.instance, name)
+
+ def __setattr__(self, name):
+ return setattr(self.instance, name)
+
+
+def create_folder_if_necessary(folder):
+ """
+ :param folder: create the folder folder if necessary (not already existing)
+ """
+ if not os.path.exists(folder):
+ os.makedirs(folder)
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/__init__.py
similarity index 100%
copy from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
copy to Modules/Biophotonics/python/iMC/scripts/domain_adaptation/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/domain_adaptation_paths.py b/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/domain_adaptation_paths.py
new file mode 100644
index 0000000000..23660eb1f1
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/domain_adaptation_paths.py
@@ -0,0 +1,18 @@
+
+
+import os
+
+ROOT_FOLDER = "/media/wirkert/data/Data/2016_03_Domain_Adaptation"
+LOG_FOLDER = os.path.join(ROOT_FOLDER, "log")
+DATA_FOLDER = os.path.join(ROOT_FOLDER, "data")
+RESULTS_FOLDER = os.path.join(ROOT_FOLDER, "results")
+INTERMEDIATES_FOLDER = os.path.join(RESULTS_FOLDER, "intermediate")
+MC_DATA_FOLDER = os.path.join(INTERMEDIATES_FOLDER, "mc_data")
+
+
+def create_folder_if_necessary(folder):
+ if not os.path.exists(folder):
+ os.makedirs(folder)
+
+create_folder_if_necessary(INTERMEDIATES_FOLDER)
+create_folder_if_necessary(LOG_FOLDER)
diff --git a/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/script_analyze_da_in_silico.py b/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/script_analyze_da_in_silico.py
new file mode 100644
index 0000000000..f8d486e90a
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/domain_adaptation/script_analyze_da_in_silico.py
@@ -0,0 +1,364 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 14 11:09:18 2015
+
+@author: wirkert
+"""
+
+import os
+import logging
+import datetime
+
+import numpy as np
+import pandas as pd
+import luigi
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from regression.preprocessing import preprocess
+import domain_adaptation_paths as sp
+from ipcai2016 import tasks_mc
+from ipcai2016.script_analyze_ipcai_in_silico import w_standard, noise_levels, \
+ evaluate_data, standard_plotting, NoisePlot
+# additionally we need the weights estimation functionality
+from regression.domain_adaptation import estimate_weights_random_forests
+
+
+class WeightedBatch(luigi.Task):
+ which_source = luigi.Parameter()
+ which_target = luigi.Parameter()
+ noise = luigi.FloatParameter()
+
+ def requires(self):
+ return tasks_mc.CameraBatch(self.which_source), \
+ tasks_mc.CameraBatch(self.which_target)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sp.ROOT_FOLDER,
+ sp.RESULTS_FOLDER,
+ "adapted_" +
+ self.which_source +
+ "_with_" + self.which_target +
+ "_noise_" + str(self.noise) +
+ ".txt"))
+
+ def run(self):
+ # get data
+ df_source = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_target = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ # first extract X_source and X_target, preprocessed at standard noise
+ # level
+ X_source, y_source = preprocess(df_source, w_percent=w_standard)
+ X_target, y_target = preprocess(df_target, w_percent=w_standard)
+
+ # train a classifier to determine probability for specific class
+ weights = estimate_weights_random_forests(X_source, X_target, X_source)
+ # add weight to dataframe
+ df_source["weights"] = weights
+
+ # finally save the dataframe with the added weights
+ df_source.to_csv(self.output().path, index=False)
+
+
+class DaNoisePlot(luigi.Task):
+ """
+ Very similar to NoisePlot in IPCAI in silico evaluation but with
+ weighted data coming in.
+ """
+ which_train = luigi.Parameter()
+ which_test = luigi.Parameter()
+
+ def requires(self):
+ # for each noise level we need to create the weights
+ NecessaryBatches = map(lambda noise: WeightedBatch(self.which_train,
+ self.which_test,
+ noise),
+ noise_levels)
+ return NecessaryBatches(self.which_train, self.which_test), \
+ tasks_mc.CameraBatch(self.which_test)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sp.ROOT_FOLDER,
+ sp.RESULTS_FOLDER,
+ sp.FINALS_FOLDER,
+ "noise_da_plot_train_" +
+ self.which_train +
+ "_test_" + self.which_test +
+ ".png"))
+
+ def run(self):
+ # get data
+ df_train = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_test = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ df = evaluate_data(df_train, noise_levels, df_test, noise_levels)
+ standard_plotting(df)
+
+ # finally save the figure
+ plt.savefig(self.output().path, dpi=500,
+ bbox_inches='tight')
+
+
+class GeneratingDistributionPlot(luigi.Task):
+ which_source = luigi.Parameter()
+ which_target = luigi.Parameter()
+
+ def requires(self):
+ return WeightedBatch(self.which_source, self.which_target), \
+ tasks_mc.CameraBatch(self.which_target)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sp.ROOT_FOLDER,
+ sp.RESULTS_FOLDER,
+ sp.FINALS_FOLDER,
+ "generating_distribution_" +
+ self.which_source +
+ "_adapted_to_" +
+ self.which_target +
+ ".png"))
+
+ def run(self):
+ # get data
+ df_source = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_target = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ # create dataframe suited for plotting
+ # we do a weighted sampling with replacement to be able to create some
+ # plots there the data distribution is visible.
+ nr_samples = 100
+ # first data weighted by domain adaptation
+ df_source_adapted = df_source["layer0"].copy()
+ df_source_adapted["weights"] = df_source["weights"]
+ df_source_adapted["data"] = "adapted"
+ df_source_adapted = df_source_adapted.sample(n=nr_samples, replace=True,
+ weights="weights")
+ # now original source data
+ df_source = df_source["layer0"].copy()
+ df_source["weights"] = 1 # we set the weights here to 1
+ df_source["data"] = "source"
+ df_source = df_source.sample(n=nr_samples, replace=True,
+ weights="weights")
+ # now the target data
+ df_target = df_target["layer0"]
+ df_target["weights"] = 1
+ df_target["data"] = "target"
+ df_target = df_target.sample(n=nr_samples, replace=True,
+ weights="weights")
+ # now merge all three dataframes to the dataframe used for the plotting
+ df = pd.concat([df_source, df_source_adapted, df_target])
+ # since we already sampled we can get rid of weights
+ df.drop("weights", axis=1, inplace=True)
+ # d to um
+ df["d"] *= 10**6
+ # vhb and sao2 to %
+ df["vhb"] *= 100
+ df["sao2"] *= 100
+
+ # do some serious plotting
+ g = sns.pairplot(df, vars=["vhb", "sao2", "d"],
+ hue="data", markers=["o", "s", "D"])
+
+ # tidy up plot
+ g.add_legend()
+
+ # finally save the figure
+ plt.savefig(self.output().path, dpi=500,
+ bbox_inches='tight')
+
+
+class WeightDistributionPlot(luigi.Task):
+ which_source = luigi.Parameter()
+ which_target = luigi.Parameter()
+
+ def requires(self):
+ return WeightedBatch(self.which_source, self.which_target)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sp.ROOT_FOLDER,
+ sp.RESULTS_FOLDER,
+ sp.FINALS_FOLDER,
+ "weight_distribution_" +
+ self.which_source +
+ "_adapted_to_" +
+ self.which_target +
+ ".png"))
+
+ def run(self):
+ # get data
+ df_source = pd.read_csv(self.input().path, header=[0, 1])
+
+ df_source["weights"].plot.hist(bins=100)
+ plt.axvline(x=1, ymin=0, ymax=df_source.shape[0])
+ # TODO: add cumsum on top
+
+ # finally save the figure
+ plt.savefig(self.output().path, dpi=500,
+ bbox_inches='tight')
+
+
+class FeatureDistributionPlot(luigi.Task):
+ which_source = luigi.Parameter()
+ which_target = luigi.Parameter()
+
+ def requires(self):
+ return WeightedBatch(self.which_source, self.which_target), \
+ tasks_mc.CameraBatch(self.which_target)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sp.ROOT_FOLDER,
+ sp.RESULTS_FOLDER,
+ sp.FINALS_FOLDER,
+ "feature_distribution_" +
+ self.which_source +
+ "_adapted_to_" +
+ self.which_target +
+ ".png"))
+
+ def run(self):
+ # get data
+ df_source = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_target = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ df_f_source = format_dataframe_for_distribution_plotting(df_source)
+ df_f_target = format_dataframe_for_distribution_plotting(df_target)
+ df_f_adapted = format_dataframe_for_distribution_plotting(df_source,
+ weights=df_source["weights"].values.squeeze())
+
+ # build a combined df
+ df_f_source["data"] = "source"
+ df_f_target["data"] = "target"
+ df_f_adapted["data"] = "adapted"
+ df = pd.concat([df_f_source, df_f_target, df_f_adapted])
+
+ # do the plotting
+ grid = sns.FacetGrid(df, col="w", hue="data", col_wrap=3, size=1.5)
+ grid.map(plt.plot, "bins", "frequency")
+
+ # tidy up plot
+ grid.fig.tight_layout(w_pad=1)
+ grid.add_legend()
+ grid.set(xticks=(0, 1))
+
+ # finally save the figure
+ plt.savefig(self.output().path, dpi=500)
+
+
+class DAvNormalPlot(luigi.Task):
+ which_train = luigi.Parameter()
+ which_test = luigi.Parameter()
+ which_train_no_covariance_shift = luigi.Parameter()
+
+ def requires(self):
+ return WeightedBatch(self.which_train, self.which_test), \
+ tasks_mc.CameraBatch(self.which_test), \
+ tasks_mc.CameraBatch(self.which_train_no_covariance_shift)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sp.ROOT_FOLDER,
+ sp.RESULTS_FOLDER,
+ sp.FINALS_FOLDER,
+ "da_v_normal_train_" +
+ self.which_train +
+ "_test_" + self.which_test +
+ ".png"))
+
+ def run(self):
+ # get data
+ df_train = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_test = pd.read_csv(self.input()[1].path, header=[0, 1])
+ df_train_no_covariance_shift = pd.read_csv(self.input()[2].path,
+ header=[0, 1])
+
+ evaluation_setups = [EvaluationStruct("Proposed", rf)]
+ # evaluate the different methods
+ df_adapted = evaluate_data(df_train, noise_levels,
+ df_test, noise_levels,
+ evaluation_setups=evaluation_setups)
+ df_adapted["data"] = "adapted"
+ df_no_adaptation = evaluate_data(
+ df_train.drop("weights", axis=1), noise_levels,
+ df_test, noise_levels,
+ evaluation_setups=evaluation_setups)
+ df_no_adaptation["data"] = "source"
+ df_no_covariance_shift = evaluate_data(
+ df_train_no_covariance_shift, noise_levels,
+ df_test, noise_levels,
+ evaluation_setups=evaluation_setups)
+ df_no_covariance_shift["data"] = "target"
+ df = pd.concat([df_adapted, df_no_adaptation, df_no_covariance_shift])
+
+ # plot it
+ sns.boxplot(data=df, x="noise added [sigma %]", y="Errors", hue="data",
+ hue_order=["source", "adapted", "target"], fliersize=0)
+ # tidy up plot
+ plt.ylim((0, 40))
+ plt.legend(loc='upper left')
+
+ # finally save the figure
+ plt.savefig(self.output().path, dpi=500)
+
+
+def format_dataframe_for_distribution_plotting(df, weights=None):
+ if weights is None:
+ weights = np.ones(df.shape[0])
+
+ bins = np.arange(0, 1, 0.01)
+
+ # we're only interested in reflectance information
+ df_formatted = df.loc[:, "reflectances"]
+ # to [nm] for plotting
+ df_formatted.rename(columns=lambda x: float(x)*10**9, inplace=True)
+
+ # transform data to a histogram
+ df_formatted = df_formatted.apply(lambda x:
+ pd.Series(np.histogram(x, bins=bins,
+ weights=weights,
+ normed=True)[0]),
+ axis=0)
+ # convert to long form using bins as identifier
+ df_formatted["bins"] = bins[1:]
+ df_formatted = pd.melt(df_formatted, id_vars=["bins"],
+ var_name="w", value_name="frequency")
+
+ return df_formatted
+
+
+if __name__ == '__main__':
+ logging.basicConfig(filename=os.path.join(sp.LOG_FOLDER,
+ "da_in_silico_plots" +
+ str(datetime.datetime.now()) +
+ '.log'),
+ level=logging.INFO)
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+ luigi.interface.setup_interface_logging()
+
+ source_domain = "ipcai_revision_generic"
+ target_domain = "ipcai_revision_colon_test"
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+ # check how the graph looks with same domains for training and testing
+ w.add(DaNoisePlot(which_train="ipcai_revision_colon_train",
+ which_test="ipcai_revision_colon_test"))
+ # check how the graph looks without domain adaptation
+ w.add(NoisePlot(which_train=source_domain, which_test=target_domain))
+ # Set a different testing domain to evaluate domain sensitivity
+ w.add(DaNoisePlot(which_train=source_domain, which_test=target_domain))
+
+ w.add(WeightDistributionPlot(which_source=source_domain,
+ which_target=target_domain))
+ w.add(FeatureDistributionPlot(which_source=source_domain,
+ which_target=target_domain))
+ # also plot distributions for equal domains to check for errors in data
+ w.add(FeatureDistributionPlot(which_source="ipcai_revision_colon_mean_scattering_train",
+ which_target="ipcai_revision_colon_mean_scattering_test"))
+ # plot how the generating model data (e.g. sao2 and vhb) is distributed
+ w.add(GeneratingDistributionPlot(which_source=source_domain,
+ which_target=target_domain))
+ w.add(DAvNormalPlot(which_train=source_domain, which_test=target_domain,
+ which_train_no_covariance_shift="ipcai_revision_colon_train"))
+ w.run()
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/__init__.py
similarity index 100%
copy from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
copy to Modules/Biophotonics/python/iMC/scripts/ipcai2016/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_silico.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_silico.py
new file mode 100644
index 0000000000..0db37b69f9
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_silico.py
@@ -0,0 +1,335 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 14 11:09:18 2015
+
+@author: wirkert
+"""
+
+import os
+import logging
+import datetime
+from collections import namedtuple
+
+import matplotlib
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+import luigi
+import matplotlib.pyplot as plt
+from sklearn.ensemble.forest import RandomForestRegressor
+
+import tasks_mc
+from regression.preprocessing import preprocess, preprocess2
+from regression.linear import LinearSaO2Unmixing
+
+import commons
+
+sc = commons.ScriptCommons()
+
+sc.add_dir("IN_SILICO_RESULTS_PATH", os.path.join(sc.get_dir("RESULTS_FOLDER"),
+ "in_silico"))
+
+sc.other["RECORDED_WAVELENGTHS"] = np.arange(470, 680, 10) * 10 ** -9
+
+w_standard = 10. # for this evaluation we add 10% noise
+
+font = {'family' : 'normal',
+ 'size' : 20}
+
+matplotlib.rc('font', **font)
+
+
+# setup standard random forest
+rf = RandomForestRegressor(10, min_samples_leaf=10, max_depth=9, n_jobs=-1)
+EvaluationStruct = namedtuple("EvaluationStruct",
+ "name regressor")
+# standard evaluation setup
+standard_evaluation_setups = [EvaluationStruct("Linear Beer-Lambert",
+ LinearSaO2Unmixing())
+ , EvaluationStruct("Proposed", rf)]
+
+# color palette
+my_colors = ["red", "green"]
+
+# standard noise levels
+noise_levels = np.array([1,2,3,4,5,6,7,8,9,10,
+ 15,20,30,40,50,100,150,200]).astype("float")
+
+
+class TrainingSamplePlot(luigi.Task):
+ which_train = luigi.Parameter()
+ which_test = luigi.Parameter()
+
+ def requires(self):
+ return tasks_mc.CameraBatch(self.which_train), \
+ tasks_mc.CameraBatch(self.which_test)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("IN_SILICO_RESULTS_PATH"),
+ "sample_plot_train_" +
+ self.which_train +
+ "_test_" + self.which_test +
+ ".pdf"))
+
+ def run(self):
+ # get data
+ df_train = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_test = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ # for this plot we write a custom evaluation function as it is built
+ # a little different
+
+ # create a new dataframe which will hold all the generated errors
+ df = pd.DataFrame()
+
+ nr_training_samples = np.arange(10, 15010, 50).astype(int)
+ # not very pythonic, don't care
+ for n in nr_training_samples:
+ X_test, y_test = preprocess(df_test, snr=w_standard)
+ # only take n samples for training
+ X_train, y_train = preprocess(df_train, nr_samples=n,
+ snr=w_standard)
+
+ regressor = rf
+ regressor.fit(X_train, y_train)
+ y_pred = regressor.predict(X_test)
+ # save results to a dataframe
+ errors = np.abs(y_pred - y_test)
+ errors = errors.reshape(len(errors), 1)
+ current_df = DataFrame(errors * 100,
+ columns=["Errors"])
+ current_df["Method"] = "Proposed"
+ current_df["Number Samples"] = n / 10**3.
+ df = pd.concat([df, current_df], ignore_index=True)
+ logging.info(
+ "Finished training classifier with {0} samples".format(
+ str(n)))
+
+ df = df.groupby("Number Samples").describe()
+ # get the error description in the rows:
+ df = df.unstack(-1)
+ # get rid of multiindex by dropping "Error" level
+ df.columns = df.columns.droplevel(0)
+
+ plt.figure()
+ plt.plot(df.index, df["50%"], color="green")
+
+ # tidy up the plot
+ plt.xlabel("number of training samples / 1000")
+ plt.ylabel("absolute error [%]")
+ plt.ylim((0, 20))
+ plt.xlim((0, 15))
+ plt.grid()
+
+ # finally save the figure
+ plt.savefig(self.output().path, mode="pdf", dpi=500,
+ bbox_inches='tight')
+
+
+class VhbPlot(luigi.Task):
+ which_train = luigi.Parameter()
+ which_test = luigi.Parameter()
+
+ def requires(self):
+ return tasks_mc.CameraBatch(self.which_train), \
+ tasks_mc.CameraBatch(self.which_test)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("IN_SILICO_RESULTS_PATH"),
+ "vhb_noise_plot_train_" +
+ self.which_train +
+ "_test_" + self.which_test +
+ ".pdf"))
+
+ @staticmethod
+ def preprocess_vhb(batch, nr_samples=None, snr=None,
+ magnification=None, bands_to_sortout=None):
+ """ For evaluating vhb we extract labels for vhb instead of sao2"""
+ X, y = preprocess2(batch, nr_samples, snr,
+ magnification, bands_to_sortout)
+
+ return X, y["vhb"].values
+
+ def run(self):
+ # get data
+ df_train = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_test = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ # for vhb we only evaluate the proposed method since the linear
+ # beer-lambert is not applicable
+ evaluation_setups = [EvaluationStruct("Proposed", rf)]
+ df = evaluate_data(df_train, noise_levels, df_test, noise_levels,
+ evaluation_setups=evaluation_setups,
+ preprocessing=self.preprocess_vhb)
+ standard_plotting(df, color_palette=["green"],
+ xytext_position=(2, 3))
+ plt.ylim((0, 4))
+
+ # finally save the figure
+ plt.savefig(self.output().path, dpi=500,
+ bbox_inches='tight')
+
+
+class NoisePlot(luigi.Task):
+ which_train = luigi.Parameter()
+ which_test = luigi.Parameter()
+
+ def requires(self):
+ return tasks_mc.CameraBatch(self.which_train), \
+ tasks_mc.CameraBatch(self.which_test)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("IN_SILICO_RESULTS_PATH"),
+ "noise_plot_train_" +
+ self.which_train +
+ "_test_" + self.which_test +
+ ".pdf"))
+
+ def run(self):
+ # get data
+ df_train = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_test = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ df = evaluate_data(df_train, noise_levels, df_test, noise_levels)
+ standard_plotting(df)
+
+ # finally save the figure
+ plt.savefig(self.output().path, mode="pdf", dpi=500,
+ bbox_inches='tight')
+
+
+class WrongNoisePlot(luigi.Task):
+ which_train = luigi.Parameter()
+ which_test = luigi.Parameter()
+ train_snr = luigi.FloatParameter()
+
+ def requires(self):
+ return tasks_mc.CameraBatch(self.which_train), \
+ tasks_mc.CameraBatch(self.which_test)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("IN_SILICO_RESULTS_PATH"),
+ str(self.train_snr) +
+ "_wrong_noise_plot_train_" +
+ self.which_train +
+ "_test_" + self.which_test +
+ ".pdf"))
+
+ def run(self):
+ # get data
+ df_train = pd.read_csv(self.input()[0].path, header=[0, 1])
+ df_test = pd.read_csv(self.input()[1].path, header=[0, 1])
+
+ # do same as in NoisePlot but with standard noise input
+ df = evaluate_data(df_train,
+ np.ones_like(noise_levels) * self.train_snr,
+ df_test, noise_levels)
+ standard_plotting(df)
+
+ # finally save the figure
+ plt.savefig(self.output().path, mode="pdf", dpi=500,
+ bbox_inches='tight')
+
+
+def evaluate_data(df_train, w_train, df_test, w_test,
+ evaluation_setups=None, preprocessing=None):
+ """ Our standard method to evaluate the data. It will fill a DataFrame df
+ which saves the errors for each evaluated setup"""
+ if evaluation_setups is None:
+ evaluation_setups = standard_evaluation_setups
+ if preprocessing is None:
+ preprocessing = preprocess
+ if ("weights" in df_train) and df_train["weights"].size > 0:
+ weights = df_train["weights"].as_matrix().squeeze()
+ else:
+ weights = np.ones(df_train.shape[0])
+
+ # create a new dataframe which will hold all the generated errors
+ df = pd.DataFrame()
+ for one_w_train, one_w_test in zip(w_train, w_test):
+ # setup testing function
+ X_test, y_test = preprocessing(df_test, snr=one_w_test)
+ # extract noisy data
+ X_train, y_train = preprocessing(df_train, snr=one_w_train)
+ for e in evaluation_setups:
+ regressor = e.regressor
+ regressor.fit(X_train, y_train, weights)
+ y_pred = regressor.predict(X_test)
+ # save results to a dataframe
+ errors = np.abs(y_pred - y_test)
+ errors = errors.reshape(len(errors), 1)
+ current_df = DataFrame(errors * 100,
+ columns=["Errors"])
+ current_df["Method"] = e.name
+ current_df["SNR"] = int(one_w_test)
+ df = pd.concat([df, current_df], ignore_index=True)
+
+ return df
+
+
+def standard_plotting(df, color_palette=None, xytext_position=None):
+ if color_palette is None:
+ color_palette = my_colors
+ if xytext_position is None:
+ xytext_position = (2, 15)
+
+ plt.figure()
+
+ # group it by method and noise level and get description on the errors
+ df_statistics = df.groupby(['Method', 'SNR']).describe()
+ # get the error description in the rows:
+ df_statistics = df_statistics.unstack(-1)
+ # get rid of multiindex by dropping "Error" level
+ df_statistics.columns = df_statistics.columns.droplevel(0)
+
+ # iterate over methods to plot linegraphs with error tube
+ # probably this can be done nicer, but no idea how exactly
+
+ for color, method in zip(
+ color_palette, df_statistics.index.get_level_values("Method").unique()):
+ df_method = df_statistics.loc[method]
+ plt.plot(df_method.index, df_method["50%"],
+ color=color, label=method)
+ plt.fill_between(df_method.index, df_method["25%"], df_method["75%"],
+ facecolor=color, edgecolor=color,
+ alpha=0.5)
+ # tidy up the plot
+ plt.ylim((0, 40))
+ plt.gca().set_xticks(np.arange(0, 200, 10), minor=True)
+ plt.xlabel("SNR")
+ plt.ylabel("absolute error [%]")
+ plt.grid()
+ plt.legend()
+
+
+if __name__ == '__main__':
+
+ sc.set_root("/media/wirkert/data/Data/2016_02_02_IPCAI/")
+ sc.create_folders()
+
+ logging.basicConfig(filename=os.path.join(sc.get_full_dir("LOG_FOLDER"),
+ "in_silico_plots_" +
+ str(datetime.datetime.now()) +
+ '.log'),
+ level=logging.INFO)
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+ luigi.interface.setup_interface_logging()
+
+ train = "ipcai_revision_colon_mean_scattering_train"
+ test = "ipcai_revision_colon_mean_scattering_test"
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+ w.add(TrainingSamplePlot(which_train=train, which_test=test))
+ w.add(NoisePlot(which_train=train, which_test=test))
+ w.add(WrongNoisePlot(which_train=train, which_test=test, train_snr=10.))
+ w.add(WrongNoisePlot(which_train=train, which_test=test, train_snr=50.))
+ w.add(WrongNoisePlot(which_train=train, which_test=test, train_snr=200.))
+ # Set a different testing domain to evaluate domain sensitivity
+ w.add(NoisePlot(which_train=train,
+ which_test="ipcai_revision_generic_mean_scattering_test"))
+ w.add(VhbPlot(which_train=train, which_test=test))
+ w.run()
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_vivo_liver.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_vivo_liver.py
new file mode 100644
index 0000000000..2f547afe3f
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_vivo_liver.py
@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 14 11:09:18 2015
+
+@author: wirkert
+"""
+
+
+import Image
+import ImageEnhance
+import logging
+import datetime
+
+import SimpleITK as sitk
+import matplotlib
+
+from msi.io.nrrdreader import NrrdReader
+import msi.normalize as norm
+from regression.estimation import estimate_image
+from tasks_common import *
+import commons
+from msi.io.tiffringreader import TiffRingReader
+
+TiffRingReader.RESIZE_FACTOR = 0.5
+
+sc = commons.ScriptCommons()
+
+sc.add_dir("LIVER_DATA",
+ os.path.join(sc.get_dir("DATA_FOLDER"), "liver_images"))
+sc.add_dir("LIVER_RESULTS", os.path.join(sc.get_dir("RESULTS_FOLDER"), "liver"))
+
+sc.add_dir("FILTER_TRANSMISSIONS",
+ os.path.join(sc.get_dir("DATA_FOLDER"),
+ "filter_transmissions"))
+
+font = {'family' : 'normal',
+ 'size' : 30}
+matplotlib.rc('font', **font)
+
+
+class ResultsFile(luigi.Task):
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("LIVER_RESULTS"),
+ "results.csv"))
+
+
+class OxyAndVhbOverTimeTask(luigi.Task):
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("LIVER_RESULTS"),
+ "liver_oxy_over_time.pdf"))
+
+ def requires(self):
+ return ResultsFile()
+
+ def run(self):
+ df = pd.read_csv(self.input().path, index_col=0)
+ # determine times from start:
+ image_name_strings = df["image name"].values
+ time_strings = map(lambda s: s[
+ s.find("2014-08-03_")+11:s.find("2014-08-03_")+19],
+ image_name_strings)
+ time_in_s = map(lambda s: int(s[0:2]) * 3600 +
+ int(s[3:5]) * 60 +
+ int(s[6:]), time_strings)
+ df["time since drug delivery [s]"] = np.array(time_in_s) - time_in_s[0]
+
+ # print oxy over time as scatterplot.
+ ax = df.plot.scatter(x="time since drug delivery [s]",
+ y="oxygenation mean [%]",
+ s=100, alpha=0.5,
+ fontsize=30)
+ ax.set_xlim((-1, 70))
+
+ plt.axvline(x=0, ymin=0, ymax=1, linewidth=2)
+ plt.axvline(x=56, ymin=0, ymax=1, linewidth=2)
+ ax.annotate('drug delivery', xy=(0, ax.get_ylim()[1]),
+ xycoords='data', xytext=(0, 0),
+ fontsize=30,
+ textcoords='offset points')
+ ax.annotate('porcine death', xy=(56, ax.get_ylim()[1]),
+ xycoords='data', xytext=(-100, 0),
+ fontsize=30,
+ textcoords='offset points')
+ ax.yaxis.label.set_size(30)
+ ax.xaxis.label.set_size(30)
+ plt.grid()
+
+ df.to_csv(self.input().path)
+
+ # create and save vhb plot
+ plt.savefig(self.output().path,
+ dpi=250, bbox_inches='tight', mode="pdf")
+
+ # print vhb over time as scatterplot.
+ ax = df.plot.scatter(x="time since drug delivery [s]",
+ y="blood volume fraction mean [%]",
+ s=100, alpha=0.5,
+ fontsize=30)
+ ax.set_xlim((-1, 70))
+
+ plt.axvline(x=0, ymin=0, ymax=1, linewidth=2)
+ plt.axvline(x=56, ymin=0, ymax=1, linewidth=2)
+ ax.annotate('drug delivery', xy=(0, ax.get_ylim()[1]),
+ xycoords='data', xytext=(0, 0),
+ fontsize=30,
+ textcoords='offset points')
+ ax.annotate('porcine death', xy=(56, ax.get_ylim()[1]),
+ xycoords='data', xytext=(-100, 0),
+ fontsize=30,
+ textcoords='offset points')
+ ax.yaxis.label.set_size(30)
+ ax.xaxis.label.set_size(30)
+ plt.grid()
+
+ plt.savefig(self.output().path + "_vhb_mean.pdf",
+ dpi=250, bbox_inches='tight', mode="pdf")
+
+
+class IPCAICreateOxyImageTask(luigi.Task):
+ image_name = luigi.Parameter()
+ df_prefix = luigi.Parameter()
+
+ def requires(self):
+ return IPCAITrainRegressor(df_prefix=self.df_prefix), \
+ Flatfield(flatfield_folder=sc.get_full_dir("FLAT_FOLDER")), \
+ SingleMultispectralImage(image=os.path.join(
+ sc.get_full_dir("LIVER_DATA"), self.image_name)), \
+ Dark(dark_folder=sc.get_full_dir("DARK_FOLDER"))
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("LIVER_RESULTS"),
+ self.image_name + "_" +
+ self.df_prefix +
+ "_oxy_summary" + ".png"))
+
+ def run(self):
+ nrrd_reader = NrrdReader()
+ tiff_ring_reader = TiffRingReader()
+ # read the flatfield
+ flat = nrrd_reader.read(self.input()[1].path)
+ dark = nrrd_reader.read(self.input()[3].path)
+ # read the msi
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+ msi, segmentation = tiff_ring_reader.read(self.input()[2].path,
+ nr_filters)
+
+ # only take into account not saturated pixels.
+ segmentation = np.max(msi.get_image(), axis=-1) < 2000.
+
+ # read the regressor
+ e_file = open(self.input()[0].path, 'r')
+ e = pickle.load(e_file)
+
+ # correct image setup
+ position_filter_nr_in_string = self.image_name.find(" 2014") - 1
+ filter_nr = int(self.image_name[
+ position_filter_nr_in_string:position_filter_nr_in_string+1])
+ original_order = np.arange(nr_filters)
+ new_image_order = np.concatenate((
+ original_order[nr_filters - filter_nr:],
+ original_order[:nr_filters - filter_nr]))
+ # resort msi to restore original order
+ msimani.get_bands(msi, new_image_order)
+ # correct by flatfield
+ msimani.image_correction(msi, flat, dark)
+
+ # create artificial rgb
+ rgb_image = msi.get_image()[:, :, [2, 3, 1]]
+ rgb_image /= np.max(rgb_image)
+ rgb_image *= 255.
+
+ # preprocess the image
+ # sortout unwanted bands
+ print "1"
+ # zero values would lead to infinity logarithm, thus clip.
+ msi.set_image(np.clip(msi.get_image(), 0.00001, 2. ** 64))
+ # normalize to get rid of lighting intensity
+ norm.standard_normalizer.normalize(msi)
+ # transform to absorption
+ msi.set_image(-np.log(msi.get_image()))
+ # normalize by l2 for stability
+ norm.standard_normalizer.normalize(msi, "l2")
+ print "2"
+ # estimate
+ sitk_image, time = estimate_image(msi, e)
+ image = sitk.GetArrayFromImage(sitk_image)
+
+ plt.figure()
+ print "3"
+ rgb_image = rgb_image.astype(np.uint8)
+ im = Image.fromarray(rgb_image, 'RGB')
+ enh_brightness = ImageEnhance.Brightness(im)
+ im = enh_brightness.enhance(5.)
+ plotted_image = np.array(im)
+ top_left_axis = plt.gca()
+ top_left_axis.imshow(plotted_image, interpolation='nearest')
+ top_left_axis.xaxis.set_visible(False)
+ top_left_axis.yaxis.set_visible(False)
+
+ plt.set_cmap("jet")
+ print "4"
+ # plot parametric maps
+ # first oxygenation
+ plt.figure()
+ oxy_image = image[:, :, 0]
+ segmentation[0, 0] = 1
+ segmentation[0, 1] = 1
+ oxy_image = np.ma.masked_array(oxy_image, ~segmentation)
+ oxy_image[np.isnan(oxy_image)] = 0.
+ oxy_image[np.isinf(oxy_image)] = 0.
+ oxy_mean = np.mean(oxy_image)
+ oxy_image[0, 0] = 0.0
+ oxy_image[0, 1] = 1.
+ plot_image(oxy_image[:, :], plt.gca())
+ plt.savefig(self.output().path,
+ dpi=250, bbox_inches='tight')
+ # second blood volume fraction
+ plt.figure()
+ vhb_image = image[:, :, 1]
+ vhb_image = np.ma.masked_array(vhb_image, ~segmentation)
+ vhb_image[np.isnan(vhb_image)] = 0.
+ vhb_image[np.isinf(vhb_image)] = 0.
+ vhb_image[0, 0] = 0.0
+ vhb_image[0, 1] = 0.1
+ vhb_image = np.clip(vhb_image, 0.0, 0.1)
+ vhb_mean = np.mean(vhb_image)
+ plot_image(vhb_image, plt.gca())
+ plt.savefig(self.output().path + "vhb.png",
+ dpi=250, bbox_inches='tight')
+
+ # store results summary in dataframe
+ df_image_results = pd.DataFrame(data=np.expand_dims([self.image_name,
+ oxy_mean * 100.,
+ vhb_mean * 100.,
+ time], 0),
+ columns=["image name",
+ "oxygenation mean [%]",
+ "blood volume fraction mean [%]",
+ "time to estimate"])
+
+ results_file = os.path.join(sc.get_full_dir("LIVER_RESULTS"),
+ "results.csv")
+ if os.path.isfile(results_file):
+ df_results = pd.read_csv(results_file, index_col=0)
+ df_results = pd.concat((df_results, df_image_results)).reset_index(
+ drop=True
+ )
+ else:
+ df_results = df_image_results
+
+ df_results.to_csv(results_file)
+
+ print "5"
+ plt.close("all")
+
+
+if __name__ == '__main__':
+
+ # create a folder for the results if necessary
+ sc.set_root("/media/wirkert/data/Data/2016_02_02_IPCAI/")
+ sc.create_folders()
+
+ # root folder there the data lies
+ logging.basicConfig(filename=os.path.join(sc.get_full_dir("LOG_FOLDER"),
+ "liver" +
+ str(datetime.datetime.now()) +
+ '.log'), level=logging.INFO)
+ luigi.interface.setup_interface_logging()
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+
+ onlyfiles = get_image_files_from_folder(sc.get_full_dir("LIVER_DATA"))
+
+ first_invivo_image_files = filter(lambda image_name: "0 2014" in image_name,
+ onlyfiles)
+
+ for f in first_invivo_image_files:
+ main_task = IPCAICreateOxyImageTask(image_name=f,
+ df_prefix="ipcai_revision_colon_mean_scattering_train")
+ w.add(main_task)
+
+ w.run()
+
+ oxygenation_over_time_task = OxyAndVhbOverTimeTask()
+ w.add(oxygenation_over_time_task)
+ w.run()
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_vivo_small_bowel.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_vivo_small_bowel.py
new file mode 100644
index 0000000000..6ce3da2895
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_analyze_ipcai_in_vivo_small_bowel.py
@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 14 11:09:18 2015
+
+@author: wirkert
+"""
+
+import Image
+import ImageEnhance
+import logging
+import datetime
+
+import SimpleITK as sitk
+import matplotlib
+
+from msi.io.nrrdreader import NrrdReader
+import msi.normalize as norm
+from regression.estimation import estimate_image
+from tasks_common import *
+import commons
+from msi.io.tiffringreader import TiffRingReader
+
+TiffRingReader.RESIZE_FACTOR = 0.5
+
+sc = commons.ScriptCommons()
+
+
+sc.add_dir("SMALL_BOWEL_DATA",
+ os.path.join(sc.get_dir("DATA_FOLDER"), "small_bowel_images"))
+
+sc.add_dir("SMALL_BOWEL_RESULT", os.path.join(sc.get_dir("RESULTS_FOLDER"),
+ "small_bowel"))
+
+sc.add_dir("FILTER_TRANSMISSIONS",
+ os.path.join(sc.get_dir("DATA_FOLDER"),
+ "filter_transmissions"))
+
+font = {'family' : 'normal',
+ 'size' : 25}
+matplotlib.rc('font', **font)
+
+
+class ResultsFile(luigi.Task):
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(
+ sc.get_full_dir("SMALL_BOWEL_RESULT"), "results.csv"))
+
+
+class OxyOverTimeTask(luigi.Task):
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(
+ sc.get_full_dir("SMALL_BOWEL_RESULT"),
+ "colon_oxy_over_time.pdf"))
+
+ def requires(self):
+ return ResultsFile()
+
+ def run(self):
+ df = pd.read_csv(self.input().path, index_col=0)
+
+ # determine times from start:
+ image_name_strings = df["image name"].values
+ time_strings = map(lambda s: s[
+ s.find("2015-10-08_")+11:s.find("2015-10-08_")+19],
+ image_name_strings)
+ time_in_s = map(lambda s: int(s[0:2]) * 3600 +
+ int(s[3:5]) * 60 +
+ int(s[6:]), time_strings)
+ df["time since first frame [s]"] = np.array(time_in_s) - time_in_s[0]
+ df["time since applying first clip [s]"] = df["time since first frame [s]"] - 4
+ # print oxy over time as scatterplot.
+ plt.figure()
+ ax = df.plot.scatter(x="time since applying first clip [s]",
+ y="oxygenation mean [%]", fontsize=30,
+ s=50, alpha=0.5)
+ ax.set_xlim((-5, 600))
+
+ plt.axvline(x=0, ymin=0, ymax=1, linewidth=2)
+ plt.axvline(x=39, ymin=0, ymax=1, linewidth=2)
+ plt.axvline(x=100, ymin=0, ymax=1, linewidth=2)
+ plt.axvline(x=124, ymin=0, ymax=1, linewidth=2)
+ ax.annotate('1', xy=(0, ax.get_ylim()[1]),
+ fontsize=18,
+ color="blue",
+ xycoords='data', xytext=(-5, 0),
+ textcoords='offset points')
+ ax.annotate('2', xy=(39, ax.get_ylim()[1]),
+ fontsize=18,
+ color="blue",
+ xycoords='data', xytext=(-5, 0),
+ textcoords='offset points')
+ ax.annotate('3', xy=(100, ax.get_ylim()[1]),
+ fontsize=18,
+ color="blue",
+ xycoords='data', xytext=(-5, 0),
+ textcoords='offset points')
+ ax.annotate('4', xy=(124, ax.get_ylim()[1]),
+ fontsize=18,
+ color="blue",
+ xycoords='data', xytext=(-5, 0),
+ textcoords='offset points')
+
+ plt.grid()
+
+ df.to_csv(self.input().path)
+
+ # save
+ plt.savefig(self.output().path,
+ dpi=250, bbox_inches='tight', mode="pdf")
+
+
+def plot_image(image, axis):
+ im2 = axis.imshow(image, interpolation='nearest', alpha=1.0)
+ # axis.set_title(title, fontsize=5)
+ # divider = make_axes_locatable(axis)
+ # cax = divider.append_axes("right", size="10%", pad=0.05)
+ # cbar = plt.colorbar(im2, cax=cax)
+ # cbar.ax.tick_params(labelsize=5)
+ axis.xaxis.set_visible(False)
+
+
+class IPCAICreateOxyImageTask(luigi.Task):
+ image_name = luigi.Parameter()
+ df_prefix = luigi.Parameter()
+
+ def requires(self):
+ return IPCAITrainRegressor(df_prefix=self.df_prefix), \
+ Flatfield(flatfield_folder=sc.get_full_dir("FLAT_FOLDER")), \
+ SingleMultispectralImage(image=self.image_name), \
+ Dark(dark_folder=sc.get_full_dir("DARK_FOLDER"))
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("SMALL_BOWEL_RESULT"),
+ os.path.split(self.image_name)[1] +
+ "_" + self.df_prefix +
+ "_summary" + ".png"))
+
+ def run(self):
+ nrrd_reader = NrrdReader()
+ tiff_ring_reader = TiffRingReader()
+ # read the flatfield
+ flat = nrrd_reader.read(self.input()[1].path)
+ dark = nrrd_reader.read(self.input()[3].path)
+ # read the msi
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+ msi, segmentation = tiff_ring_reader.read(self.input()[2].path,
+ nr_filters)
+ # only take into account not saturated pixels.
+ segmentation = np.logical_and(segmentation,
+ (np.max(msi.get_image(),
+ axis=-1) < 1000.))
+
+ # read the regressor
+ e_file = open(self.input()[0].path, 'r')
+ e = pickle.load(e_file)
+
+ # correct image setup
+ filter_nr = int(self.image_name[-6:-5])
+ original_order = np.arange(nr_filters)
+ new_image_order = np.concatenate((
+ original_order[nr_filters - filter_nr:],
+ original_order[:nr_filters - filter_nr]))
+ # resort msi to restore original order
+ msimani.get_bands(msi, new_image_order)
+ # correct by flatfield
+ msimani.image_correction(msi, flat, dark)
+
+ # create artificial rgb
+ rgb_image = msi.get_image()[:, :, [2, 3, 1]]
+ rgb_image /= np.max(rgb_image)
+ rgb_image *= 255.
+
+ # preprocess the image
+ # sortout unwanted bands
+ print "1"
+ # zero values would lead to infinity logarithm, thus clip.
+ msi.set_image(np.clip(msi.get_image(), 0.00001, 2. ** 64))
+ # normalize to get rid of lighting intensity
+ norm.standard_normalizer.normalize(msi)
+ # transform to absorption
+ msi.set_image(-np.log(msi.get_image()))
+ # normalize by l2 for stability
+ norm.standard_normalizer.normalize(msi, "l2")
+ print "2"
+ # estimate
+ sitk_image, time = estimate_image(msi, e)
+ image = sitk.GetArrayFromImage(sitk_image)
+
+ plt.figure()
+ print "3"
+ rgb_image = rgb_image.astype(np.uint8)
+ im = Image.fromarray(rgb_image, 'RGB')
+ enh_brightness = ImageEnhance.Brightness(im)
+ im = enh_brightness.enhance(10.)
+ plotted_image = np.array(im)
+ top_left_axis = plt.gca()
+ top_left_axis.imshow(plotted_image, interpolation='nearest')
+ top_left_axis.xaxis.set_visible(False)
+ top_left_axis.yaxis.set_visible(False)
+
+ plt.set_cmap("jet")
+ print "4"
+ # plot parametric maps
+ segmentation[0, 0] = 1
+ segmentation[0, 1] = 1
+ oxy_image = np.ma.masked_array(image[:, :, 0], ~segmentation)
+ oxy_image[np.isnan(oxy_image)] = 0.
+ oxy_image[np.isinf(oxy_image)] = 0.
+ oxy_mean = np.mean(oxy_image)
+ oxy_image[0, 0] = 0.0
+ oxy_image[0, 1] = 1.
+
+ plot_image(oxy_image[:, :], plt.gca())
+
+ df_image_results = pd.DataFrame(data=np.expand_dims([self.image_name,
+ oxy_mean * 100.,
+ time], 0),
+ columns=["image name",
+ "oxygenation mean [%]",
+ "time to estimate"])
+
+ results_file = os.path.join(sc.get_full_dir("SMALL_BOWEL_RESULT"),
+ "results.csv")
+ if os.path.isfile(results_file):
+ df_results = pd.read_csv(results_file, index_col=0)
+ df_results = pd.concat((df_results, df_image_results)).reset_index(
+ drop=True
+ )
+ else:
+ df_results = df_image_results
+
+ df_results.to_csv(results_file)
+
+ plt.savefig(self.output().path,
+ dpi=250, bbox_inches='tight')
+ plt.close("all")
+
+
+if __name__ == '__main__':
+
+ # create a folder for the results if necessary
+ sc.set_root("/media/wirkert/data/Data/2016_02_02_IPCAI/")
+ sc.create_folders()
+
+ # root folder there the data lies
+ logging.basicConfig(filename=os.path.join(sc.get_full_dir("LOG_FOLDER"),
+ "small_bowel_images" +
+ str(datetime.datetime.now()) +
+ '.log'),
+ level=logging.INFO)
+ luigi.interface.setup_interface_logging()
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+
+
+ # determine files to process
+ files = get_image_files_from_folder(sc.get_full_dir("SMALL_BOWEL_DATA"),
+ suffix="F0.tiff", fullpath=True)
+
+ for f in files:
+ main_task = IPCAICreateOxyImageTask(image_name=f,
+ df_prefix="ipcai_revision_colon_mean_scattering_te")
+ w.add(main_task)
+ w.run()
+
+ oxygenation_over_time_task = OxyOverTimeTask()
+ w.add(oxygenation_over_time_task)
+ w.run()
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_calculate_spectra.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_calculate_spectra.py
new file mode 100644
index 0000000000..5ceb764c33
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/script_calculate_spectra.py
@@ -0,0 +1,123 @@
+'''
+Created on Sep 9, 2015
+
+@author: wirkert
+'''
+
+
+import logging
+import datetime
+import os
+import time
+
+import numpy as np
+import luigi
+
+import commons
+import mc.factories as mcfac
+from mc.sim import SimWrapper
+from mc.create_spectrum import create_spectrum
+
+# parameter setting
+NR_BATCHES = 100
+NR_ELEMENTS_IN_BATCH = 1000
+# the wavelengths to be simulated
+WAVELENGHTS = np.arange(450, 720, 2) * 10 ** -9
+NR_PHOTONS = 10 ** 6
+
+# experiment configuration
+MCI_FILENAME = "./temp.mci"
+MCO_FILENAME = "temp.mco"
+# this path definitly needs to be adapted by you
+PATH_TO_MCML = "/home/wirkert/workspace/monteCarlo/gpumcml/fast-gpumcml/"
+EXEC_MCML = "gpumcml.sm_20"
+
+
+sc = commons.ScriptCommons()
+
+
+class CreateSpectraTask(luigi.Task):
+ df_prefix = luigi.Parameter()
+ batch_nr = luigi.IntParameter()
+ nr_samples = luigi.IntParameter()
+ factory = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("MC_DATA_FOLDER"),
+ self.df_prefix + "_" +
+ str(self.batch_nr) + ".txt"))
+
+ def run(self):
+ start = time.time()
+ # setup simulation wrapper
+ sim_wrapper = SimWrapper()
+ sim_wrapper.set_mci_filename(MCI_FILENAME)
+ sim_wrapper.set_mcml_executable(os.path.join(PATH_TO_MCML, EXEC_MCML))
+ # setup model
+ tissue_model = self.factory.create_tissue_model()
+ tissue_model.set_mci_filename(sim_wrapper.mci_filename)
+ tissue_model.set_mco_filename(MCO_FILENAME)
+ tissue_model.set_nr_photons(NR_PHOTONS)
+ # setup array in which data shall be stored
+ batch = self.factory.create_batch_to_simulate()
+ batch.create_parameters(self.nr_samples)
+ # dataframe created by batch:
+ df = batch.df
+ # add reflectance column to dataframe
+ for w in WAVELENGHTS:
+ df["reflectances", w] = np.NAN
+
+ # for each instance of our tissue model
+ for i in range(df.shape[0]):
+ # set the desired element in the dataframe to be simulated
+ tissue_model.set_dataframe_row(df.loc[i, :])
+ logging.info("running simulation " + str(i) + " for\n" +
+ str(tissue_model))
+ reflectances = create_spectrum(tissue_model, sim_wrapper,
+ WAVELENGHTS)
+ # store in dataframe
+ for r, w in zip(reflectances, WAVELENGHTS):
+ df["reflectances", w][i] = r
+
+ # clean up temporarily created files
+ os.remove(MCI_FILENAME)
+ created_mco_file = os.path.join(PATH_TO_MCML, MCO_FILENAME)
+ if os.path.isfile(created_mco_file):
+ os.remove(created_mco_file)
+ # save the created output
+ f = open(self.output().path, 'w')
+ df.to_csv(f)
+
+ end = time.time()
+ logging.info("time for creating batch of mc data: %.f s" %
+ (end - start))
+
+
+if __name__ == '__main__':
+
+ # create a folder for the results if necessary
+ sc.set_root("/media/wirkert/data/Data/2016_02_02_IPCAI/")
+ sc.create_folders()
+
+ logging.basicConfig(filename=os.path.join(sc.get_full_dir("LOG_FOLDER"),
+ "calculate_spectra" +
+ str(datetime.datetime.now()) +
+ '.log'),
+ level=logging.INFO)
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+ luigi.interface.setup_interface_logging()
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+ BATCH_NUMBERS = np.arange(0, NR_BATCHES, 1)
+ for i in BATCH_NUMBERS:
+ colon_task = CreateSpectraTask("ipcai_revision_generic_mean_scattering",
+ i,
+ NR_ELEMENTS_IN_BATCH,
+ mcfac.GenericMeanScatteringFactory())
+ w.add(colon_task)
+ w.run()
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai2016/tasks_common.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/tasks_common.py
new file mode 100644
index 0000000000..7df698175c
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/tasks_common.py
@@ -0,0 +1,166 @@
+
+import os
+import pickle
+
+import numpy as np
+import pandas as pd
+import luigi
+from sklearn.ensemble.forest import RandomForestRegressor
+import matplotlib.pylab as plt
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+import tasks_mc
+import commons
+from msi.msi import Msi
+from msi.io.nrrdwriter import NrrdWriter
+import msi.msimanipulations as msimani
+from regression.preprocessing import preprocess2
+from msi.io.tiffringreader import TiffRingReader
+
+sc = commons.ScriptCommons()
+
+"""
+Collection of functions and luigi.Task s which are used by more than one script
+"""
+
+
+def get_image_files_from_folder(folder,
+ prefix="", suffix=".tiff", fullpath=False):
+ # small helper function to get all the image files in a folder
+ # it will only return files which end with suffix.
+ # if fullpath==True it will return the full path of the file, otherwise
+ # only the filename
+ # get all filenames
+ image_files = [f for f in os.listdir(folder) if
+ os.path.isfile(os.path.join(folder, f))]
+ image_files.sort()
+ image_files = [f for f in image_files if f.endswith(suffix)]
+ image_files = [f for f in image_files if f.startswith(prefix)]
+ if fullpath: # expand to full path if wished
+ image_files = [os.path.join(folder, f) for f in image_files]
+ return image_files
+
+
+def plot_image(image, axis=None, title=None, cmap=None):
+ if axis is None:
+ axis = plt.gca()
+ if cmap is None:
+ im = axis.imshow(image, interpolation='nearest', alpha=1.0)
+ else:
+ im = axis.imshow(image, interpolation='nearest', alpha=1.0,
+ cmap=cmap)
+ divider = make_axes_locatable(axis)
+ cax = divider.append_axes("right", size="20%", pad=0.05)
+ cbar = plt.colorbar(im, cax=cax)
+
+ axis.xaxis.set_visible(False)
+ axis.yaxis.set_visible(False)
+ if title is not None:
+ axis.set_title(title)
+
+
+class IPCAITrainRegressor(luigi.Task):
+ df_prefix = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ "reg_small_bowel_" +
+ self.df_prefix))
+
+ def requires(self):
+ return tasks_mc.SpectroCamBatch(self.df_prefix)
+
+ def run(self):
+ # extract data from the batch
+ df_train = pd.read_csv(self.input().path, header=[0, 1])
+
+ X, y = preprocess2(df_train, snr=10.)
+ # train regressor
+ reg = RandomForestRegressor(10, min_samples_leaf=10, max_depth=9,
+ n_jobs=-1)
+ # reg = KNeighborsRegressor(algorithm="auto")
+ # reg = LinearRegression()
+ # reg = sklearn.svm.SVR(kernel="rbf", degree=3, C=100., gamma=10.)
+ # reg = LinearSaO2Unmixing()
+ reg.fit(X, y.values)
+ # reg = LinearSaO2Unmixing()
+ # save regressor
+ regressor_file = self.output().open('w')
+ pickle.dump(reg, regressor_file)
+ regressor_file.close()
+
+
+class SingleMultispectralImage(luigi.Task):
+
+ image = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(self.image)
+
+
+class Flatfield(luigi.Task):
+
+ flatfield_folder = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ "flatfield.nrrd"))
+
+ def run(self):
+ tiff_ring_reader = TiffRingReader()
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+
+ # analyze all the first image files
+ image_files = get_image_files_from_folder(self.flatfield_folder)
+ image_files = filter(lambda image_name: "F0" in image_name, image_files)
+
+ # helper function to take maximum of two images
+ def maximum_of_two_images(image_1, image_name_2):
+ image_2 = tiff_ring_reader.read(os.path.join(self.flatfield_folder,
+ image_name_2),
+ nr_filters)[0].get_image()
+ return np.maximum(image_1, image_2)
+
+ # now reduce to maximum of all the single images
+ flat_maximum = reduce(lambda x, y: maximum_of_two_images(x, y),
+ image_files, 0)
+ msi = Msi(image=flat_maximum)
+ msi.set_wavelengths(sc.other["RECORDED_WAVELENGTHS"])
+
+ # write flatfield as nrrd
+ writer = NrrdWriter(msi)
+ writer.write(self.output().path)
+
+
+class Dark(luigi.Task):
+ dark_folder = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ "dark" +
+ ".nrrd"))
+
+ def run(self):
+ tiff_ring_reader = TiffRingReader()
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+
+ # analyze all the first image files
+ image_files = get_image_files_from_folder(self.dark_folder,
+ suffix="F0.tiff")
+
+ # returns the mean dark image vector of all inputted dark image
+ # overly complicated TODO SW: make this simple code readable.
+ dark_means = map(lambda image_name:
+ msimani.calculate_mean_spectrum(
+ tiff_ring_reader.read(os.path.join(self.dark_folder, image_name),
+ nr_filters)[0]),
+ image_files)
+ dark_means_sum = reduce(lambda x, y: x+y.get_image(), dark_means, 0)
+ final_dark_mean = dark_means_sum / len(dark_means)
+
+ msi = Msi(image=final_dark_mean)
+ msi.set_wavelengths(sc.other["RECORDED_WAVELENGTHS"])
+
+ # write flatfield as nrrd
+ writer = NrrdWriter(msi)
+ writer.write(self.output().path)
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai2016/tasks_mc.py b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/tasks_mc.py
new file mode 100644
index 0000000000..c3771dfd9d
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai2016/tasks_mc.py
@@ -0,0 +1,155 @@
+'''
+Created on Sep 10, 2015
+
+@author: wirkert
+'''
+
+
+
+import os
+
+import pandas as pd
+import numpy as np
+import luigi
+from scipy.interpolate import interp1d
+from sklearn.preprocessing import normalize
+
+import commons
+import mc.dfmanipulations as dfmani
+from msi.io.spectrometerreader import SpectrometerReader
+
+sc = commons.ScriptCommons()
+
+
+class SpectrometerFile(luigi.Task):
+ input_file = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(self.input_file)
+
+
+class FilterTransmission(luigi.Task):
+ input_file = luigi.Parameter()
+
+ def requires(self):
+ return SpectrometerFile(self.input_file)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ "processed_transmission" + os.path.split(self.input_file)[1]))
+
+ def run(self):
+ reader = SpectrometerReader()
+ filter_transmission = reader.read(self.input().path)
+ # filter high and low _wavelengths
+ wavelengths = filter_transmission.get_wavelengths()
+ fi_image = filter_transmission.get_image()
+ fi_image[wavelengths < 450 * 10 ** -9] = 0.0
+ fi_image[wavelengths > 720 * 10 ** -9] = 0.0
+ # filter elements farther away than +- 30nm
+ file_name = os.path.split(self.input_file)[1]
+ name_to_float = float(os.path.splitext(file_name)[0])
+ fi_image[wavelengths < (name_to_float - 30) * 10 ** -9] = 0.0
+ fi_image[wavelengths > (name_to_float + 30) * 10 ** -9] = 0.0
+ # elements < 0 are set to 0.
+ fi_image[fi_image < 0.0] = 0.0
+
+ # write it to a dataframe
+ df = pd.DataFrame()
+ df["wavelengths"] = wavelengths
+ df["reflectances"] = fi_image
+ df.to_csv(self.output().path, index=False)
+
+
+class JoinBatches(luigi.Task):
+ df_prefix = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ self.df_prefix + "_" +
+ "all" + ".txt"))
+
+ def run(self):
+ # get all files in the search path
+ files = [f for f in os.listdir(sc.get_full_dir("MC_DATA_FOLDER"))
+ if os.path.isfile(os.path.join(sc.get_full_dir("MC_DATA_FOLDER"), f))]
+ # from these get only those who start with correct batch prefix
+ df_file_names = [os.path.join(sc.get_full_dir("MC_DATA_FOLDER"), f)
+ for f in files if f.startswith(self.df_prefix)]
+ # load these files
+ dfs = [pd.read_csv(f, header=[0, 1]) for f in df_file_names]
+ # now join them to one batch
+ joined_df = pd.concat(dfs, ignore_index=True)
+ # write it
+ joined_df.to_csv(self.output().path, index=False)
+
+
+class CameraBatch(luigi.Task):
+ """takes a batch of reference data and converts it to the spectra
+ processed by a camera with the specified wavelengths assuming a 10nm FWHM"""
+ df_prefix = luigi.Parameter()
+
+ def requires(self):
+ return JoinBatches(self.df_prefix)
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ self.df_prefix +
+ "_all_virtual_camera.txt"))
+
+ def run(self):
+ # load dataframe
+ df = pd.read_csv(self.input().path, header=[0, 1])
+ # camera batch creation:
+ dfmani.fold_by_sliding_average(df, 6)
+ dfmani.interpolate_wavelengths(df, sc.other["RECORDED_WAVELENGTHS"])
+ # write it
+ df.to_csv(self.output().path, index=False)
+
+
+class SpectroCamBatch(luigi.Task):
+ """
+ Same as CameraBatch in purpose but adapts the batch to our very specific
+ SpectroCam set-up.
+ """
+ df_prefix = luigi.Parameter()
+
+ def requires(self):
+ # all wavelengths must have been measured for transmission and stored in
+ # wavelength.txt files (e.g. 470.txt)
+ filenames = ((sc.other["RECORDED_WAVELENGTHS"] * 10**9).astype(int)).astype(str)
+ filenames = map(lambda name: FilterTransmission(os.path.join(sc.get_full_dir("FILTER_TRANSMISSIONS"),
+ name +
+ ".txt")),
+ filenames)
+
+ return JoinBatches(self.df_prefix), filenames
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("INTERMEDIATES_FOLDER"),
+ self.df_prefix +
+ "_all_spectrocam.txt"))
+
+ def run(self):
+ # load dataframe
+ df = pd.read_csv(self.input()[0].path, header=[0, 1])
+ # camera batch creation:
+ new_reflectances = []
+ for band in self.input()[1]:
+ df_filter = pd.read_csv(band.path)
+ interpolator = interp1d(df_filter["wavelengths"],
+ df_filter["reflectances"],
+ assume_sorted=False, bounds_error=False)
+ # use this to create new reflectances
+ interpolated_filter = interpolator(df["reflectances"].
+ columns.astype(float))
+ # normalize band response
+ normalize(interpolated_filter.reshape(1, -1), norm='l1', copy=False)
+ folded_reflectance = np.dot(df["reflectances"].values,
+ interpolated_filter)
+ new_reflectances.append(folded_reflectance)
+ new_reflectances = np.array(new_reflectances).T
+ dfmani.switch_reflectances(df, sc.other["RECORDED_WAVELENGTHS"],
+ new_reflectances)
+ # write it
+ df.to_csv(self.output().path, index=False)
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/__init__.py
similarity index 100%
copy from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
copy to Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_image_hdf5.h5_list.txt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_image_hdf5.h5_list.txt
new file mode 100644
index 0000000000..1a0f78a1b1
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_image_hdf5.h5_list.txt
@@ -0,0 +1 @@
+ipcai_image_hdf5.h5
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_solver.prototxt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_solver.prototxt
new file mode 100644
index 0000000000..d76ba8c7f1
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_solver.prototxt
@@ -0,0 +1,24 @@
+# The train/test net protocol buffer definition
+train_net: "ipcai_train.prototxt"
+test_net: "ipcai_test.prototxt"
+# test_iter specifies how many forward passes the test should carry out.
+# In the case of MNIST, we have test batch size 100 and 100 test iterations,
+# covering the full 10,000 testing images.
+test_iter: 100
+# Carry out testing every 500 training iterations.
+test_interval: 500
+# The base learning rate, momentum and the weight decay of the network.
+base_lr: 0.01
+momentum: 0.0
+weight_decay: 0.0005
+# The learning rate policy
+lr_policy: "inv"
+gamma: 0.0001
+power: 0.75
+# Display every 100 iterations
+display: 1000
+# The maximum number of iterations
+max_iter: 10000
+# snapshot intermediate results
+snapshot: 5000
+snapshot_prefix: "snapshot"
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test.prototxt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test.prototxt
new file mode 100644
index 0000000000..72534d20a0
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test.prototxt
@@ -0,0 +1,77 @@
+layer {
+ name: "data"
+ type: "HDF5Data"
+ top: "data"
+ top: "label"
+ hdf5_data_param {
+ source: "ipcai_test_hdf5.h5_list.txt"
+ batch_size: 50
+ }
+}
+layer {
+ name: "fc1"
+ type: "InnerProduct"
+ bottom: "data"
+ top: "fc1"
+ inner_product_param {
+ num_output: 25
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "relu1"
+ type: "ReLU"
+ bottom: "fc1"
+ top: "fc1"
+}
+layer {
+ name: "fc2"
+ type: "InnerProduct"
+ bottom: "fc1"
+ top: "fc2"
+ inner_product_param {
+ num_output: 25
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "relu2"
+ type: "ReLU"
+ bottom: "fc2"
+ top: "fc2"
+}
+layer {
+ name: "score"
+ type: "InnerProduct"
+ bottom: "fc2"
+ top: "score"
+ inner_product_param {
+ num_output: 1
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "loss"
+ type: "EuclideanLoss"
+ bottom: "score"
+ bottom: "label"
+ top: "loss"
+}
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test_hdf5.h5_list.txt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test_hdf5.h5_list.txt
new file mode 100644
index 0000000000..691abad4da
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test_hdf5.h5_list.txt
@@ -0,0 +1 @@
+ipcai_test_hdf5.h5
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test_image.prototxt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test_image.prototxt
new file mode 100644
index 0000000000..6bc1620c4f
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_test_image.prototxt
@@ -0,0 +1,70 @@
+
+layer {
+ name: "data"
+ type: "HDF5Data"
+ top: "data"
+ hdf5_data_param {
+ source: "ipcai_image_hdf5.h5_list.txt"
+ batch_size: 1263612
+ }
+}
+layer {
+ name: "fc1"
+ type: "InnerProduct"
+ bottom: "data"
+ top: "fc1"
+ inner_product_param {
+ num_output: 25
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "relu1"
+ type: "ReLU"
+ bottom: "fc1"
+ top: "fc1"
+}
+layer {
+ name: "fc2"
+ type: "InnerProduct"
+ bottom: "fc1"
+ top: "fc2"
+ inner_product_param {
+ num_output: 25
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "relu2"
+ type: "ReLU"
+ bottom: "fc2"
+ top: "fc2"
+}
+layer {
+ name: "score"
+ type: "InnerProduct"
+ bottom: "fc2"
+ top: "score"
+ inner_product_param {
+ num_output: 1
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_train.prototxt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_train.prototxt
new file mode 100644
index 0000000000..d79b65aa90
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_train.prototxt
@@ -0,0 +1,77 @@
+layer {
+ name: "data"
+ type: "HDF5Data"
+ top: "data"
+ top: "label"
+ hdf5_data_param {
+ source: "ipcai_train_hdf5.h5_list.txt"
+ batch_size: 100
+ }
+}
+layer {
+ name: "fc1"
+ type: "InnerProduct"
+ bottom: "data"
+ top: "fc1"
+ inner_product_param {
+ num_output: 25
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "relu1"
+ type: "ReLU"
+ bottom: "fc1"
+ top: "fc1"
+}
+layer {
+ name: "fc2"
+ type: "InnerProduct"
+ bottom: "fc1"
+ top: "fc2"
+ inner_product_param {
+ num_output: 25
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "relu2"
+ type: "ReLU"
+ bottom: "fc2"
+ top: "fc2"
+}
+layer {
+ name: "score"
+ type: "InnerProduct"
+ bottom: "fc2"
+ top: "score"
+ inner_product_param {
+ num_output: 1
+ weight_filler {
+ type: "xavier"
+ }
+ bias_filler {
+ type: "constant"
+ value: 0.1
+ }
+ }
+}
+layer {
+ name: "loss"
+ type: "EuclideanLoss"
+ bottom: "score"
+ bottom: "label"
+ top: "loss"
+}
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_train_hdf5.h5_list.txt b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_train_hdf5.h5_list.txt
new file mode 100644
index 0000000000..d4b8316827
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/ipcai_train_hdf5.h5_list.txt
@@ -0,0 +1 @@
+ipcai_train_hdf5.h5
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_create_hdf5_database.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_create_hdf5_database.py
new file mode 100644
index 0000000000..3c416e3446
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_create_hdf5_database.py
@@ -0,0 +1,29 @@
+import h5py, os
+import pandas as pd
+
+from regression.preprocessing import preprocess
+
+
+def create_hdf5(path_to_simulation_results, hdf5_name):
+
+ df = pd.read_csv(path_to_simulation_results, header=[0, 1])
+
+ X, y = preprocess(df, snr=10.)
+ y = y.values
+
+ with h5py.File(hdf5_name,'w') as H:
+ H.create_dataset('data', data=X ) # note the name X given to the dataset!
+ H.create_dataset('label', data=y ) # note the name y given to the dataset!
+ with open(hdf5_name + '_list.txt','w') as L:
+ L.write(hdf5_name) # list all h5 files you are going to use
+
+
+data_root = "/media/wirkert/data/Data/2016_02_02_IPCAI/results/intermediate"
+
+TRAIN_IMAGES = os.path.join(data_root,
+ "ipcai_revision_colon_mean_scattering_train_all_spectrocam.txt")
+TEST_IMAGES = os.path.join(data_root,
+ "ipcai_revision_colon_mean_scattering_test_all_spectrocam.txt")
+
+create_hdf5(TRAIN_IMAGES, "ipcai_train_hdf5.h5")
+create_hdf5(TEST_IMAGES, "ipcai_test_hdf5.h5")
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_create_lmdb_database.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_create_lmdb_database.py
new file mode 100644
index 0000000000..ad0160c8ce
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_create_lmdb_database.py
@@ -0,0 +1,52 @@
+
+import os
+
+import pandas as pd
+import lmdb
+import caffe
+
+from regression.preprocessing import preprocess
+
+
+def create_lmdb(path_to_simulation_results, lmdb_name):
+
+ df = pd.read_csv(path_to_simulation_results, header=[0, 1])
+
+ X, y = preprocess(df, snr=10.)
+ y = y.values * 1000
+
+ # We need to prepare the database for the size. We'll set it 10 times
+ # greater than what we theoretically need. There is little drawback to
+ # setting this too big. If you still run into problem after raising
+ # this, you might want to try saving fewer entries in a single
+ # transaction.
+ map_size = X.nbytes * 10
+
+ env = lmdb.open(lmdb_name, map_size=map_size)
+
+ with env.begin(write=True) as txn:
+ # txn is a Transaction object
+ for i in range(X.shape[0]):
+ datum = caffe.proto.caffe_pb2.Datum()
+ datum.channels = X.shape[1]
+ datum.height = 1
+ datum.width = 1
+ datum.data = X[i].tobytes() # or .tostring() if numpy < 1.9
+ datum.label = int(y[i])
+ str_id = '{:08}'.format(i)
+
+ # The encode is only essential in Python 3
+ txn.put(str_id.encode('ascii'), datum.SerializeToString())
+
+
+data_root = "/media/wirkert/data/Data/2016_02_02_IPCAI/results/intermediate"
+
+TRAIN_IMAGES = os.path.join(data_root,
+ "ipcai_revision_colon_mean_scattering_train_all_spectrocam.txt")
+TEST_IMAGES = os.path.join(data_root,
+ "ipcai_revision_colon_mean_scattering_test_all_spectrocam.txt")
+
+create_lmdb(TRAIN_IMAGES, "ipcai_train_lmdb")
+create_lmdb(TEST_IMAGES, "ipcai_test_lmdb")
+
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_test_pretrained_model.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_test_pretrained_model.py
new file mode 100644
index 0000000000..688ad933ec
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_test_pretrained_model.py
@@ -0,0 +1,26 @@
+
+import time
+
+import caffe
+
+from ipcai2016.tasks_common import plot_image
+
+model_def = 'ipcai_test_image.prototxt'
+model_weights = 'snapshot_iter_100000.caffemodel'
+
+net = caffe.Net(model_def, # defines the structure of the model
+ model_weights, # contains the trained weights
+ caffe.TEST) # use test mode (e.g., don't perform dropout)
+
+### perform classification
+
+start = time.time()
+output = net.forward()
+end = time.time()
+estimation_time = end - start
+
+print "time necessary for estimating image parameters: " + str(estimation_time) + "s"
+
+image = output['score'].reshape(1029,1228)
+
+plot_image(image)
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_train_caffe.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_train_caffe.py
new file mode 100644
index 0000000000..c269272502
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_caffe/script_train_caffe.py
@@ -0,0 +1,83 @@
+from pylab import *
+
+import caffe
+from caffe import layers as L, params as P
+
+
+def ipcai(database, batch_size):
+ # our version of LeNet: a series of linear and simple nonlinear transformations
+ n = caffe.NetSpec()
+
+ n.data, n.label = L.HDF5Data(batch_size=batch_size, source=database, ntop=2)
+
+ n.fc1 = L.InnerProduct(n.data, num_output=25, weight_filler=dict(type='xavier'),
+ bias_filler=dict(type='constant', value=0.1))
+ n.relu1 = L.ReLU(n.fc1, in_place=True)
+ n.fc2 = L.InnerProduct(n.relu1, num_output=25, weight_filler=dict(type='xavier'),
+ bias_filler=dict(type='constant', value=0.1))
+ n.relu2 = L.ReLU(n.fc2, in_place=True)
+ n.score = L.InnerProduct(n.relu2, num_output=1, weight_filler=dict(type='xavier'),
+ bias_filler=dict(type='constant', value=0.1))
+ n.loss = L.EuclideanLoss(n.score, n.label)
+
+ return n.to_proto()
+
+with open('ipcai_train.prototxt', 'w') as f:
+ f.write(str(ipcai('ipcai_train_hdf5.h5_list.txt', 100)))
+
+with open('ipcai_test.prototxt', 'w') as f:
+ f.write(str(ipcai('ipcai_test_hdf5.h5_list.txt', 50)))
+
+caffe.set_device(0)
+caffe.set_mode_gpu()
+
+### load the solver and create train and test nets
+solver = None # ignore this workaround for lmdb data (can't instantiate two solvers on the same data)
+solver = caffe.SGDSolver('ipcai_solver.prototxt')
+
+# each output is (batch size, feature dim, spatial dim)
+print [(k, v.data.shape) for k, v in solver.net.blobs.items()]
+
+# just print the weight sizes (we'll omit the biases)
+print [(k, v[0].data.shape) for k, v in solver.net.params.items()]
+
+solver.net.forward() # train net
+print solver.test_nets[0].forward() # test net (there can be more than one)
+
+niter = 100000
+test_interval = 1000
+# losses will also be stored in the log
+train_loss = zeros(niter)
+test_acc = zeros(int(np.ceil(niter / test_interval)))
+output = zeros((niter, 8, 10))
+
+# the main solver loop
+for it in range(niter):
+ solver.step(1) # SGD by Caffe
+
+ # store the train loss
+ train_loss[it] = solver.net.blobs['loss'].data
+
+ # store the output on the first test batch
+ # (start the forward pass at fc1 to avoid loading new data)
+ solver.test_nets[0].forward(start='fc1')
+ output[it] = solver.test_nets[0].blobs['score'].data[:8]
+
+ # run a full test every so often
+ # (Caffe can also do this for us and write to a log, but we show here
+ # how to do it directly in Python, where more complicated things are easier.)
+ if it % test_interval == 0:
+ print 'Iteration', it, 'testing...'
+ mean = 0.
+ for i in range(100):
+ solver.test_nets[0].forward()
+ mean += np.sum(np.abs(np.squeeze(solver.test_nets[0].blobs['score'].data)
+ - solver.test_nets[0].blobs['label'].data))
+ mean = mean / 5000
+ test_acc[it // test_interval] = mean * 100. # %
+
+print "final testing accuracy: ", test_acc[-1]
+
+
+print solver.test_nets[0].blobs['score'].data
+print solver.test_nets[0].blobs['label'].data
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/__init__.py
similarity index 100%
copy from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
copy to Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/input_data.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/input_data.py
new file mode 100644
index 0000000000..d1d0d28e2b
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/input_data.py
@@ -0,0 +1,144 @@
+"""Functions for downloading and reading MNIST data."""
+from __future__ import print_function
+import gzip
+import os
+import urllib
+import numpy
+SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'
+def maybe_download(filename, work_directory):
+ """Download the data from Yann's website, unless it's already here."""
+ if not os.path.exists(work_directory):
+ os.mkdir(work_directory)
+ filepath = os.path.join(work_directory, filename)
+ if not os.path.exists(filepath):
+ filepath, _ = urllib.urlretrieve(SOURCE_URL + filename, filepath)
+ statinfo = os.stat(filepath)
+ print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')
+ return filepath
+def _read32(bytestream):
+ dt = numpy.dtype(numpy.uint32).newbyteorder('>')
+ return numpy.frombuffer(bytestream.read(4), dtype=dt)
+def extract_images(filename):
+ """Extract the images into a 4D uint8 numpy array [index, y, x, depth]."""
+ print('Extracting', filename)
+ with gzip.open(filename) as bytestream:
+ magic = _read32(bytestream)
+ if magic != 2051:
+ raise ValueError(
+ 'Invalid magic number %d in MNIST image file: %s' %
+ (magic, filename))
+ num_images = _read32(bytestream)
+ rows = _read32(bytestream)
+ cols = _read32(bytestream)
+ buf = bytestream.read(rows * cols * num_images)
+ data = numpy.frombuffer(buf, dtype=numpy.uint8)
+ data = data.reshape(num_images, rows, cols, 1)
+ return data
+def dense_to_one_hot(labels_dense, num_classes=10):
+ """Convert class labels from scalars to one-hot vectors."""
+ num_labels = labels_dense.shape[0]
+ index_offset = numpy.arange(num_labels) * num_classes
+ labels_one_hot = numpy.zeros((num_labels, num_classes))
+ labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
+ return labels_one_hot
+def extract_labels(filename, one_hot=False):
+ """Extract the labels into a 1D uint8 numpy array [index]."""
+ print('Extracting', filename)
+ with gzip.open(filename) as bytestream:
+ magic = _read32(bytestream)
+ if magic != 2049:
+ raise ValueError(
+ 'Invalid magic number %d in MNIST label file: %s' %
+ (magic, filename))
+ num_items = _read32(bytestream)
+ buf = bytestream.read(num_items)
+ labels = numpy.frombuffer(buf, dtype=numpy.uint8)
+ if one_hot:
+ return dense_to_one_hot(labels)
+ return labels
+class DataSet(object):
+ def __init__(self, images, labels, fake_data=False):
+ if fake_data:
+ self._num_examples = 10000
+ else:
+ assert images.shape[0] == labels.shape[0], (
+ "images.shape: %s labels.shape: %s" % (images.shape,
+ labels.shape))
+ self._num_examples = images.shape[0]
+ # Convert shape from [num examples, rows, columns, depth]
+ # to [num examples, rows*columns] (assuming depth == 1)
+ assert images.shape[3] == 1
+ images = images.reshape(images.shape[0],
+ images.shape[1] * images.shape[2])
+ # Convert from [0, 255] -> [0.0, 1.0].
+ images = images.astype(numpy.float32)
+ images = numpy.multiply(images, 1.0 / 255.0)
+ self._images = images
+ self._labels = labels
+ self._epochs_completed = 0
+ self._index_in_epoch = 0
+ @property
+ def images(self):
+ return self._images
+ @property
+ def labels(self):
+ return self._labels
+ @property
+ def num_examples(self):
+ return self._num_examples
+ @property
+ def epochs_completed(self):
+ return self._epochs_completed
+ def next_batch(self, batch_size, fake_data=False):
+ """Return the next `batch_size` examples from this data set."""
+ if fake_data:
+ fake_image = [1.0 for _ in xrange(784)]
+ fake_label = 0
+ return [fake_image for _ in xrange(batch_size)], [
+ fake_label for _ in xrange(batch_size)]
+ start = self._index_in_epoch
+ self._index_in_epoch += batch_size
+ if self._index_in_epoch > self._num_examples:
+ # Finished epoch
+ self._epochs_completed += 1
+ # Shuffle the data
+ perm = numpy.arange(self._num_examples)
+ numpy.random.shuffle(perm)
+ self._images = self._images[perm]
+ self._labels = self._labels[perm]
+ # Start next epoch
+ start = 0
+ self._index_in_epoch = batch_size
+ assert batch_size <= self._num_examples
+ end = self._index_in_epoch
+ return self._images[start:end], self._labels[start:end]
+def read_data_sets(train_dir, fake_data=False, one_hot=False):
+ class DataSets(object):
+ pass
+ data_sets = DataSets()
+ if fake_data:
+ data_sets.train = DataSet([], [], fake_data=True)
+ data_sets.validation = DataSet([], [], fake_data=True)
+ data_sets.test = DataSet([], [], fake_data=True)
+ return data_sets
+ TRAIN_IMAGES = 'train-images-idx3-ubyte.gz'
+ TRAIN_LABELS = 'train-labels-idx1-ubyte.gz'
+ TEST_IMAGES = 't10k-images-idx3-ubyte.gz'
+ TEST_LABELS = 't10k-labels-idx1-ubyte.gz'
+ VALIDATION_SIZE = 5000
+ local_file = maybe_download(TRAIN_IMAGES, train_dir)
+ train_images = extract_images(local_file)
+ local_file = maybe_download(TRAIN_LABELS, train_dir)
+ train_labels = extract_labels(local_file, one_hot=one_hot)
+ local_file = maybe_download(TEST_IMAGES, train_dir)
+ test_images = extract_images(local_file)
+ local_file = maybe_download(TEST_LABELS, train_dir)
+ test_labels = extract_labels(local_file, one_hot=one_hot)
+ validation_images = train_images[:VALIDATION_SIZE]
+ validation_labels = train_labels[:VALIDATION_SIZE]
+ train_images = train_images[VALIDATION_SIZE:]
+ train_labels = train_labels[VALIDATION_SIZE:]
+ data_sets.train = DataSet(train_images, train_labels)
+ data_sets.validation = DataSet(validation_images, validation_labels)
+ data_sets.test = DataSet(test_images, test_labels)
+ return data_sets
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/input_ipcai_data.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/input_ipcai_data.py
new file mode 100644
index 0000000000..65429d72ad
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/input_ipcai_data.py
@@ -0,0 +1,103 @@
+"""Functions for downloading and reading ipcai data."""
+from __future__ import print_function
+
+import os
+
+import numpy
+import pandas as pd
+
+from regression.preprocessing import preprocess
+
+
+class DataSet(object):
+ def __init__(self, images, labels, fake_data=False):
+ if fake_data:
+ self._num_examples = 10000
+ else:
+ assert images.shape[0] == labels.shape[0], (
+ "images.shape: %s labels.shape: %s" % (images.shape,
+ labels.shape))
+ self._num_examples = images.shape[0]
+ images = images.astype(numpy.float32)
+ self._images = images
+ self._labels = labels
+ if self._labels.ndim == 1:
+ self._labels = self._labels[:, numpy.newaxis]
+ self._epochs_completed = 0
+ self._index_in_epoch = 0
+
+ @property
+ def images(self):
+ return self._images
+
+ @property
+ def labels(self):
+ return self._labels
+
+ @property
+ def num_examples(self):
+ return self._num_examples
+
+ @property
+ def epochs_completed(self):
+ return self._epochs_completed
+
+ def next_batch(self, batch_size, fake_data=False):
+ """Return the next `batch_size` examples from this data set."""
+ if fake_data:
+ fake_image = [1.0 for _ in xrange(784)]
+ fake_label = 0
+ return [fake_image for _ in xrange(batch_size)], [
+ fake_label for _ in xrange(batch_size)]
+ start = self._index_in_epoch
+ self._index_in_epoch += batch_size
+ if self._index_in_epoch > self._num_examples:
+ # Finished epoch
+ self._epochs_completed += 1
+ # Shuffle the data
+ perm = numpy.arange(self._num_examples)
+ numpy.random.shuffle(perm)
+ self._images = self._images[perm]
+ self._labels = self._labels[perm]
+
+ # Start next epoch
+ start = 0
+ self._index_in_epoch = batch_size
+ assert batch_size <= self._num_examples
+ end = self._index_in_epoch
+ return self._images[start:end], self._labels[start:end]
+
+
+def read_data_sets(dir, fake_data=False):
+
+ class DataSets(object):
+ pass
+ data_sets = DataSets()
+ if fake_data:
+ data_sets.train = DataSet([], [], fake_data=True)
+ data_sets.validation = DataSet([], [], fake_data=True)
+ data_sets.test = DataSet([], [], fake_data=True)
+ return data_sets
+
+ TRAIN_IMAGES = "ipcai_revision_colon_mean_scattering_train_all_spectrocam.txt"
+ TEST_IMAGES = "ipcai_revision_colon_mean_scattering_test_all_spectrocam.txt"
+
+ df_train = pd.read_csv(os.path.join(dir, TRAIN_IMAGES), header=[0, 1])
+ df_test = pd.read_csv(os.path.join(dir, TEST_IMAGES), header=[0, 1])
+
+ train_images, train_labels = preprocess(df_train, snr=10.)
+ test_images, test_labels = preprocess(df_test, snr=10.)
+
+ train_labels = train_labels.values
+ test_labels = test_labels.values
+
+ VALIDATION_SIZE = 1
+
+ validation_images = train_images[:VALIDATION_SIZE]
+ validation_labels = train_labels[:VALIDATION_SIZE]
+ train_images = train_images[VALIDATION_SIZE:]
+ train_labels = train_labels[VALIDATION_SIZE:]
+ data_sets.train = DataSet(train_images, train_labels)
+ data_sets.validation = DataSet(validation_images, validation_labels)
+ data_sets.test = DataSet(test_images, test_labels)
+ return data_sets
\ No newline at end of file
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/script_train_tensorflow_model.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/script_train_tensorflow_model.py
new file mode 100644
index 0000000000..ee85401f73
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_tensorflow/script_train_tensorflow_model.py
@@ -0,0 +1,270 @@
+
+import Image
+import ImageEnhance
+import logging
+import datetime
+
+import SimpleITK as sitk
+import tensorflow as tf
+
+from regression.tensorflow_estimator import multilayer_perceptron, cnn
+from regression.tensorflow_dataset import read_data_set
+from ipcai2016.tasks_common import *
+import commons
+from msi.io.nrrdreader import NrrdReader
+import msi.normalize as norm
+from regression.estimation import estimate_image_tensorflow
+
+sc = commons.ScriptCommons()
+sc.set_root("/media/wirkert/data/Data/2016_02_02_IPCAI/")
+sc.create_folders()
+
+ipcai_dir = sc.get_full_dir("INTERMEDIATES_FOLDER")
+
+sc.add_dir("SMALL_BOWEL_DATA",
+ os.path.join(sc.get_dir("DATA_FOLDER"), "small_bowel_images"))
+
+sc.add_dir("TENSORFLOW_DATA",
+ os.path.join(sc.get_dir("INTERMEDIATES_FOLDER"), "TensorflowModels"))
+
+sc.add_dir("SMALL_BOWEL_RESULT", os.path.join(sc.get_dir("RESULTS_FOLDER"),
+ "small_bowel_tensorflow"))
+
+sc.add_dir("FILTER_TRANSMISSIONS",
+ os.path.join(sc.get_dir("DATA_FOLDER"),
+ "filter_transmissions"))
+
+
+
+def plot_image(image, axis):
+ im2 = axis.imshow(image, interpolation='nearest', alpha=1.0)
+ axis.xaxis.set_visible(False)
+
+
+class TensorFlowCreateOxyImageTask(luigi.Task):
+ image_name = luigi.Parameter()
+ df_prefix = luigi.Parameter()
+ df_test_prefix = luigi.Parameter()
+
+ def requires(self):
+ return TensorflowTrainRegressor(df_prefix=self.df_prefix,
+ df_test_prefix=self.df_test_prefix), \
+ Flatfield(flatfield_folder=sc.get_full_dir("FLAT_FOLDER")), \
+ SingleMultispectralImage(image=self.image_name), \
+ Dark(dark_folder=sc.get_full_dir("DARK_FOLDER"))
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("SMALL_BOWEL_RESULT"),
+ os.path.split(self.image_name)[1] +
+ "_" + self.df_prefix +
+ "_summary" + ".png"))
+
+
+ def run(self):
+ nrrd_reader = NrrdReader()
+ tiff_ring_reader = TiffRingReader()
+ # read the flatfield
+ flat = nrrd_reader.read(self.input()[1].path)
+ dark = nrrd_reader.read(self.input()[3].path)
+ # read the msi
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+ msi, segmentation = tiff_ring_reader.read(self.input()[2].path,
+ nr_filters, resize_factor=0.5)
+ # only take into account not saturated pixels.
+ segmentation = np.logical_and(segmentation,
+ (np.max(msi.get_image(),
+ axis=-1) < 1000.))
+
+ # correct image setup
+ filter_nr = int(self.image_name[-6:-5])
+ original_order = np.arange(nr_filters)
+ new_image_order = np.concatenate((
+ original_order[nr_filters - filter_nr:],
+ original_order[:nr_filters - filter_nr]))
+ # resort msi to restore original order
+ msimani.get_bands(msi, new_image_order)
+ # correct by flatfield
+ msimani.image_correction(msi, flat, dark)
+
+ # create artificial rgb
+ rgb_image = msi.get_image()[:, :, [2, 3, 1]]
+ rgb_image /= np.max(rgb_image)
+ rgb_image *= 255.
+
+ # preprocess the image
+ # sortout unwanted bands
+ print "1"
+ # zero values would lead to infinity logarithm, thus clip.
+ msi.set_image(np.clip(msi.get_image(), 0.00001, 2. ** 64))
+ # normalize to get rid of lighting intensity
+ norm.standard_normalizer.normalize(msi)
+ # transform to absorption
+ msi.set_image(-np.log(msi.get_image()))
+ # normalize by l2 for stability
+ norm.standard_normalizer.normalize(msi, "l2")
+ print "2"
+ # estimate
+ path = sc.get_full_dir("TENSORFLOW_DATA")
+ sitk_image, time = estimate_image_tensorflow(msi, path)
+ image = sitk.GetArrayFromImage(sitk_image)
+
+ plt.figure()
+ print "3"
+ rgb_image = rgb_image.astype(np.uint8)
+ im = Image.fromarray(rgb_image, 'RGB')
+ enh_brightness = ImageEnhance.Brightness(im)
+ im = enh_brightness.enhance(10.)
+ plotted_image = np.array(im)
+ top_left_axis = plt.gca()
+ top_left_axis.imshow(plotted_image, interpolation='nearest')
+ top_left_axis.xaxis.set_visible(False)
+ top_left_axis.yaxis.set_visible(False)
+
+ plt.set_cmap("jet")
+ print "4"
+ # plot parametric maps
+ segmentation[0, 0] = 1
+ segmentation[0, 1] = 1
+ oxy_image = np.ma.masked_array(image[:, :], ~segmentation)
+ oxy_image[np.isnan(oxy_image)] = 0.
+ oxy_image[np.isinf(oxy_image)] = 0.
+ oxy_mean = np.mean(oxy_image)
+ oxy_image[0, 0] = 0.0
+ oxy_image[0, 1] = 1.
+
+ plot_image(oxy_image[:, :], plt.gca())
+
+ df_image_results = pd.DataFrame(data=np.expand_dims([self.image_name,
+ oxy_mean * 100.,
+ time], 0),
+ columns=["image name",
+ "oxygenation mean [%]",
+ "time to estimate"])
+
+ results_file = os.path.join(sc.get_full_dir("SMALL_BOWEL_RESULT"),
+ "results.csv")
+ if os.path.isfile(results_file):
+ df_results = pd.read_csv(results_file, index_col=0)
+ df_results = pd.concat((df_results, df_image_results)).reset_index(
+ drop=True
+ )
+ else:
+ df_results = df_image_results
+
+ df_results.to_csv(results_file)
+
+ plt.savefig(self.output().path,
+ dpi=250, bbox_inches='tight')
+ plt.close("all")
+
+
+class TensorflowTrainRegressor(luigi.Task):
+ df_prefix = luigi.Parameter()
+ df_test_prefix = luigi.Parameter()
+
+ def output(self):
+ return luigi.LocalTarget(os.path.join(sc.get_full_dir("TENSORFLOW_DATA"),
+ "model.ckpt"))
+
+ def requires(self):
+ return tasks_mc.SpectroCamBatch(self.df_prefix), \
+ tasks_mc.SpectroCamBatch(self.df_test_prefix)
+
+ def run(self):
+ # extract data from the batch
+ tensorflow_dataset = read_data_set(self.input()[0].path)
+ test_dataset = read_data_set(self.input()[1].path)
+
+ # train regressor
+ # Construct the desired model
+
+ # Network Parameters
+ nr_filters = len(sc.other["RECORDED_WAVELENGTHS"])
+ x = tf.placeholder("float", [None, nr_filters, 1, 1])
+ # Construct the desired model
+ keep_prob = tf.placeholder("float")
+ # pred, regularizers = multilayer_perceptron(x, nr_filters, 100, 1,
+ # keep_prob)
+ pred = cnn(x, 1, keep_prob)
+ # define parameters
+ learning_rate = 0.0001
+ training_epochs = 300
+ batch_size = 100
+ display_step = 1
+
+ # Define loss and optimizer
+
+ y = tf.placeholder("float", [None, 1])
+ cost = tf.reduce_mean(tf.square(pred - y))
+ optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
+
+ # Initializing the variables
+ init = tf.initialize_all_variables()
+
+ saver = tf.train.Saver() # defaults to saving all variables
+
+ # Launch the graph
+ with tf.Session() as sess:
+ sess.run(init)
+
+ # Training cycle
+ for epoch in range(training_epochs):
+ avg_cost = 0.
+ total_batch = int(tensorflow_dataset.num_examples/batch_size)
+ # Loop over all batches
+ for i in range(total_batch):
+ batch_xs, batch_ys = tensorflow_dataset.next_batch(batch_size)
+ # Fit training using batch data
+ x_image = np.reshape(batch_xs, [-1, nr_filters, 1, 1])
+ sess.run(optimizer, feed_dict={x: x_image, y: batch_ys,
+ keep_prob: 0.75})
+ # Compute average loss
+ avg_cost += sess.run(cost, feed_dict={x: x_image, y: batch_ys,
+ keep_prob: 1.0})/total_batch
+ # Display logs per epoch step
+ if epoch % display_step == 0:
+ print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost)
+
+ # Test model
+ accuracy = tf.reduce_mean(tf.cast(tf.abs(pred-y), "float"))
+ x_test_image = np.reshape(test_dataset.images, [-1, nr_filters, 1, 1])
+ print "Mean testing error:", accuracy.eval({x: x_test_image,
+ y: test_dataset.labels,
+ keep_prob:1.0})
+
+ print "Optimization Finished!"
+ saver.save(sess, self.output().path)
+
+
+if __name__ == '__main__':
+
+ # create a folder for the results if necessary
+ sc.set_root("/media/wirkert/data/Data/2016_02_02_IPCAI/")
+ sc.create_folders()
+
+ # root folder there the data lies
+ logging.basicConfig(filename=os.path.join(sc.get_full_dir("LOG_FOLDER"),
+ "small_bowel_images" +
+ str(datetime.datetime.now()) +
+ '.log'),
+ level=logging.INFO)
+ luigi.interface.setup_interface_logging()
+ ch = logging.StreamHandler()
+ ch.setLevel(logging.INFO)
+ logger = logging.getLogger()
+ logger.addHandler(ch)
+
+ sch = luigi.scheduler.CentralPlannerScheduler()
+ w = luigi.worker.Worker(scheduler=sch)
+
+ # determine files to process
+ files = get_image_files_from_folder(sc.get_full_dir("SMALL_BOWEL_DATA"),
+ suffix="F0.tiff", fullpath=True)
+
+ for f in files:
+ main_task = TensorFlowCreateOxyImageTask(image_name=f,
+ df_prefix="ipcai_revision_colon_mean_scattering_train",
+ df_test_prefix="ipcai_revision_colon_mean_scattering_test")
+ w.add(main_task)
+ w.run()
+
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/__init__.py
similarity index 100%
copy from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
copy to Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/input_icai_data.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/input_icai_data.py
new file mode 100644
index 0000000000..4aaf742da7
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/input_icai_data.py
@@ -0,0 +1,110 @@
+"""
+This tutorial introduces logistic regression using Theano and stochastic
+gradient descent.
+
+Logistic regression is a probabilistic, linear classifier. It is parametrized
+by a weight matrix :math:`W` and a bias vector :math:`b`. Classification is
+done by projecting data points onto a set of hyperplanes, the distance to
+which is used to determine a class membership probability.
+
+Mathematically, this can be written as:
+
+.. math::
+ P(Y=i|x, W,b) &= softmax_i(W x + b) \\
+ &= \frac {e^{W_i x + b_i}} {\sum_j e^{W_j x + b_j}}
+
+
+The output of the model or prediction is then done by taking the argmax of
+the vector whose i'th element is P(Y=i|x).
+
+.. math::
+
+ y_{pred} = argmax_i P(Y=i|x,W,b)
+
+
+This tutorial presents a stochastic gradient descent optimization method
+suitable for large datasets.
+
+
+References:
+
+ - textbooks: "Pattern Recognition and Machine Learning" -
+ Christopher M. Bishop, section 4.3.2
+
+"""
+
+from __future__ import print_function
+
+import os
+
+import numpy
+import pandas as pd
+import numpy as np
+
+import theano
+import theano.tensor as T
+
+from regression.preprocessing import preprocess
+
+__docformat__ = 'restructedtext en'
+
+
+def create_dataset(path_to_simulation_results):
+
+ df = pd.read_csv(path_to_simulation_results, header=[0, 1])
+
+ X, y = preprocess(df, snr=10.)
+ y = y.values
+ return X, y
+
+
+
+def load_data(data_root):
+ ''' Loads the dataset
+
+ :type dataset: string
+ :param dataset: the path to the dataset (here MNIST)
+ '''
+
+ TRAIN_IMAGES = os.path.join(data_root,
+ "ipcai_revision_colon_mean_scattering_train_all_spectrocam.txt")
+ TEST_IMAGES = os.path.join(data_root,
+ "ipcai_revision_colon_mean_scattering_test_all_spectrocam.txt")
+
+ train_set = create_dataset(TRAIN_IMAGES)
+ valid_set = create_dataset(TEST_IMAGES)
+ test_set = (np.load("sample_image.npy"), np.array([0]))
+
+ def shared_dataset(data_xy, borrow=True):
+ """ Function that loads the dataset into shared variables
+
+ The reason we store our dataset in shared variables is to allow
+ Theano to copy it into the GPU memory (when code is run on GPU).
+ Since copying data into the GPU is slow, copying a minibatch everytime
+ is needed (the default behaviour if the data is not in a shared
+ variable) would lead to a large decrease in performance.
+ """
+ data_x, data_y = data_xy
+ shared_x = theano.shared(numpy.asarray(data_x,
+ dtype=theano.config.floatX),
+ borrow=borrow)
+ shared_y = theano.shared(numpy.asarray(data_y,
+ dtype=theano.config.floatX),
+ borrow=borrow)
+ # When storing data on the GPU it has to be stored as floats
+ # therefore we will store the labels as ``floatX`` as well
+ # (``shared_y`` does exactly that). But during our computations
+ # we need them as ints (we use labels as index, and if they are
+ # floats it doesn't make sense) therefore instead of returning
+ # ``shared_y`` we will have to cast it to int. This little hack
+ # lets ous get around this issue
+ return shared_x, shared_y
+
+ test_set_x, test_set_y = shared_dataset(test_set, 0)
+ valid_set_x, valid_set_y = shared_dataset(valid_set)
+ train_set_x, train_set_y = shared_dataset(train_set)
+
+ rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
+ (test_set_x, test_set_y)]
+ return rval
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/logistic_sgd.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/logistic_sgd.py
new file mode 100644
index 0000000000..6ef9f732b3
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/logistic_sgd.py
@@ -0,0 +1,176 @@
+"""
+This tutorial introduces logistic regression using Theano and stochastic
+gradient descent.
+
+Logistic regression is a probabilistic, linear classifier. It is parametrized
+by a weight matrix :math:`W` and a bias vector :math:`b`. Classification is
+done by projecting data points onto a set of hyperplanes, the distance to
+which is used to determine a class membership probability.
+
+Mathematically, this can be written as:
+
+.. math::
+ P(Y=i|x, W,b) &= softmax_i(W x + b) \\
+ &= \frac {e^{W_i x + b_i}} {\sum_j e^{W_j x + b_j}}
+
+
+The output of the model or prediction is then done by taking the argmax of
+the vector whose i'th element is P(Y=i|x).
+
+.. math::
+
+ y_{pred} = argmax_i P(Y=i|x,W,b)
+
+
+This tutorial presents a stochastic gradient descent optimization method
+suitable for large datasets.
+
+
+References:
+
+ - textbooks: "Pattern Recognition and Machine Learning" -
+ Christopher M. Bishop, section 4.3.2
+
+"""
+
+from __future__ import print_function
+
+import numpy
+
+import theano
+import theano.tensor as T
+
+
+__docformat__ = 'restructedtext en'
+
+
+class LogisticRegression(object):
+ """Multi-class Logistic Regression Class
+
+ The logistic regression is fully described by a weight matrix :math:`W`
+ and bias vector :math:`b`. Classification is done by projecting data
+ points onto a set of hyperplanes, the distance to which is used to
+ determine a class membership probability.
+ """
+
+ def __init__(self, input, n_in, n_out):
+ """ Initialize the parameters of the logistic regression
+
+ :type input: theano.tensor.TensorType
+ :param input: symbolic variable that describes the input of the
+ architecture (one minibatch)
+
+ :type n_in: int
+ :param n_in: number of input units, the dimension of the space in
+ which the datapoints lie
+
+ :type n_out: int
+ :param n_out: number of output units, the dimension of the space in
+ which the labels lie
+
+ """
+ # start-snippet-1
+ # initialize with 0 the weights W as a matrix of shape (n_in, n_out)
+ self.W = theano.shared(
+ value=numpy.zeros(
+ (n_in, n_out),
+ dtype=theano.config.floatX
+ ),
+ name='W',
+ borrow=True
+ )
+ # initialize the biases b as a vector of n_out 0s
+ self.b = theano.shared(
+ value=numpy.zeros(
+ (n_out,),
+ dtype=theano.config.floatX
+ ),
+ name='b',
+ borrow=True
+ )
+
+ # symbolic expression for computing the matrix of class-membership
+ # probabilities
+ # Where:
+ # W is a matrix where column-k represent the separation hyperplane for
+ # class-k
+ # x is a matrix where row-j represents input training sample-j
+ # b is a vector where element-k represent the free parameter of
+ # hyperplane-k
+ #self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
+ self.p_y_given_x = T.max(T.dot(input, self.W) + self.b, axis = 1)
+
+
+ # symbolic description of how to compute prediction as class whose
+ # probability is maximal
+ self.y_pred = self.p_y_given_x
+ #self.y_pred = self.p_y_given_x
+ # end-snippet-1
+
+ # parameters of the model
+ self.params = [self.W, self.b]
+
+ # keep track of model input
+ self.input = input
+
+ def negative_log_likelihood(self, y):
+ """Return the mean of the negative log-likelihood of the prediction
+ of this model under a given target distribution.
+
+ .. math::
+
+ \frac{1}{|\mathcal{D}|} \mathcal{L} (\theta=\{W,b\}, \mathcal{D}) =
+ \frac{1}{|\mathcal{D}|} \sum_{i=0}^{|\mathcal{D}|}
+ \log(P(Y=y^{(i)}|x^{(i)}, W,b)) \\
+ \ell (\theta=\{W,b\}, \mathcal{D})
+
+ :type y: theano.tensor.TensorType
+ :param y: corresponds to a vector that gives for each example the
+ correct label
+
+ Note: we use the mean instead of the sum so that
+ the learning rate is less dependent on the batch size
+ """
+ # start-snippet-2
+ # y.shape[0] is (symbolically) the number of rows in y, i.e.,
+ # number of examples (call it n) in the minibatch
+ # T.arange(y.shape[0]) is a symbolic vector which will contain
+ # [0,1,2,... n-1] T.log(self.p_y_given_x) is a matrix of
+ # Log-Probabilities (call it LP) with one row per example and
+ # one column per class LP[T.arange(y.shape[0]),y] is a vector
+ # v containing [LP[0,y[0]], LP[1,y[1]], LP[2,y[2]], ...,
+ # LP[n-1,y[n-1]]] and T.mean(LP[T.arange(y.shape[0]),y]) is
+ # the mean (across minibatch examples) of the elements in v,
+ # i.e., the mean log-likelihood across the minibatch.
+ theano.printing.Print('p_y_given_x')(self.p_y_given_x)
+ theano.printing.Print('y')(y)
+ return T.mean(T.square(self.p_y_given_x - y))
+ #return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]), y])
+ # end-snippet-2
+
+ def errors(self, y):
+ """Return a float representing the number of errors in the minibatch
+ over the total number of examples of the minibatch ; zero one
+ loss over the size of the minibatch
+
+ :type y: theano.tensor.TensorType
+ :param y: corresponds to a vector that gives for each example the
+ correct label
+ """
+
+ # check if y has same dimension of y_pred
+ if y.ndim != self.y_pred.ndim:
+ raise TypeError(
+ 'y should have the same shape as self.y_pred',
+ ('y', y.type, 'y_pred', self.y_pred.type)
+ )
+ # check if y is of the correct datatype
+ if y.dtype.startswith('float'):
+ # the T.neq operator returns a vector of 0s and 1s, where 1
+ # represents a mistake in prediction
+ return T.mean(T.abs_(self.y_pred - y))
+ else:
+ raise NotImplementedError()
+
+
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/script_train_theano_model.py b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/script_train_theano_model.py
new file mode 100644
index 0000000000..32c2a7045e
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/ipcai_to_theano/script_train_theano_model.py
@@ -0,0 +1,445 @@
+
+
+"""
+This tutorial introduces the multilayer perceptron using Theano.
+
+ A multilayer perceptron is a logistic regressor where
+instead of feeding the input to the logistic regression you insert a
+intermediate layer, called the hidden layer, that has a nonlinear
+activation function (usually tanh or sigmoid) . One can use many such
+hidden layers making the architecture deep. The tutorial will also tackle
+the problem of MNIST digit classification.
+
+.. math::
+
+ f(x) = G( b^{(2)} + W^{(2)}( s( b^{(1)} + W^{(1)} x))),
+
+References:
+
+ - textbooks: "Pattern Recognition and Machine Learning" -
+ Christopher M. Bishop, section 5
+
+"""
+
+from __future__ import print_function
+
+import os
+import sys
+import timeit
+import time
+
+import numpy
+import numpy as np
+import matplotlib.pylab as plt
+import theano
+import theano.tensor as T
+
+
+from logistic_sgd import LogisticRegression
+from input_icai_data import load_data
+from ipcai2016.tasks_common import plot_image
+
+#theano.config.compute_test_value = 'warn'
+#theano.config.mode = "FAST_COMPILE"
+#theano.config.exception_verbosity='high'
+
+__docformat__ = 'restructedtext en'
+
+
+# start-snippet-1
+class HiddenLayer(object):
+ def __init__(self, rng, input, n_in, n_out, W=None, b=None,
+ activation=T.tanh):
+ """
+ Typical hidden layer of a MLP: units are fully-connected and have
+ sigmoidal activation function. Weight matrix W is of shape (n_in,n_out)
+ and the bias vector b is of shape (n_out,).
+
+ NOTE : The nonlinearity used here is tanh
+
+ Hidden unit activation is given by: tanh(dot(input,W) + b)
+
+ :type rng: numpy.random.RandomState
+ :param rng: a random number generator used to initialize weights
+
+ :type input: theano.tensor.dmatrix
+ :param input: a symbolic tensor of shape (n_examples, n_in)
+
+ :type n_in: int
+ :param n_in: dimensionality of input
+
+ :type n_out: int
+ :param n_out: number of hidden units
+
+ :type activation: theano.Op or function
+ :param activation: Non linearity to be applied in the hidden
+ layer
+ """
+ self.input = input
+ # end-snippet-1
+
+ # `W` is initialized with `W_values` which is uniformely sampled
+ # from sqrt(-6./(n_in+n_hidden)) and sqrt(6./(n_in+n_hidden))
+ # for tanh activation function
+ # the output of uniform if converted using asarray to dtype
+ # theano.config.floatX so that the code is runable on GPU
+ # Note : optimal initialization of weights is dependent on the
+ # activation function used (among other things).
+ # For example, results presented in [Xavier10] suggest that you
+ # should use 4 times larger initial weights for sigmoid
+ # compared to tanh
+ # We have no info for other function, so we use the same as
+ # tanh.
+ if W is None:
+ W_values = numpy.asarray(
+ rng.uniform(
+ low=-numpy.sqrt(6. / (n_in + n_out)),
+ high=numpy.sqrt(6. / (n_in + n_out)),
+ size=(n_in, n_out)
+ ),
+ dtype=theano.config.floatX
+ )
+ if activation == theano.tensor.nnet.sigmoid:
+ W_values *= 4
+
+ W = theano.shared(value=W_values, name='W', borrow=True)
+
+ if b is None:
+ b_values = 0.1+numpy.zeros((n_out,), dtype=theano.config.floatX)
+ b = theano.shared(value=b_values, name='b', borrow=True)
+
+ self.W = W
+ self.b = b
+
+ lin_output = T.dot(input, self.W) + self.b
+ self.output = (
+ lin_output if activation is None
+ else activation(lin_output)
+ )
+ # parameters of the model
+ self.params = [self.W, self.b]
+
+
+# start-snippet-2
+class MLP(object):
+ """Multi-Layer Perceptron Class
+
+ A multilayer perceptron is a feedforward artificial neural network model
+ that has one layer or more of hidden units and nonlinear activations.
+ Intermediate layers usually have as activation function tanh or the
+ sigmoid function (defined here by a ``HiddenLayer`` class) while the
+ top layer is a softmax layer (defined here by a ``LogisticRegression``
+ class).
+ """
+
+ def __init__(self, rng, input, n_in, n_hidden, n_out):
+ """Initialize the parameters for the multilayer perceptron
+
+ :type rng: numpy.random.RandomState
+ :param rng: a random number generator used to initialize weights
+
+ :type input: theano.tensor.TensorType
+ :param input: symbolic variable that describes the input of the
+ architecture (one minibatch)
+
+ :type n_in: int
+ :param n_in: number of input units, the dimension of the space in
+ which the datapoints lie
+
+ :type n_hidden: int
+ :param n_hidden: number of hidden units
+
+ :type n_out: int
+ :param n_out: number of output units, the dimension of the space in
+ which the labels lie
+
+ """
+
+ # Since we are dealing with a one hidden layer MLP, this will translate
+ # into a HiddenLayer with a tanh activation function connected to the
+ # LogisticRegression layer; the activation function can be replaced by
+ # sigmoid or any other nonlinear function
+ self.hiddenLayer1 = HiddenLayer(
+ rng=rng,
+ input=input,
+ n_in=n_in,
+ n_out=n_hidden,
+ activation=T.nnet.relu
+ )
+
+ self.hiddenLayer2 = HiddenLayer(
+ rng=rng,
+ input=self.hiddenLayer1.output,
+ n_in=n_hidden,
+ n_out=n_hidden,
+ activation=T.nnet.relu
+ )
+
+ # The logistic regression layer gets as input the hidden units
+ # of the hidden layer
+ self.logRegressionLayer = LogisticRegression(
+ input=self.hiddenLayer2.output,
+ n_in=n_hidden,
+ n_out=n_out
+ )
+ # end-snippet-2 start-snippet-3
+ # L1 norm ; one regularization option is to enforce L1 norm to
+ # be small
+ self.L1 = (
+ abs(self.hiddenLayer1.W).sum()
+ + abs(self.hiddenLayer2.W).sum()
+ + abs(self.logRegressionLayer.W).sum()
+ )
+
+ # square of L2 norm ; one regularization option is to enforce
+ # square of L2 norm to be small
+ self.L2_sqr = (
+ (self.hiddenLayer1.W ** 2).sum()
+ + (self.hiddenLayer2.W ** 2).sum()
+ + (self.logRegressionLayer.W ** 2).sum()
+ )
+
+ # negative log likelihood of the MLP is given by the negative
+ # log likelihood of the output of the model, computed in the
+ # logistic regression layer
+ self.negative_log_likelihood = (
+ self.logRegressionLayer.negative_log_likelihood
+ )
+ # same holds for the function computing the number of errors
+ self.errors = self.logRegressionLayer.errors
+
+ self.y_pred = self.logRegressionLayer.y_pred
+
+ # the parameters of the model are the parameters of the two layer it is
+ # made out of
+ self.params = self.hiddenLayer1.params +\
+ self.hiddenLayer2.params +\
+ self.logRegressionLayer.params
+ # end-snippet-3
+
+ # keep track of model input
+ self.input = input
+
+
+def test_mlp(learning_rate=0.001, L1_reg=0.0001, L2_reg=0.0001, n_epochs=1000,
+ dataset="/media/wirkert/data/Data/2016_02_02_IPCAI/results/intermediate",
+ batch_size=20, n_hidden=25,
+ do_timing_test=False):
+ """
+ Demonstrate stochastic gradient descent optimization for a multilayer
+ perceptron
+
+ This is demonstrated on MNIST.
+
+ :type learning_rate: float
+ :param learning_rate: learning rate used (factor for the stochastic
+ gradient
+
+ :type L1_reg: float
+ :param L1_reg: L1-norm's weight when added to the cost (see
+ regularization)
+
+ :type L2_reg: float
+ :param L2_reg: L2-norm's weight when added to the cost (see
+ regularization)
+
+ :type n_epochs: int
+ :param n_epochs: maximal number of epochs to run the optimizer
+
+ :type dataset: string
+ :param dataset: the path of the MNIST dataset file from
+ http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz
+
+
+ """
+
+ datasets = load_data(dataset)
+
+ train_set_x, train_set_y = datasets[0]
+ valid_set_x, valid_set_y = datasets[1]
+ test_set_x, test_set_y = datasets[2]
+
+ # compute number of minibatches for training and validation
+ n_train_batches = train_set_x.get_value(borrow=True).shape[0] // batch_size
+ n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] // batch_size
+
+ ######################
+ # BUILD ACTUAL MODEL #
+ ######################
+ print('... building the model')
+
+ # allocate symbolic variables for the data
+ index = T.lscalar() # index to a [mini]batch
+ x = T.matrix('x') # the data is presented as rasterized images
+ x.tag.test_value = np.zeros((5000, 8)).astype('float32')
+ y = T.vector('y') # the labels are presented as 1D vector of
+ # [int] labels
+ y.tag.test_value = np.ones(5000).astype('float32')
+
+ rng = numpy.random.RandomState(1234)
+
+ # construct the MLP class
+ classifier = MLP(
+ rng=rng,
+ input=x,
+ n_in=8,
+ n_hidden=n_hidden,
+ n_out=1
+ )
+
+ # start-snippet-4
+ # the cost we minimize during training is the negative log likelihood of
+ # the model plus the regularization terms (L1 and L2); cost is expressed
+ # here symbolically
+ cost = (
+ classifier.negative_log_likelihood(y)
+ + L1_reg * classifier.L1
+ + L2_reg * classifier.L2_sqr
+ )
+ # end-snippet-4
+
+ # compiling a Theano function that computes the mistakes that are made
+ # by the model on a minibatch
+ test_model = theano.function(
+ inputs=[],
+ outputs=classifier.y_pred,
+ givens={
+ x: test_set_x
+ }
+ )
+
+ validate_model = theano.function(
+ inputs=[index],
+ outputs=classifier.errors(y),
+ givens={
+ x: valid_set_x[index * batch_size:(index + 1) * batch_size],
+ y: valid_set_y[index * batch_size:(index + 1) * batch_size]
+ }
+ )
+
+ # start-snippet-5
+ # compute the gradient of cost with respect to theta (sorted in params)
+ # the resulting gradients will be stored in a list gparams
+ gparams = [T.grad(cost, param) for param in classifier.params]
+
+ # specify how to update the parameters of the model as a list of
+ # (variable, update expression) pairs
+
+ # given two lists of the same length, A = [a1, a2, a3, a4] and
+ # B = [b1, b2, b3, b4], zip generates a list C of same size, where each
+ # element is a pair formed from the two lists :
+ # C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)]
+ updates = [
+ (param, param - learning_rate * gparam)
+ for param, gparam in zip(classifier.params, gparams)
+ ]
+
+ # compiling a Theano function `train_model` that returns the cost, but
+ # in the same time updates the parameter of the model based on the rules
+ # defined in `updates`
+ train_model = theano.function(
+ inputs=[index],
+ outputs=cost,
+ updates=updates,
+ givens={
+ x: train_set_x[index * batch_size: (index + 1) * batch_size],
+ y: train_set_y[index * batch_size: (index + 1) * batch_size]
+ }
+ )
+ # end-snippet-5
+
+ ###############
+ # TRAIN MODEL #
+ ###############
+ print('... training')
+
+ # early-stopping parameters
+ patience = 10000 # look as this many examples regardless
+ patience_increase = 2 # wait this much longer when a new best is
+ # found
+ improvement_threshold = 0.995 # a relative improvement of this much is
+ # considered significant
+ validation_frequency = min(n_train_batches, patience // 2)
+ # go through this many
+ # minibatche before checking the network
+ # on the validation set; in this case we
+ # check every epoch
+
+ best_validation_loss = numpy.inf
+ best_iter = 0
+ test_score = 0.
+ start_time = timeit.default_timer()
+
+ epoch = 0
+ done_looping = False
+
+ while (epoch < n_epochs):# and (not done_looping):
+ epoch = epoch + 1
+ for minibatch_index in range(n_train_batches):
+
+ minibatch_avg_cost = train_model(minibatch_index)
+ # iteration number
+ iter = (epoch - 1) * n_train_batches + minibatch_index
+
+ if (iter + 1) % validation_frequency == 0:
+ # compute zero-one loss on validation set
+ validation_losses = [validate_model(i) for i
+ in range(n_valid_batches)]
+ this_validation_loss = numpy.mean(validation_losses)
+
+ print(
+ 'epoch %i, minibatch %i/%i, validation error %f %%' %
+ (
+ epoch,
+ minibatch_index + 1,
+ n_train_batches,
+ this_validation_loss * 100.
+ )
+ )
+
+ # if we got the best validation score until now
+ if this_validation_loss < best_validation_loss:
+ #improve patience if loss improvement is good enough
+ if (
+ this_validation_loss < best_validation_loss *
+ improvement_threshold
+ ):
+ patience = max(patience, iter * patience_increase)
+
+ best_validation_loss = this_validation_loss
+ best_iter = iter
+
+ if do_timing_test:
+ # test it on the test set
+ start = time.time()
+ test_predictions = test_model()
+ end = time.time()
+ estimation_time = end - start
+ print("time necessary for estimating image parameters: " +
+ str(estimation_time) + "s")
+ print(test_predictions.shape)
+
+ if patience <= iter:
+ done_looping = True
+ #break
+
+ end_time = timeit.default_timer()
+ print(('Optimization complete. Best validation score of %f %% '
+ 'obtained at iteration %i, with test performance %f %%') %
+ (best_validation_loss * 100., best_iter + 1, test_score * 100.))
+ print(('The code for file ' +
+ os.path.split(__file__)[1] +
+ ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr)
+
+ test_predictions = test_model()
+ image = test_predictions.reshape(1029,1228)
+ image[0, 0] = 0.0
+ image[0, 1] = 1.
+ image = np.clip(image, 0., 1.)
+ plot_image(image)
+ plt.savefig("sample_image.png",
+ dpi=250, bbox_inches='tight')
+
+if __name__ == '__main__':
+ test_mlp()
+
diff --git a/Modules/Biophotonics/python/inverseMonteCarlo/__init__.py b/Modules/Biophotonics/python/iMC/scripts/spielewiese/__init__.py
similarity index 100%
rename from Modules/Biophotonics/python/inverseMonteCarlo/__init__.py
rename to Modules/Biophotonics/python/iMC/scripts/spielewiese/__init__.py
diff --git a/Modules/Biophotonics/python/iMC/scripts/spielewiese/monte_carlo_single_photon.py b/Modules/Biophotonics/python/iMC/scripts/spielewiese/monte_carlo_single_photon.py
new file mode 100644
index 0000000000..05f0afc7dd
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/spielewiese/monte_carlo_single_photon.py
@@ -0,0 +1,203 @@
+from collections import OrderedDict
+import numpy as np
+
+import theano
+from theano.ifelse import ifelse
+import theano.tensor as T
+import theano.tensor.inplace as inplace
+#from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
+from theano.tensor.shared_randomstreams import RandomStreams
+import time
+
+
+#theano.config.compute_test_value = 'warn'
+#theano.config.exception_verbosity='high'
+#theano.config.profile=True
+#theano.config.mode = "FAST_RUN"
+#theano.config.mode = "FAST_COMPILE"
+#theano.config.scan.allow_gc =True
+#theano.config.scan.allow_output_prealloc =False
+#theano.optimizer_excluding="more_mem"
+
+# initializing
+rng = RandomStreams(seed=234)
+photons = 10**6
+SHELL_MAX = 101
+
+
+mu_a = T.scalar('mu_a')
+# provide Theano with a default test-value
+mu_a.tag.test_value = 2.
+mu_s = T.scalar('mu_s')
+mu_s.tag.test_value = 20.
+microns_per_shell = T.scalar('microns_per_shell')
+microns_per_shell.tag.test_value = 50.
+
+albedo = mu_s / (mu_s + mu_a)
+shells_per_mfp = 1e4/microns_per_shell/(mu_a+mu_s)
+
+heat = theano.shared(np.zeros(SHELL_MAX, dtype=theano.config.floatX))
+
+x = T.scalar('x')
+x.tag.test_value = 0
+
+y = T.scalar('y')
+y.tag.test_value = 0
+
+z = T.scalar('z')
+z.tag.test_value = 0
+
+u = T.scalar('u')
+u.tag.test_value = 0
+
+v = T.scalar('v')
+v.tag.test_value = 0
+
+w = T.scalar('w')
+w.tag.test_value = 1
+
+weight = T.scalar('weight')
+weight.tag.test_value = 1
+
+
+def one_run(my_x, my_y, my_z,
+ my_u, my_v, my_w,
+ my_weight,
+ my_heat, my_albedo, my_microns_per_shell):
+
+ # move
+ random = rng.uniform(low=0.00003, high=1.)
+ t = -T.log(random)
+
+ x_moved = my_x + my_u*t
+ y_moved = my_y + my_v*t
+ z_moved = my_z + my_w*t
+
+ # absorb
+ shell = T.cast(T.sqrt(T.sqr(x_moved) + T.sqr(y_moved) + T.sqr(z_moved))
+ * my_microns_per_shell, 'int32')
+ shell = T.clip(shell, 0, SHELL_MAX-1)
+
+ new_weight = my_weight * my_albedo
+
+ # new direction
+ xi1 = rng.uniform(low=-1., high=1.)
+ xi2 = rng.uniform(low=-1., high=1.)
+ xi_norm = T.sqrt(T.sqr(xi1) + T.sqr(xi2))
+
+ t_xi = rng.uniform(low=0.000000001, high=1.)
+
+ # rescale xi12 to fit t_xi as norm
+ xi1 = xi1/xi_norm * T.sqr(t_xi)
+ xi2 = xi2/xi_norm * T.sqr(t_xi)
+
+ u_new_direction = 2. * t_xi - 1.
+ v_new_direction = xi1 * T.sqrt((1. - T.sqr(u_new_direction)) / t_xi)
+ w_new_direction = xi2 * T.sqrt((1. - T.sqr(u_new_direction)) / t_xi)
+
+ # roulette
+ weight_for_starting_roulette = 0.001
+ CHANCE = 0.1
+ partakes_roulette = T.switch(T.lt(new_weight, weight_for_starting_roulette),
+ 1,
+ 0)
+ roulette = rng.uniform(low=0., high=1.)
+ loses_roulette = T.gt(roulette, CHANCE)
+ # if roulette decides to terminate the photon: set weight to 0
+ weight_after_roulette = ifelse(T.and_(partakes_roulette, loses_roulette),
+ 0.,
+ new_weight)
+ # if partakes in roulette but does not get terminated
+ weight_after_roulette = ifelse(T.and_(partakes_roulette, T.invert(loses_roulette)),
+ weight_after_roulette / CHANCE,
+ weight_after_roulette)
+
+ new_heat = (1.0 - my_albedo) * my_weight
+ heat_i = my_heat[shell]
+
+ return (x_moved, y_moved, z_moved,\
+ u_new_direction, v_new_direction, w_new_direction,\
+ weight_after_roulette),\
+ OrderedDict({my_heat: T.inc_subtensor(heat_i, new_heat)})
+
+
+# one_photon_results, one_photon_updates = theano.scan(fn=one_run,
+# outputs_info=[T.zeros_like(x),
+# T.zeros_like(y),
+# T.zeros_like(z),
+# T.zeros_like(u),
+# T.zeros_like(v),
+# T.ones_like(w),
+# T.ones_like(weight)],
+# non_sequences=[heat,
+# albedo,
+# microns_per_shell],
+# n_steps=100,
+# strict=True)
+#
+# final_one_photon_heat_result = one_photon_updates[heat]
+
+# heat_for_one_photon = theano.function(inputs=[x, y, z,
+# u, v, w,
+# weight,
+# mu_a, mu_s, microns_per_shell],
+# outputs=final_one_photon_heat_result,
+# updates=one_photon_updates)
+
+
+def all_runs(my_x, my_y, my_z,
+ my_u, my_v, my_w,
+ my_weight,
+ my_heat,
+ my_albedo, my_microns_per_shell):
+ my_one_photon_results, my_one_photon_updates = theano.scan(fn=one_run,
+ outputs_info=[T.zeros_like(my_x),
+ T.zeros_like(my_y),
+ T.zeros_like(my_z),
+ T.zeros_like(my_u),
+ T.zeros_like(my_v),
+ T.ones_like(my_w),
+ T.ones_like(my_weight)],
+ non_sequences=[my_heat,
+ my_albedo,
+ my_microns_per_shell],
+ n_steps=10,
+ strict=True)
+ return {my_heat: my_one_photon_updates[my_heat]}
+
+
+all_photon_results, all_photon_updates = theano.scan(fn=all_runs,
+ outputs_info=None,
+ non_sequences=[x, y, z,
+ u, v, w,
+ weight,
+ heat,
+ albedo, microns_per_shell],
+ n_steps=10,
+ strict=True)
+
+
+heat_for_all_photons = theano.function(inputs=[x, y, z,
+ u, v, w,
+ weight,
+ mu_a, mu_s, microns_per_shell],
+ outputs=all_photon_updates[heat],
+ updates=all_photon_updates)
+
+
+
+
+
+start = time.time()
+
+print("start simulation")
+
+print(heat_for_all_photons(0., 0., 0.,
+ 0., 0., 1.,
+ 1.,
+ 2., 20., 50.))
+
+end = time.time()
+print("end simulation after: " + str(end - start) + " seconds")
+
+
diff --git a/Modules/Biophotonics/python/iMC/scripts/spielewiese/spielewiese.py b/Modules/Biophotonics/python/iMC/scripts/spielewiese/spielewiese.py
new file mode 100644
index 0000000000..871864547f
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/scripts/spielewiese/spielewiese.py
@@ -0,0 +1,130 @@
+from collections import OrderedDict
+import numpy as np
+
+import theano
+import theano.tensor as T
+from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
+#from theano.tensor.shared_randomstreams import RandomStreams
+import time
+
+#theano.config.compute_test_value = 'warn'
+#theano.config.exception_verbosity='high'
+# initializing
+rng = RandomStreams(seed=234)
+photons = 10**6
+SHELL_MAX = 101
+
+mu_a = T.scalar('mu_a')
+# provide Theano with a default test-value
+mu_a.tag.test_value = 2.
+mu_s = T.scalar('mu_s')
+mu_s.tag.test_value = 20.
+microns_per_shell = T.scalar('microns_per_shell')
+microns_per_shell.tag.test_value = 50.
+
+albedo = mu_s / (mu_s + mu_a)
+shells_per_mfp = 1e4/microns_per_shell/(mu_a+mu_s)
+
+
+
+
+finished = theano.shared(np.array(0, dtype='int8'))
+
+xyz = theano.shared(np.zeros((photons,3), dtype=theano.config.floatX))
+
+uvw_np = np.zeros((photons,3), dtype=theano.config.floatX)
+uvw_np[:,2] = 1. # w = 1
+uvw = theano.shared(uvw_np)
+
+#weights_np = np.ones((photons,1), dtype=theano.config.floatX)
+weight = theano.shared(np.ones((photons,1), dtype=theano.config.floatX))
+
+heat_np = np.zeros((SHELL_MAX,1), dtype=theano.config.floatX)
+heat = theano.shared(heat_np)
+
+
+
+
+
+
+
+
+# while sum alive > 0
+
+def l2_norm_along_columns(A):
+ A_normed = T.sqrt(T.sum(T.sqr(A), axis=1))
+ A_normed = A_normed.reshape((photons, 1))
+ return A_normed
+
+# move
+random = rng.uniform((photons,1), low=0.00003, high=1.)
+t = -T.log(random)
+t = T.addbroadcast(t, 1)
+
+xyz_moved = xyz + uvw*t
+#theano.printing.Print('xyz_moved')(xyz_moved)
+
+# absorb
+shells = T.cast(l2_norm_along_columns(xyz_moved) * shells_per_mfp,
+ 'int32')
+shells = T.clip(shells, 0, SHELL_MAX-1)
+new_heats = (1.0 - albedo) * weight
+new_weight = weight * albedo
+theano.printing.Print('shells')(shells)
+
+# new direction
+xi12 = rng.uniform((photons,2), low=-1., high=1.)
+xi_norm = l2_norm_along_columns(xi12)
+
+t_xi = rng.uniform((photons,1), low=0.000000001, high=1.)
+t_xi = T.addbroadcast(t_xi, 1)
+
+# rescale xi12 to fit t_xi as norm
+xi12 = xi12/xi_norm * T.sqr(t_xi)
+
+u_new_direction = 2. * t_xi - 1.
+vw_new_direction = xi12 * T.sqrt((1. - T.sqr(u_new_direction)) / t_xi)
+uvw_new_direction = T.concatenate([u_new_direction, vw_new_direction], axis=1)
+
+#theano.printing.Print('t_xi')(t_xi)
+#theano.printing.Print('vw')(vw_new_direction)
+#theano.printing.Print('uvw')(uvw_new_direction)
+# roulette
+weight_for_starting_roulette = 0.001
+CHANCE = 0.1
+partakes_roulette = T.switch(T.lt(new_weight, weight_for_starting_roulette),
+ 1,
+ 0)
+roulette = rng.uniform((photons,1), low=0., high=1.)
+loses_roulette = T.gt(roulette, CHANCE)
+# if roulette decides to ter+minate the photon: set weight to 0
+weight_after_roulette = T.switch(T.and_(partakes_roulette, loses_roulette),
+ 0.,
+ new_weight)
+# if partakes in roulette but does not get terminated
+weight_after_roulette = T.switch(T.and_(partakes_roulette, T.invert(loses_roulette)),
+ weight_after_roulette / CHANCE,
+ weight_after_roulette)
+#theano.printing.Print('new weight')(new_weight)
+#theano.printing.Print('partakes_roulette')(partakes_roulette)
+#theano.printing.Print('loses_roulette')(loses_roulette)
+#theano.printing.Print('weight_after_roulette')(weight_after_roulette)
+
+
+one_cycle = theano.function(inputs=[mu_a, mu_s, microns_per_shell],
+ outputs=[shells, new_heats],
+ updates=OrderedDict({xyz: xyz_moved, uvw: uvw_new_direction,
+ weight: weight_after_roulette,
+ finished: T.allclose(weight, 0.)}))
+
+
+start = time.time()
+print("start simulation")
+
+while not finished.get_value():
+ new_shells, new_heats = one_cycle(2, 20, 50)
+
+end = time.time()
+print("end simulation after: " + str(end - start) + " seconds")
+
+
diff --git a/Modules/Biophotonics/python/iMC/setup.py b/Modules/Biophotonics/python/iMC/setup.py
new file mode 100644
index 0000000000..9e04fc9ca8
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/setup.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug 7 18:41:50 2015
+
+@author: wirkert
+"""
+
+from setuptools import setup, find_packages
+
+setup(name='MITK-MSI',
+ version='0.1',
+ description='Multi spectral imaging (MSI) utilities',
+ author='Sebastian Wirkert',
+ author_email='s.wirkert@dkfz-heidelberg.de',
+ license='BSD',
+ packages=find_packages(exclude=['test*']),
+ package_dir={},
+ package_data={'data': ['*.txt', '*.mci', '*.nrrd']},
+ install_requires=['numpy>=1.10.2', 'scipy', 'scikit-learn>=0.17',
+ 'SimpleITK>=0.9.0', 'subprocess32',
+ 'pypng', 'pandas>0.17', 'libtiff'],
+ entry_points={} # for scripts, add later
+ )
diff --git a/Modules/Biophotonics/python/iMC/tox.ini b/Modules/Biophotonics/python/iMC/tox.ini
new file mode 100644
index 0000000000..51e0c9f594
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/tox.ini
@@ -0,0 +1,9 @@
+# content of: tox.ini , put in same dir as setup.py
+[tox]
+envlist = py27
+[testenv]
+deps=discover # install pytest in the venvs
+install_command=pip install -f http://www.simpleitk.org/SimpleITK/resources/software.html --trusted-host www.simpleitk.org {opts} {packages}
+#changedir=tests
+commands=discover
+
diff --git a/Modules/Biophotonics/python/iMC/tutorials/Monte Carlo Spectra Generation - Basic tutorial.ipynb b/Modules/Biophotonics/python/iMC/tutorials/Monte Carlo Spectra Generation - Basic tutorial.ipynb
new file mode 100644
index 0000000000..e5ea2b6e52
--- /dev/null
+++ b/Modules/Biophotonics/python/iMC/tutorials/Monte Carlo Spectra Generation - Basic tutorial.ipynb
@@ -0,0 +1,1018 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Creating and manipulating monte carlo spectra using MITK-MSI\n",
+ "\n",
+ "In this tutorial we will learn how to\n",
+ "1. create reflectance spectra from examplary tissues\n",
+ "2. how to analyse and visualize the created spectra\n",
+ "3. how to manipulate them\n",
+ "\n",
+ "The MITK-MSI software provides a wrapper to the popular MCML approach to simulate how light travels through tissue. This wrapper can be found in mc/sim.py.\n",
+ "In this tutorial we will utilize our tissue model which uses this wrapper to create the reflectance spectra.\n",
+ "\n",
+ "As a prerequisit, you need a MCML monte carlo simulation which uses the format specified [here](http://omlc.org/software/mc/).\n",
+ "I tested this software with the GPU accelerated version which can be found [here](https://code.google.com/archive/p/gpumcml/)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "# 1.1 create spectra - setup simulation environment\n",
+ "\n",
+ "# some necessary imports\n",
+ "import logging\n",
+ "import numpy as np\n",
+ "import os\n",
+ "# everything related to the simulation wrapper\n",
+ "from mc import sim\n",
+ "# the factories create batches (tissue samples) and suited tissue models\n",
+ "from mc import factories\n",
+ "# function which runs simulations for each wavelength\n",
+ "from mc.create_spectrum import create_spectrum\n",
+ "\n",
+ "# Where does your monte carlo simulation executable resides in?\n",
+ "MCML_EXECUTABLE = \"/home/wirkert/workspace/monteCarlo/gpumcml/fast-gpumcml/gpumcml.sm_20\"\n",
+ "# The MCML needs a simulation input file, where shall it be created?\n",
+ "MCI_FILENAME = \"./temp.mci\"\n",
+ "# filename of the file with the simulation results. Due to a bug in GPUMCML will always\n",
+ "# be created in the same folder as the MCML executable\n",
+ "MCO_FILENAME = \"temp.mco\"\n",
+ "# The wavelengths for which we want to run our simulation\n",
+ "WAVELENGTHS = np.arange(450, 720, 2) * 10 ** -9\n",
+ "\n",
+ "# we want to create standard colonic tissue as specified in the IPCAI 2016 publication\n",
+ "# \"Robust Near Real-Time Estimation of Physiological Parameters from Megapixel\n",
+ "# Multispectral Images with Inverse Monte Carlo and Random Forest Regression\"\n",
+ "factory = factories.ColonMuscleMeanScatteringFactory()\n",
+ "# if you want to create data from the generic tissue mentioned in the paper, choose:\n",
+ "#factory = factories.GenericMeanScatteringFactory()\n",
+ "\n",
+ "# create a simulation wrapper\n",
+ "# the simulation wrapper wraps the mcml executable in python code\n",
+ "sim_wrapper = sim.SimWrapper()\n",
+ "# our simulation needs to know where the input file for the simulation\n",
+ "# shall resign (will be automatically created)\n",
+ "sim_wrapper.set_mci_filename(MCI_FILENAME)\n",
+ "# also it needs to know where the simulation executable shall lie in\n",
+ "sim_wrapper.set_mcml_executable(MCML_EXECUTABLE)\n",
+ "\n",
+ "# create the tissue model\n",
+ "# it is responsible for writing the simulation input file\n",
+ "tissue_model = factory.create_tissue_model()\n",
+ "# tell it where the input file shall lie in\n",
+ "tissue_model.set_mci_filename(sim_wrapper.mci_filename)\n",
+ "# also set the output filename\n",
+ "tissue_model.set_mco_filename(MCO_FILENAME)\n",
+ "# tell it how much photons shall be simulated. Will be set to 10**6 by standard,\n",
+ "# this is just an example\n",
+ "tissue_model.set_nr_photons(10**6)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " layer0 | \n",
+ " layer1 | \n",
+ " layer2 | \n",
+ "
\n",
+ " \n",
+ " | \n",
+ " vhb | \n",
+ " sao2 | \n",
+ " a_mie | \n",
+ " b_mie | \n",
+ " d | \n",
+ " n | \n",
+ " g | \n",
+ " vhb | \n",
+ " sao2 | \n",
+ " a_mie | \n",
+ " ... | \n",
+ " d | \n",
+ " n | \n",
+ " g | \n",
+ " vhb | \n",
+ " sao2 | \n",
+ " a_mie | \n",
+ " b_mie | \n",
+ " d | \n",
+ " n | \n",
+ " g | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.003780 | \n",
+ " 0.447583 | \n",
+ " 2425.900882 | \n",
+ " 1.286 | \n",
+ " 0.000907 | \n",
+ " 1.36 | \n",
+ " 0.872626 | \n",
+ " 0.068985 | \n",
+ " 0.447583 | \n",
+ " 912.591151 | \n",
+ " ... | \n",
+ " 0.000503 | \n",
+ " 1.36 | \n",
+ " 0.948700 | \n",
+ " 0.034427 | \n",
+ " 0.447583 | \n",
+ " 3150.494032 | \n",
+ " 1.286 | \n",
+ " 0.000454 | \n",
+ " 1.38 | \n",
+ " 0.804610 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.021198 | \n",
+ " 0.184410 | \n",
+ " 3022.116532 | \n",
+ " 1.286 | \n",
+ " 0.000782 | \n",
+ " 1.36 | \n",
+ " 0.930268 | \n",
+ " 0.063804 | \n",
+ " 0.184410 | \n",
+ " 10.000000 | \n",
+ " ... | \n",
+ " 0.000735 | \n",
+ " 1.36 | \n",
+ " 0.830601 | \n",
+ " 0.028247 | \n",
+ " 0.184410 | \n",
+ " 3101.261499 | \n",
+ " 1.286 | \n",
+ " 0.000430 | \n",
+ " 1.38 | \n",
+ " 0.813056 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.052096 | \n",
+ " 0.307445 | \n",
+ " 1171.322758 | \n",
+ " 1.286 | \n",
+ " 0.000897 | \n",
+ " 1.36 | \n",
+ " 0.924933 | \n",
+ " 0.021053 | \n",
+ " 0.307445 | \n",
+ " 1433.788625 | \n",
+ " ... | \n",
+ " 0.000738 | \n",
+ " 1.36 | \n",
+ " 0.807348 | \n",
+ " 0.006614 | \n",
+ " 0.307445 | \n",
+ " 1002.536901 | \n",
+ " 1.286 | \n",
+ " 0.000485 | \n",
+ " 1.38 | \n",
+ " 0.943837 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 0.076799 | \n",
+ " 0.471304 | \n",
+ " 1599.038671 | \n",
+ " 1.286 | \n",
+ " 0.000878 | \n",
+ " 1.36 | \n",
+ " 0.900637 | \n",
+ " 0.084504 | \n",
+ " 0.471304 | \n",
+ " 3228.771326 | \n",
+ " ... | \n",
+ " 0.000605 | \n",
+ " 1.36 | \n",
+ " 0.905222 | \n",
+ " 0.043674 | \n",
+ " 0.471304 | \n",
+ " 1810.114303 | \n",
+ " 1.286 | \n",
+ " 0.000504 | \n",
+ " 1.38 | \n",
+ " 0.868953 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 0.053123 | \n",
+ " 0.108137 | \n",
+ " 3524.480885 | \n",
+ " 1.286 | \n",
+ " 0.001001 | \n",
+ " 1.36 | \n",
+ " 0.833434 | \n",
+ " 0.095382 | \n",
+ " 0.108137 | \n",
+ " 1988.134950 | \n",
+ " ... | \n",
+ " 0.000643 | \n",
+ " 1.36 | \n",
+ " 0.920940 | \n",
+ " 0.031201 | \n",
+ " 0.108137 | \n",
+ " 1731.751283 | \n",
+ " 1.286 | \n",
+ " 0.000542 | \n",
+ " 1.38 | \n",
+ " 0.906191 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 0.009147 | \n",
+ " 0.866703 | \n",
+ " 372.754799 | \n",
+ " 1.286 | \n",
+ " 0.000943 | \n",
+ " 1.36 | \n",
+ " 0.841274 | \n",
+ " 0.094915 | \n",
+ " 0.866703 | \n",
+ " 1660.695761 | \n",
+ " ... | \n",
+ " 0.000505 | \n",
+ " 1.36 | \n",
+ " 0.856969 | \n",
+ " 0.009274 | \n",
+ " 0.866703 | \n",
+ " 1991.390563 | \n",
+ " 1.286 | \n",
+ " 0.000439 | \n",
+ " 1.38 | \n",
+ " 0.813544 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 0.082903 | \n",
+ " 0.206032 | \n",
+ " 2314.415411 | \n",
+ " 1.286 | \n",
+ " 0.000663 | \n",
+ " 1.36 | \n",
+ " 0.884492 | \n",
+ " 0.038608 | \n",
+ " 0.206032 | \n",
+ " 459.458466 | \n",
+ " ... | \n",
+ " 0.000573 | \n",
+ " 1.36 | \n",
+ " 0.850574 | \n",
+ " 0.063746 | \n",
+ " 0.206032 | \n",
+ " 2728.820678 | \n",
+ " 1.286 | \n",
+ " 0.000494 | \n",
+ " 1.38 | \n",
+ " 0.801766 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 0.040719 | \n",
+ " 0.200956 | \n",
+ " 1858.910121 | \n",
+ " 1.286 | \n",
+ " 0.000772 | \n",
+ " 1.36 | \n",
+ " 0.884516 | \n",
+ " 0.003930 | \n",
+ " 0.200956 | \n",
+ " 3564.807750 | \n",
+ " ... | \n",
+ " 0.000766 | \n",
+ " 1.36 | \n",
+ " 0.903764 | \n",
+ " 0.047257 | \n",
+ " 0.200956 | \n",
+ " 1429.574407 | \n",
+ " 1.286 | \n",
+ " 0.000468 | \n",
+ " 1.38 | \n",
+ " 0.849055 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 0.028810 | \n",
+ " 0.729636 | \n",
+ " 1751.818248 | \n",
+ " 1.286 | \n",
+ " 0.000886 | \n",
+ " 1.36 | \n",
+ " 0.813391 | \n",
+ " 0.007477 | \n",
+ " 0.729636 | \n",
+ " 1388.286116 | \n",
+ " ... | \n",
+ " 0.000813 | \n",
+ " 1.36 | \n",
+ " 0.914125 | \n",
+ " 0.092993 | \n",
+ " 0.729636 | \n",
+ " 4001.446613 | \n",
+ " 1.286 | \n",
+ " 0.000504 | \n",
+ " 1.38 | \n",
+ " 0.844552 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " 0.089758 | \n",
+ " 0.665397 | \n",
+ " 3768.709188 | \n",
+ " 1.286 | \n",
+ " 0.000800 | \n",
+ " 1.36 | \n",
+ " 0.836711 | \n",
+ " 0.015648 | \n",
+ " 0.665397 | \n",
+ " 1298.629577 | \n",
+ " ... | \n",
+ " 0.000620 | \n",
+ " 1.36 | \n",
+ " 0.927904 | \n",
+ " 0.048023 | \n",
+ " 0.665397 | \n",
+ " 3015.289386 | \n",
+ " 1.286 | \n",
+ " 0.000427 | \n",
+ " 1.38 | \n",
+ " 0.893833 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
10 rows × 21 columns
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 4.5e-07 | \n",
+ " 4.52e-07 | \n",
+ " 4.54e-07 | \n",
+ " 4.56e-07 | \n",
+ " 4.58e-07 | \n",
+ " 4.6e-07 | \n",
+ " 4.62e-07 | \n",
+ " 4.64e-07 | \n",
+ " 4.66e-07 | \n",
+ " 4.68e-07 | \n",
+ " ... | \n",
+ " 7e-07 | \n",
+ " 7.02e-07 | \n",
+ " 7.04e-07 | \n",
+ " 7.06e-07 | \n",
+ " 7.08e-07 | \n",
+ " 7.1e-07 | \n",
+ " 7.12e-07 | \n",
+ " 7.14e-07 | \n",
+ " 7.16e-07 | \n",
+ " 7.18e-07 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.318616 | \n",
+ " 0.346943 | \n",
+ " 0.371254 | \n",
+ " 0.379878 | \n",
+ " 0.385557 | \n",
+ " 0.389087 | \n",
+ " 0.394877 | \n",
+ " 0.397762 | \n",
+ " 0.401003 | \n",
+ " 0.404130 | \n",
+ " ... | \n",
+ " 0.494731 | \n",
+ " 0.495162 | \n",
+ " 0.495068 | \n",
+ " 0.495426 | \n",
+ " 0.495447 | \n",
+ " 0.495008 | \n",
+ " 0.495081 | \n",
+ " 0.495093 | \n",
+ " 0.494623 | \n",
+ " 0.494477 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.140266 | \n",
+ " 0.189640 | \n",
+ " 0.243554 | \n",
+ " 0.259792 | \n",
+ " 0.275593 | \n",
+ " 0.284833 | \n",
+ " 0.296358 | \n",
+ " 0.302311 | \n",
+ " 0.308877 | \n",
+ " 0.314986 | \n",
+ " ... | \n",
+ " 0.446426 | \n",
+ " 0.447138 | \n",
+ " 0.448675 | \n",
+ " 0.449469 | \n",
+ " 0.450297 | \n",
+ " 0.451485 | \n",
+ " 0.451886 | \n",
+ " 0.451767 | \n",
+ " 0.452054 | \n",
+ " 0.452514 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.021747 | \n",
+ " 0.035154 | \n",
+ " 0.056293 | \n",
+ " 0.065113 | \n",
+ " 0.073610 | \n",
+ " 0.080725 | \n",
+ " 0.088940 | \n",
+ " 0.094565 | \n",
+ " 0.100813 | \n",
+ " 0.107133 | \n",
+ " ... | \n",
+ " 0.378155 | \n",
+ " 0.379112 | \n",
+ " 0.379953 | \n",
+ " 0.381048 | \n",
+ " 0.382271 | \n",
+ " 0.382699 | \n",
+ " 0.384109 | \n",
+ " 0.384781 | \n",
+ " 0.385816 | \n",
+ " 0.386681 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 0.021931 | \n",
+ " 0.031995 | \n",
+ " 0.045955 | \n",
+ " 0.051771 | \n",
+ " 0.056990 | \n",
+ " 0.061694 | \n",
+ " 0.067690 | \n",
+ " 0.071328 | \n",
+ " 0.076024 | \n",
+ " 0.080335 | \n",
+ " ... | \n",
+ " 0.422478 | \n",
+ " 0.424793 | \n",
+ " 0.425965 | \n",
+ " 0.428011 | \n",
+ " 0.429414 | \n",
+ " 0.430371 | \n",
+ " 0.432106 | \n",
+ " 0.433527 | \n",
+ " 0.433773 | \n",
+ " 0.435063 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 0.069287 | \n",
+ " 0.107174 | \n",
+ " 0.159794 | \n",
+ " 0.177421 | \n",
+ " 0.196123 | \n",
+ " 0.208005 | \n",
+ " 0.221937 | \n",
+ " 0.231352 | \n",
+ " 0.239231 | \n",
+ " 0.247642 | \n",
+ " ... | \n",
+ " 0.477140 | \n",
+ " 0.478393 | \n",
+ " 0.481133 | \n",
+ " 0.483172 | \n",
+ " 0.485144 | \n",
+ " 0.486761 | \n",
+ " 0.488254 | \n",
+ " 0.490285 | \n",
+ " 0.491700 | \n",
+ " 0.492445 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 0.045606 | \n",
+ " 0.051312 | \n",
+ " 0.058581 | \n",
+ " 0.062728 | \n",
+ " 0.065359 | \n",
+ " 0.068912 | \n",
+ " 0.073484 | \n",
+ " 0.075951 | \n",
+ " 0.080196 | \n",
+ " 0.084404 | \n",
+ " ... | \n",
+ " 0.382621 | \n",
+ " 0.381922 | \n",
+ " 0.381471 | \n",
+ " 0.381451 | \n",
+ " 0.380481 | \n",
+ " 0.380568 | \n",
+ " 0.379841 | \n",
+ " 0.379317 | \n",
+ " 0.378714 | \n",
+ " 0.378075 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 0.027393 | \n",
+ " 0.044668 | \n",
+ " 0.070860 | \n",
+ " 0.081027 | \n",
+ " 0.091248 | \n",
+ " 0.098535 | \n",
+ " 0.107426 | \n",
+ " 0.112543 | \n",
+ " 0.118445 | \n",
+ " 0.123929 | \n",
+ " ... | \n",
+ " 0.371301 | \n",
+ " 0.373190 | \n",
+ " 0.375097 | \n",
+ " 0.377324 | \n",
+ " 0.379127 | \n",
+ " 0.380524 | \n",
+ " 0.382481 | \n",
+ " 0.383658 | \n",
+ " 0.385444 | \n",
+ " 0.386918 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 0.048908 | \n",
+ " 0.078857 | \n",
+ " 0.124928 | \n",
+ " 0.142237 | \n",
+ " 0.159621 | \n",
+ " 0.172280 | \n",
+ " 0.186836 | \n",
+ " 0.196870 | \n",
+ " 0.206029 | \n",
+ " 0.216111 | \n",
+ " ... | \n",
+ " 0.494583 | \n",
+ " 0.496394 | \n",
+ " 0.497351 | \n",
+ " 0.498217 | \n",
+ " 0.499010 | \n",
+ " 0.499452 | \n",
+ " 0.501481 | \n",
+ " 0.501600 | \n",
+ " 0.502315 | \n",
+ " 0.503171 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 0.086791 | \n",
+ " 0.105141 | \n",
+ " 0.125877 | \n",
+ " 0.135923 | \n",
+ " 0.143073 | \n",
+ " 0.151115 | \n",
+ " 0.160239 | \n",
+ " 0.165631 | \n",
+ " 0.173878 | \n",
+ " 0.180887 | \n",
+ " ... | \n",
+ " 0.516076 | \n",
+ " 0.516351 | \n",
+ " 0.517303 | \n",
+ " 0.517044 | \n",
+ " 0.516727 | \n",
+ " 0.516664 | \n",
+ " 0.515435 | \n",
+ " 0.515228 | \n",
+ " 0.515323 | \n",
+ " 0.514933 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " 0.056338 | \n",
+ " 0.071479 | \n",
+ " 0.089041 | \n",
+ " 0.097041 | \n",
+ " 0.103308 | \n",
+ " 0.109447 | \n",
+ " 0.116874 | \n",
+ " 0.120901 | \n",
+ " 0.127804 | \n",
+ " 0.133711 | \n",
+ " ... | \n",
+ " 0.506670 | \n",
+ " 0.506889 | \n",
+ " 0.507858 | \n",
+ " 0.508143 | \n",
+ " 0.508351 | \n",
+ " 0.508218 | \n",
+ " 0.509040 | \n",
+ " 0.509576 | \n",
+ " 0.508506 | \n",
+ " 0.508549 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
10 rows × 135 columns
\n",
+ "