def __init__(self, n = -1):
"""
Method: __init__
Constructor
"""
DataUnitSettings.__init__(self, n)
self.set("Type", "Colocalization")
self.registerCounted("ColocalizationLowerThreshold", 1)
self.registerCounted("ColocalizationUpperThreshold", 1)
self.register("ColocalizationDepth", 1)
self.register("CalculateThresholds")
for i in ["PValue", "RObserved", "RRandMean", "RRandSD",
"NumIterations", "ColocCount", "Method", "PSF",
"Ch1ThresholdMax", "Ch2ThresholdMax", "PearsonImageAbove",
"PearsonImageBelow", "PearsonWholeImage", "M1", "M2",
"ThresholdM1", "ThresholdM2", "Slope", "Intercept",
"K1", "K2", "DiffStainIntCh1", "DiffStainIntCh2",
"DiffStainVoxelsCh1", "DiffStainVoxelsCh2",
"ColocAmount", "ColocPercent", "PercentageVolumeCh1",
"PercentageTotalCh1", "PercentageTotalCh2",
"PercentageVolumeCh2", "PercentageMaterialCh1", "PercentageMaterialCh2",
"SumOverThresholdCh1", "SumOverThresholdCh2", "SumCh1", "SumCh2",
"NonZeroCh1", "NonZeroCh2", "OverThresholdCh1", "OverThresholdCh2", "Ch2Lambda"]:
self.register(i, 1)
self.register("OutputScalar", 1)
#self.register("ColocalizationColorTransferFunction",1)
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(255, 1.0, 1.0, 1.0)
self.set("ColorTransferFunction", ctf)
# This is used purely for remembering the ctf the user has set
self.register("ColocalizationColorTransferFunction", 1)
def get(self, name):
"""
Return the value of a key
"""
val = DataUnitSettings.get(self, name)
if name == "MergingColorTransferFunction" and not val:
val = DataUnitSettings.get(self, "ColorTransferFunction")
Logging.info("Returning proxyed ctf for merging", val, kw="ctf")
self.set("MergingColorTransferFunction", val)
return val
return val
def initialize(self, dataunit, channels, timepoints):
"""
Set initial values for settings based on
number of channels and timepoints
"""
DataUnitSettings.initialize(self, dataunit, channels, timepoints)
for i in range(channels):
tf = vtkbxd.vtkIntensityTransferFunction()
self.setCounted("IntensityTransferFunction", i, tf, 0)
self.set("PreviewChannel", 1)
def initialize(self, dataunit, channels, timepoints):
"""
Set initial values for settings based on
number of channels and timepoints
"""
DataUnitSettings.initialize(self, dataunit, channels, timepoints)
for i in range(channels):
tf = vtkbxd.vtkIntensityTransferFunction()
self.setCounted("IntensityTransferFunction", i, tf, 0)
self.set("PreviewChannel", 1)
def get(self, name):
"""
Return the value of a key
"""
val = DataUnitSettings.get(self, name)
if name == "MergingColorTransferFunction" and not val:
val = DataUnitSettings.get(self, "ColorTransferFunction")
Logging.info("Returning proxyed ctf for merging", val, kw = "ctf")
self.set("MergingColorTransferFunction", val)
return val
return val
def __init__(self, n=-1):
"""
Constructor
"""
DataUnitSettings.__init__(self, n)
#self.registerCounted("MergingColorTransferFunction",1)
self.set("Type", "Merging")
self.registerCounted("IntensityTransferFunction", 1)
self.register("AlphaTransferFunction", 1)
self.register("AlphaMode")
self.registerCounted("PreviewChannel")
tf = vtkbxd.vtkIntensityTransferFunction()
self.set("AlphaTransferFunction", tf)
self.set("AlphaMode", [0, 0])
def __init__(self, n = -1):
"""
Constructor
"""
DataUnitSettings.__init__(self, n)
#self.registerCounted("MergingColorTransferFunction",1)
self.set("Type", "Merging")
self.registerCounted("IntensityTransferFunction", 1)
self.register("AlphaTransferFunction", 1)
self.register("AlphaMode")
self.registerCounted("PreviewChannel")
tf = vtkbxd.vtkIntensityTransferFunction()
self.set("AlphaTransferFunction", tf)
self.set("AlphaMode", [0, 0])
def __init__(self, n=-1):
"""
Constructor
"""
DataUnitSettings.__init__(self, n)
self.registerCounted("IntensityTransferFunctions", 1)
self.register("InterpolationTimepoints", 1)
self.set("Type", "Adjust")
self.registerPrivate("ColorTransferFunction", 1)
self.registerCounted("Source")
self.register("VoxelSize")
self.register("Spacing")
#self.register("Origin")
self.register("Dimensions")
self.register("Type")
self.register("Name")
self.register("BitDepth")
self.set("InterpolationTimepoints", [])
def __init__(self, n = -1):
"""
Constructor
"""
DataUnitSettings.__init__(self, n)
self.registerCounted("IntensityTransferFunctions", 1)
self.register("InterpolationTimepoints", 1)
self.set("Type", "Adjust")
self.registerPrivate("ColorTransferFunction", 1)
self.registerCounted("Source")
self.register("VoxelSize")
self.register("Spacing")
#self.register("Origin")
self.register("Dimensions")
self.register("Type")
self.register("Name")
self.register("BitDepth")
self.set("InterpolationTimepoints", [])
def getSettingsFromCache(key):
"""
Return the settings stored under a given key in the cache
"""
global settingsCache
data = settingsCache.get(tuple(key), None)
value = None
parser = None
if data:
value = []
for (n, configParser) in data:
if not configParser.sections():
continue
print "n=",n,"configParser=",configParser
print configParser.sections()
settings = DataUnitSettings(n)
settings.set("Type", None)
settings = settings.readFrom(configParser)
value.append(settings)
parser = configParser
return value, parser
def initialize(self, dataunit, channels, timepoints):
"""
Set initial values for settings based on
number of channels and timepoints
"""
DataUnitSettings.initialize(self, dataunit, channels, timepoints)
print "Initializing colocalization for %d channels" % channels
self.set("ColocalizationDepth", dataunit.getBitDepth())
if hasattr(dataunit, "getScalarRange"):
minval, maxval = dataunit.getScalarRange()
else:
minval, maxval = dataunit.getSourceDataUnits()[0].getScalarRange()
print "Initializing channels, maxval=", maxval
for i in range(channels):
self.setCounted("ColocalizationLowerThreshold", i, maxval / 2, 0)
self.setCounted("ColocalizationUpperThreshold", i, maxval, 0)
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(maxval, 1.0, 1.0, 1.0)
self.set("ColorTransferFunction", ctf)
self.set("OutputScalar", maxval)
def initialize(self, dataunit, channels, timepoints):
"""
Set initial values for settings based on
number of channels and timepoints
"""
DataUnitSettings.initialize(self, dataunit, channels, timepoints)
print "Initializing colocalization for %d channels" % channels
self.set("ColocalizationDepth", dataunit.getBitDepth())
if hasattr(dataunit, "getScalarRange"):
minval, maxval = dataunit.getScalarRange()
else:
minval, maxval = dataunit.getSourceDataUnits()[0].getScalarRange()
print "Initializing channels, maxval=", maxval
for i in range(channels):
self.setCounted("ColocalizationLowerThreshold", i, maxval / 2, 0)
self.setCounted("ColocalizationUpperThreshold", i, maxval, 0)
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(maxval, 1.0, 1.0, 1.0)
self.set("ColorTransferFunction", ctf)
self.set("OutputScalar", maxval)
def getSettingsFromCache(key):
"""
Return the settings stored under a given key in the cache
"""
global settingsCache
data = settingsCache.get(tuple(key), None)
value = None
parser = None
if data:
value = []
for (n, configParser) in data:
if not configParser.sections():
continue
print "n=", n, "configParser=", configParser
print configParser.sections()
settings = DataUnitSettings(n)
settings.set("Type", None)
settings = settings.readFrom(configParser)
value.append(settings)
parser = configParser
return value, parser
def __init__(self, n=-1):
"""
Method: __init__
Constructor
"""
DataUnitSettings.__init__(self, n)
self.set("Type", "Colocalization")
self.registerCounted("ColocalizationLowerThreshold", 1)
self.registerCounted("ColocalizationUpperThreshold", 1)
self.register("ColocalizationDepth", 1)
self.register("CalculateThresholds")
for i in [
"PValue", "RObserved", "RRandMean", "RRandSD", "NumIterations",
"ColocCount", "Method", "PSF", "Ch1ThresholdMax",
"Ch2ThresholdMax", "PearsonImageAbove", "PearsonImageBelow",
"PearsonWholeImage", "M1", "M2", "ThresholdM1", "ThresholdM2",
"Slope", "Intercept", "K1", "K2", "DiffStainIntCh1",
"DiffStainIntCh2", "DiffStainVoxelsCh1", "DiffStainVoxelsCh2",
"ColocAmount", "ColocPercent", "PercentageVolumeCh1",
"PercentageTotalCh1", "PercentageTotalCh2",
"PercentageVolumeCh2", "PercentageMaterialCh1",
"PercentageMaterialCh2", "SumOverThresholdCh1",
"SumOverThresholdCh2", "SumCh1", "SumCh2", "NonZeroCh1",
"NonZeroCh2", "OverThresholdCh1", "OverThresholdCh2",
"Ch2Lambda"
]:
self.register(i, 1)
self.register("OutputScalar", 1)
#self.register("ColocalizationColorTransferFunction",1)
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(255, 1.0, 1.0, 1.0)
self.set("ColorTransferFunction", ctf)
# This is used purely for remembering the ctf the user has set
self.register("ColocalizationColorTransferFunction", 1)
def initialize(self, dataunit, channels, timepoints):
"""
Set initial values for settings based on
number of channels and timepoints
"""
DataUnitSettings.initialize(self, dataunit, channels, timepoints)
ctf = self.get("ColorTransferFunction")
if hasattr(dataunit, "getScalarRange"):
minval, maxval = dataunit.getScalarRange()
bitdepth = dataunit.getBitDepth()
else:
minval, maxval = dataunit.getSourceDataUnits()[0].getScalarRange()
bitdepth = dataunit.getSourceDataUnits()[0].getBitDepth()
minval = min(0, minval)
maxval = max(2**bitdepth - 1, maxval)
for i in range(timepoints):
tf = vtkbxd.vtkIntensityTransferFunction()
tf.SetRangeMax(maxval)
self.setCounted("IntensityTransferFunctions", i, tf, 0)
def initialize(self, dataunit, channels, timepoints):
"""
Set initial values for settings based on
number of channels and timepoints
"""
DataUnitSettings.initialize(self, dataunit, channels, timepoints)
ctf = self.get("ColorTransferFunction")
if hasattr(dataunit, "getScalarRange"):
minval, maxval = dataunit.getScalarRange()
bitdepth = dataunit.getBitDepth()
else:
minval, maxval = dataunit.getSourceDataUnits()[0].getScalarRange()
bitdepth = dataunit.getSourceDataUnits()[0].getBitDepth()
minval = min(0,minval)
maxval = max(2**bitdepth-1, maxval)
for i in range(timepoints):
tf = vtkbxd.vtkIntensityTransferFunction()
tf.SetRangeMax(maxval)
self.setCounted("IntensityTransferFunctions", i, tf, 0)
def loadFromFile(self, filename):
"""
Loads the specified .bxc-file and imports data from it.
Also returns a DataUnit of the type stored in the loaded
.bxc-file or None if something goes wrong. The dataunit is
returned in a list with one item for interoperability with
LSM data source
"""
if not self.baseFilename:
self.baseFilename = filename
self.shortname = os.path.basename(filename)
dataUnitFormat = self.loadBxdFile(filename)
Logging.info("format of unit = ", dataUnitFormat, kw = "datasource")
if (not dataUnitFormat) or (not self.parser):
Logging.info("No dataUnitFormat or parser: %s and %s"%(dataUnitFormat, self.parser), kw = "datasource")
return None
# Then, the number of datasets/timepoints that belong to this dataset
# series
try:
count = self.parser.get("ImageData", "numberOfFiles")
except ConfigParser.NoOptionError:
count = self.parser.get("ImageData", "numberoffiles")
Logging.info("format = ", dataUnitFormat, "count = ", count, kw = "datasource")
# Then read the .vti-filenames and store them in the dataSets-list:
filedir = os.path.dirname(filename)
hasPolydata = self.parser.has_section("PolyData")
for i in range(int(count)):
currentFile = "file_%d"%i
filename = self.parser.get("ImageData", currentFile)
if hasPolydata:
print "GOT polydata"
polyFileName = self.parser.get("PolyData", currentFile)
self.polyDataFiles.append(polyFileName)
reader = vtk.vtkXMLImageDataReader()
filepath = os.path.join(filedir, filename)
if not reader.CanReadFile(filepath):
Logging.error("Cannot read file",
"Cannot read source XML Image Data File %s"%filename)
return
self.dataSets.append(filename)
# If everything went well, we create a new DataUnit-instance of the
# correct subclass, so that the DataUnit-instance can take over and
# resume data processing. First, we return the DataUnit to the caller,
# so it can set a reference to it:
dataunit = DataUnit()
settings = DataUnitSettings()
settings.setType("")
settings = settings.readFrom(self.parser)
self.originalDimensions = eval(settings.get("Dimensions"))
self.settings = settings
dataunit.setDataSource(self)
dataunit.setSettings(settings)
data = dataunit.getTimepoint(0)
dataunits = [dataunit]
if data.GetNumberOfScalarComponents() == 3:
for i in range(0, 3) :
dataSource = RGBComponentDataSource(self, i)
dataunit = DataUnit()
dataunit.setDataSource(dataSource)
settings = DataUnitSettings()
settings = settings.readFrom(self.parser)
dataunit.setSettings(settings)
dataunits.append(dataunit)
return dataunits
