Esempio n. 1
0
	def getTimepoint(self, timepointIndex):
		"""
		Return the timepointIndexth timepoint
		"""		   
		self.timepoint = timepointIndex
		path = self.path[:]
		if not self.reader:
			self.reader = vtkbxd.vtkExtTIFFReader()
			self.reader.AddObserver("ProgressEvent", lib.messenger.send)
			lib.messenger.connect(self.reader, 'ProgressEvent', self.updateProgress)
			xDimension, yDimension, zDimension = self.dimensions
			self.reader.SetDataExtent(0, xDimension - 1, 0, yDimension - 1, 0, zDimension - 1)
			
			spacing = self.getSpacing()
			if spacing[2] == 0:
				spacing[2] = 1.0
			self.reader.SetDataSpacing(*spacing)
		
		zpat = ""
		tpat = ""
		cpat = os.path.sep + "%s_C%.3d" % (self.fileNameBase, self.channel)
		path += cpat

		if self.dimensions[2] > 1:
			zpat = "Z%.3d"
		if self.timepoints > 1:
			tpat = "T%.3d"%(timepointIndex+1)
		pat = path + zpat + tpat + ".tif"
		
		self.reader.SetFilePattern(self.convertFileName(pat))

		if self.reverseSlices and 0:
			#print "offset=",self.dimensions[2]
			self.reader.SetFileNameSliceOffset(self.dimensions[2])
			self.reader.SetFileNameSliceSpacing(-1)
		else:
			self.reader.SetFileNameSliceOffset(1)

		self.reader.UpdateInformation()

		return self.reader.GetOutput()
Esempio n. 2
0
	def getTIFFReader(self, Series_Info, Channel):
		"""
		create a tiff reader that reads then given channel of the given series
		"""
		XYDim = Series_Info['Resolution_X'] - 1
		NumSect = Series_Info['Number_Sections'] - 1
		XSpace = Series_Info['Voxel_Width_X']
		YSpace = Series_Info['Voxel_Height_Y']
		ZSpace = Series_Info['Voxel_Depth_Z']
		TIFFReader = vtkbxd.vtkExtTIFFReader()
		if self.progressCallback:
			TIFFReader.AddObserver("ProgressEvent", lib.messenger.send)
			lib.messenger.connect(TIFFReader, 'ProgressEvent', self.progressCallback)
		if Series_Info['Pixel_Size'] != 3:
			TIFFReader.RawModeOn()
		
		arr = vtk.vtkStringArray()
		for i in Channel:
			arr.InsertNextValue(os.path.join(self.path, i))
		TIFFReader.SetFileNames(arr)
		#First read the images for a particular channel
		# Check to see whether the image name contains either
		# channels or z slices at all. If not, then we can just you
		# the filename and skip a whole bunch of processing
	
		if Series_Info['Bit_Depth'] == 8:
			TIFFReader.SetDataScalarTypeToUnsignedChar()
		else:
			raise "Only 8-bit data supported"

		spacingX,spacingY,spacingZ = 1.0,1.0,1.0
		if XSpace != 0.0 and YSpace != 0.0:
			spacingY = YSpace / XSpace
		if XSpace != 0.0 and ZSpace != 0.0:
			spacingZ = ZSpace / XSpace
		
		TIFFReader.FileLowerLeftOff()
		TIFFReader.SetDataExtent(0, XYDim, 0, XYDim, 0, NumSect)
		TIFFReader.SetDataSpacing(spacingX, spacingY, spacingZ)
		TIFFReader.Update()
		return TIFFReader
import vtk
import vtkbxd
import time

PATH="/media/sda12/Data/Olympus/silicone/su8onsilicone3.oif.files/su8onsilicone3_C001Z%.3d.tif"
t=time.time()
written=1
TIMES=40
for i in range(0,TIMES):
    rdr = vtkbxd.vtkExtTIFFReader()
    rdr.SetDataExtent(0,1023,0,1023,0,42)
    rdr.SetFilePattern(PATH)
    rdr.SetFileNameSliceOffset(1)
    rdr.Update()
    data = rdr.GetOutput()
    if not written:
	writer = vtk.vtkXMLImageDataWriter()
	writer.SetFileName("koe.vti")
	writer.SetInput(data)
	writer.Write()	
	del writer
	written=1
    del data
    del rdr
    
    
t2=time.time()
print "Time it took to read OIF %d times="%TIMES,t2-t
print "Average: ",(t2-t)/float(TIMES)
t=time.time()
written=1
Esempio n. 4
0
    def getReadersFromFilenames(self):
        """
		create the reader list from a given set of file names and parameters
		"""
        for i in self.readers:
            del i
        self.readers = []

        if not self.filenames:
            raise Logging.GUIError("No files could be found", \
                  "For some reason, no files were listed to be imported.")

        files = self.filenames
        print "Determining readers from ", self.filenames

        isRGB = 1
        self.ext = files[0].split(".")[-1].lower()
        dim = self.dimMapping[self.ext]
        # Initially flip the image if it's tiff, png or jpg.
        # In setVerticalFlip we negate the setting to have it set correctly.
        if self.ext.lower() in ["png", "jpg", "jpeg"]:
            self.flipVertically = True
        if self.ext in ["tif", "tiff"]:
            reader = vtkbxd.vtkExtTIFFReader()
            reader.SetFileName(files[0])
            reader.UpdateInformation()
            if reader.GetNumberOfScalarComponents() >= 3:
                print "MODE IS RGB, IS AN RGB IMAGE"
            else:
                print "MODE ISN'T RGB, THEREFORE NOT RGB"
                isRGB = 0
            rdr = self.getReaderByExtension(self.ext, isRGB)
            rdr.SetFileName(files[0])
            if rdr.GetNumberOfSubFiles() > 1:
                dim = 3

        self.isRGB = isRGB
        self.is3D = (dim == 3)

        dirName = os.path.dirname(files[0])
        print "THERE ARE", self.slicesPerTimepoint, "SLICES PER TIMEPOINT"
        self.ext = files[0].split(".")[-1].lower()

        if dim == 3:
            totalFiles = len(files)
            for i, file in enumerate(files):
                rdr = self.getReaderByExtension(self.ext, isRGB)
                rdr.SetFileName(file)
                self.readers.append(rdr)
            return

        totalFiles = len(files) / self.slicesPerTimepoint

        imgAmnt = len(files)
        if totalFiles == 1:
            rdr = self.getReaderByExtension(self.ext, isRGB)
            arr = vtk.vtkStringArray()
            for fileName in files:
                arr.InsertNextValue(os.path.join(dirName, fileName))
            rdr.SetFileNames(arr)
            self.readers.append(rdr)
            return

        if imgAmnt > 1:
            # If the pattern doesn't have %, then we just use
            # the given filenames and allocate them to timepoints
            # using  slicesPerTimepoint slices per timepoint
            ntps = len(files) / self.slicesPerTimepoint
            filelst = files[:]
            # dirn #TODO: what was this?
            for tp in range(0, ntps):
                rdr = self.getReaderByExtension(self.ext, isRGB)
                arr = vtk.vtkStringArray()
                for i in range(0, self.slicesPerTimepoint):
                    arr.InsertNextValue(filelst[0])
                    filelst = filelst[1:]
                rdr.SetFileNames(arr)
                rdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0,
                                  self.slicesPerTimepoint - 1)
                rdr.SetDataSpacing(self.spacing)
                rdr.SetDataOrigin(0, 0, 0)
                self.readers.append(rdr)
            return

        elif imgAmnt == 1:
            # If only one file
            rdr = self.getReaderByExtension(self.ext, isRGB)
            rdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0,
                              self.slicesPerTimepoint - 1)
            rdr.SetDataSpacing(self.spacing)
            rdr.SetDataOrigin(0, 0, 0)
            rdr.SetFileName(files[0])

            Logging.info("Reader = ", rdr, kw="io")
            self.readers.append(rdr)
Esempio n. 5
0
import vtk
import vtkbxd
import time

PATH = "/media/sda12/Data/Olympus/silicone/su8onsilicone3.oif.files/su8onsilicone3_C001Z%.3d.tif"
t = time.time()
written = 1
TIMES = 40
for i in range(0, TIMES):
    rdr = vtkbxd.vtkExtTIFFReader()
    rdr.SetDataExtent(0, 1023, 0, 1023, 0, 42)
    rdr.SetFilePattern(PATH)
    rdr.SetFileNameSliceOffset(1)
    rdr.Update()
    data = rdr.GetOutput()
    if not written:
        writer = vtk.vtkXMLImageDataWriter()
        writer.SetFileName("koe.vti")
        writer.SetInput(data)
        writer.Write()
        del writer
        written = 1
    del data
    del rdr

t2 = time.time()
print "Time it took to read OIF %d times=" % TIMES, t2 - t
print "Average: ", (t2 - t) / float(TIMES)
t = time.time()
written = 1
for i in range(0, TIMES):
	def getReadersFromFilenames(self):
		"""
		create the reader list from a given set of file names and parameters
		"""
		for i in self.readers:
			del i
		self.readers = []

		if not self.filenames:
			raise Logging.GUIError("No files could be found", \
									"For some reason, no files were listed to be imported.")		 
					
		files = self.filenames
		print "Determining readers from ", self.filenames

		isRGB = 1
		self.ext = files[0].split(".")[-1].lower()
		dim = self.dimMapping[self.ext]
		# Initially flip the image if it's tiff, png or jpg.
		# In setVerticalFlip we negate the setting to have it set correctly.
		if self.ext.lower() in ["png", "jpg", "jpeg"]:
			self.flipVertically = True
		if self.ext in ["tif", "tiff"]:
			reader = vtkbxd.vtkExtTIFFReader()
			reader.SetFileName(files[0])
			reader.UpdateInformation()
			if reader.GetNumberOfScalarComponents() >= 3:
				print "MODE IS RGB, IS AN RGB IMAGE"
			else:
				print "MODE ISN'T RGB, THEREFORE NOT RGB"
				isRGB = 0
			rdr = self.getReaderByExtension(self.ext, isRGB)
			rdr.SetFileName(files[0])
			if rdr.GetNumberOfSubFiles() > 1:
				dim = 3
				
		self.isRGB = isRGB
		self.is3D = (dim == 3)
		
		dirName = os.path.dirname(files[0])
		print "THERE ARE", self.slicesPerTimepoint, "SLICES PER TIMEPOINT"
		self.ext = files[0].split(".")[-1].lower()
		
		if dim == 3:
			totalFiles = len(files)
			for i, file in enumerate(files):
				rdr = self.getReaderByExtension(self.ext, isRGB)
				rdr.SetFileName(file)
				self.readers.append(rdr)
			return
			
		totalFiles = len(files) / self.slicesPerTimepoint

		imgAmnt = len(files)
		if totalFiles == 1:
			rdr = self.getReaderByExtension(self.ext, isRGB)
			arr = vtk.vtkStringArray()
			for fileName in files:
				arr.InsertNextValue(os.path.join(dirName, fileName))
			rdr.SetFileNames(arr)
			self.readers.append(rdr)
			return
			
		if imgAmnt > 1:
			# If the pattern doesn't have %, then we just use
			# the given filenames and allocate them to timepoints
			# using  slicesPerTimepoint slices per timepoint
			ntps = len(files) / self.slicesPerTimepoint
			filelst = files[:]
			# dirn #TODO: what was this?
			for tp in range(0, ntps):
				rdr = self.getReaderByExtension(self.ext, isRGB)
				arr = vtk.vtkStringArray()
				for i in range(0, self.slicesPerTimepoint):
					arr.InsertNextValue(filelst[0])
					filelst = filelst[1:]
				rdr.SetFileNames(arr)
				rdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)
				rdr.SetDataSpacing(self.spacing)
				rdr.SetDataOrigin(0, 0, 0)
				self.readers.append(rdr)
			return
		
		elif imgAmnt == 1:
			# If only one file
			rdr = self.getReaderByExtension(self.ext, isRGB)
			rdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)
			rdr.SetDataSpacing(self.spacing)
			rdr.SetDataOrigin(0, 0, 0)
			rdr.SetFileName(files[0])

			Logging.info("Reader = ", rdr, kw = "io")
			self.readers.append(rdr)