def setDataSource(self, dataSource): """ Sets a DataSource for this CombinedDataUnit Parameters: dataSource A DataSource to manage actual image data located on disk """ DataUnit.setDataSource(self, dataSource)
def loadFromFile(self, filename): """ Loads the specified .oif-file and imports data from it. Parameters: filename The .oif-file to be loaded """ dataunit = DataUnit() datasource = InterfileDataSource(filename) dataunit.setDataSource(datasource) return [dataunit]
def loadFromFile(self, filename): """ Loads image from MRC-file and generates own DataSource @param filename Path to MRC-file @return List of tuples of datasets in file (only one) """ self.filename = filename dataUnits = [] imageName = self.getShortName() dataSource = MRCDataSource(filename) dataUnit = DataUnit() dataUnit.setDataSource(dataSource) dataUnits.append((imageName,dataUnit)) return dataUnits
def loadFromFile(self, filename):
"""
Loads image from MRC-file and generates own DataSource
@param filename Path to MRC-file
@return List of tuples of datasets in file (only one)
"""
self.filename = filename
dataUnits = []
imageName = self.getShortName()
dataSource = MRCDataSource(filename)
dataUnit = DataUnit()
dataUnit.setDataSource(dataSource)
dataUnits.append((imageName, dataUnit))
return dataUnits
def __init__(self, name = ""):
"""
Constructor
"""
DataUnit.__init__(self, name, initToNone = 0)
self.outputDirectory = ""
self.sourceunits = []
self.doOrig = 0
self.merging = 0
self.merge = None
self.maptocolor = None
settingclass = self.getSettingsClass()
Logging.info("Settings class = ", settingclass, kw = "dataunit")
self.settings = settingclass()
#self.byName = {}
self.module = None
self.outputChannels = {}
self.checkDimensions = 1
self.currentDimensions = None
self.currentSpacing = None
self.currentTimepoints = None
def loadFromFile(self, filename):
"""
Loads a directory of slices
"""
self.filename = filename
filebase, ext = os.path.splitext(filename)
directoryname = os.path.abspath(os.path.dirname(filename))
ext = ext[1:]
files = glob.glob(os.path.join(directoryname, "*.%s"%ext))
print "Loading files", files
datasource = FileListDataSource.FileListDataSource()
datasource.setSlicesPerTimepoint(len(files))
datasource.setFilenames(files)
dataunit = DataUnit()
dataunit.setDataSource(datasource)
settings = dataunit.getSettings()
dims = datasource.getDimensions()
settings.set("Dimensions", dims)
settings.set("Name", os.path.basename(os.path.dirname(filename)))
return [dataunit]
self.reader.SetFileName(self.convertFileName(filename))
#self.reader.Update()
self.reader.UpdateInformation()
dataunits = []
channelNum = self.reader.GetNumberOfChannels()
self.timepointAmnt = channelNum
Logging.info("There are %d channels" % channelNum, kw = "lsmreader")
for i in range(channelNum):
# We create a datasource with specific channel number that
# we can associate with the dataunit
datasource = LsmDataSource(filename, i)
datasource.setPath(filename)
dataunit = DataUnit()
dataunit.setDataSource(datasource)
dataunits.append(dataunit)
return dataunits
def getColorTransferFunction(self):
"""
Returns the ctf of the dataset series which this datasource
operates on
"""
if not self.ctf:
Logging.info("Using ctf based on LSM Color", kw = "lsmreader")
ctf = vtk.vtkColorTransferFunction()
r = self.reader.GetChannelColorComponent(self.channelNum, 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
class LeicaDataSource(DataSource):
"""
Leica format datasource
"""
def __init__(self, filename = "", experiment = "", channel = -1):
"""
Constructor
"""
DataSource.__init__(self)
self.filename = filename
self.reader = LeicaExperiment(filename, progressCallback = self.updateProgress)
self.shortname = os.path.basename(filename)
self.experiment = experiment
if experiment:
self.originalDimensions = self.reader.GetDimensions(self.experiment)
duration = self.reader.GetDuration(self.experiment)
numT = self.reader.GetNumberOfTimepoints(self.experiment)
print "Number of Timepoints = ",numT
print "Duration=",duration
step = duration/float(numT)
stamps = []
for t in range(0, numT):
stamps.append(step*t)
self.setTimeStamps(stamps)
self.setAbsoluteTimeStamps(stamps)
self.channel = channel
self.dimensions = None
self.voxelsize = None
self.spacing = None
self.color = None
self.ctf = None
self.setPath(filename)
self.datasetCount = None
def getDataSetCount(self):
"""
Returns the number of individual DataSets (=time points)
managed by this DataSource
"""
if not self.datasetCount:
self.datasetCount = self.reader.GetNumberOfTimepoints(self.experiment)
return self.datasetCount
def getFileName(self):
"""
Return the file name
"""
return self.filename
def getDataSet(self, i, raw = 0):
"""
Returns the DataSet at the specified index
Parameters: i The index
"""
self.setCurrentTimepoint(i)
self.timepoint = i
data = self.reader.GetTimepoint(self.experiment, self.channel, i)
return self.getResampledData(data, i)
def internalGetDimensions(self):
"""
Returns the (x,y,z) dimensions of the datasets this
dataunit contains
"""
return self.reader.GetDimensions(self.experiment)
def getSpacing(self):
"""
Returns the spacing of the datasets this
dataunit contains
"""
if not self.spacing:
a, b, c = self.getVoxelSize()
self.spacing = [1, b / a, c / a]
return self.spacing
def getVoxelSize(self):
"""
Returns the voxel size of the datasets this
dataunit contains
"""
if not self.voxelsize:
self.voxelsize = self.reader.GetVoxelSize(self.experiment)
return self.voxelsize
def getScalarRange(self):
"""
Return scalar range of data
"""
self.getBitDepth()
self.scalarRange = (0, 2 ** self.bitdepth - 1)
return self.scalarRange
def loadFromFile(self, filename):
"""
Loads the specified .txt-file and imports data from it.
Parameters: filename The .txt-file to be loaded
"""
exts = filename.split(".")
if exts[-1].lower()=="lei":
filename = ".".join(exts[:-1])
if os.path.exists(filename+".txt"):
filename+=".txt"
elif os.path.exists(filename+".TXT"):
filename+=".TXT"
elif os.path.exists(filename+".Txt"):
filename+=".Txt"
self.filename = filename
self.path = os.path.dirname(filename)
self.reader.setFileName(filename)
try:
f = open(filename)
f.close()
except IOError, ex:
Logging.error("Failed to open Leica File",
"Failed to open file %s for reading: %s" % (filename, str(ex)))
self.reader.Read()
dataunits = []
experiments = self.reader.GetExperiments()
for experiment in experiments:
if experiment in self.reader.nonExistent:
continue
channelNum = self.reader.GetNumberOfChannels(experiment)
#print "There are %d channels in %s"%(channelNum,filename)
for i in range(channelNum):
# We create a datasource with specific channel number that
# we can associate with the dataunit
datasource = LeicaDataSource(filename, experiment, i)
dataunit = DataUnit()
dataunit.setDataSource(datasource)
dataunits.append((experiment, dataunit))
return dataunits
self.reader.SetFileName(self.convertFileName(filename))
#self.reader.Update()
self.reader.UpdateInformation()
dataunits = []
channelNum = self.reader.GetNumberOfChannels()
self.timepointAmnt = channelNum
Logging.info("There are %d channels" % channelNum, kw="lsmreader")
for i in range(channelNum):
# We create a datasource with specific channel number that
# we can associate with the dataunit
datasource = LsmDataSource(filename, i)
datasource.setPath(filename)
dataunit = DataUnit()
dataunit.setDataSource(datasource)
dataunits.append(dataunit)
return dataunits
def getColorTransferFunction(self):
"""
Returns the ctf of the dataset series which this datasource
operates on
"""
if not self.ctf:
Logging.info("Using ctf based on LSM Color", kw="lsmreader")
ctf = vtk.vtkColorTransferFunction()
r = self.reader.GetChannelColorComponent(self.channelNum, 0)
g = self.reader.GetChannelColorComponent(self.channelNum, 1)