def runCellCoordinateTransformationToReference(parameter): """Transform points by resampling and applying the elastix transformation in the reference data""" im = parameter.Resampling.DataFiles; if im is None: im = parameter.DataSource.ImageFile; cf = parameter.ImageProcessing.CellCoordinateFile; pa = parameter.Alignment; pr = parameter.Resampling; # downscale points to referenece image size points = resamplePoints(cf, im, resolutionData = pr.ResolutionData, resolutionReference = pr.ResolutionReference, orientation = pr.Orientation); # transform points #points = points[:,[1,0,2]]; points = transformPoints(points, alignmentdirectory = pa.AlignmentDirectory, transformparameterfile = None, read = True, tmpfile = None, outdirectory = None, indices = True); #points = points[:,[1,0,2]]; tf = parameter.ImageProcessing.CellTransformedCoordinateFile; if tf is None: return points; else: io.writePoints(tf, points); return tf;
def runVoxelization(parameter): """Voxelize a set of points""" cf = parameter.ImageProcessing.CellTransformedCoordinateFile; if cf is None: cf = parameter.ImageProcessing.CellCoordinateFile; points = io.readPoints(cf); pv = parameter.Voxelization; si = pv.Size; if si is None: si = parameter.Alignment.MovingImage; if si is None: si = parameter.Resampling.ResampledFile; if isinstance(si, basestring): si = dataSize(si); print si vox = voxelize(points, si, average = pv.AveragingDiameter, mode = pv.Mode); vf = pv.File; if vf is None: return vox; else: io.writeDataStack(vf, vox.astype('int32')); return vf;
def runVoxelization(parameter): """Voxelize a set of points""" cf = parameter.ImageProcessing.CellTransformedCoordinateFile if cf is None: cf = parameter.ImageProcessing.CellCoordinateFile points = io.readPoints(cf) pv = parameter.Voxelization si = pv.Size if si is None: si = parameter.Alignment.MovingImage if si is None: si = parameter.Resampling.ResampledFile if isinstance(si, str): si = dataSize(si) print(si) vox = voxelize(points, si, average=pv.AveragingDiameter, mode=pv.Mode) vf = pv.File if vf is None: return vox else: io.writeDataStack(vf, vox.astype('int32')) return vf
def runCellCoordinateTransformation(parameter): """Transform points by resampling applying the elastix transformation and then re-resample again""" im = parameter.Resampling.DataFiles; if im is None: im = parameter.DataSource.ImageFile; cf = parameter.ImageProcessing.CellCoordinateFile; pa = parameter.Alignment; pr = parameter.Resampling; # downscale points to referenece image size points = resamplePoints(cf, im, resolutionData = pr.ResolutionData, resolutionReference = pr.ResolutionReference, orientation = pr.Orientation); # transform points points = points[:,[1,0,2]]; # account for (y,x, z) array representaton here points = transformPoints(points, alignmentdirectory = pa.AlignmentDirectory, transformparameterfile = None, read = True, tmpfile = None, outdirectory = None, indices = False); points = points[:,[1,0,2]]; # account for (y,x, z) array representaton here # upscale ppints back to original size points = resamplePointsInverse(points, im, resolutionData = pr.ResolutionData, resolutionReference = pr.ResolutionReference, orientation = pr.Orientation); tf = parameter.ImageProcessing.CellTransformedCoordinateFile; if tf is None: return points; else: io.writePoints(tf, points); return tf;
def runCellDetection(parameter): """Detect cells in data""" timer = Timer() pp = parameter.StackProcessing ps = parameter.DataSource # run segmentation if parameter.ImageProcessing.Method == "SpotDetection": detectCells = iDISCO.ImageProcessing.SpotDetection.detectCells centers, intensities = parallelProcessStack( ps.ImageFile, x=ps.XRange, y=ps.YRange, z=ps.ZRange, processes=pp.Processes, chunksizemax=pp.ChunkSizeMax, chunksizemin=pp.ChunkSizeMin, chunkoverlap=pp.ChunkOverlap, optimizechunks=pp.OptimizeChunks, optimizechunksizeincrease=pp.OptimizeChunkSizeIncrease, segmentation=detectCells, parameter=parameter.ImageProcessing) else: if haveIlastik: #ilastik does parallel processing so do sequential processing here detectCells = iDISCO.ImageProcessing.IlastikClassification.detectCells centers, intensities = sequentiallyProcessStack( ps.ImageFile, x=ps.XRange, y=ps.YRange, z=ps.ZRange, chunksizemax=pp.ChunkSizeMax, chunksizemin=pp.ChunkSizeMin, chunkoverlap=pp.ChunkOverlap, segmentation=detectCells, parameter=parameter.ImageProcessing) else: raise RuntimeError( "No Ilastik installed use SpotDectection instead!") timer.printElapsedTime("Main") if not parameter.ImageProcessing.Parameter.ThresholdSave is None: iid = intensities > parameter.ImageProcessing.Parameter.ThresholdSave centers = centers[iid, :] if not parameter.ImageProcessing.PointFile is None: io.writePoints(parameter.ImageProcessing.PointFile, centers) if not parameter.ImageProcessing.IntensityFile is None: io.writePoints(parameter.ImageProcessing.IntensityFile, intensities) return centers, intensities
def runCellCoordinateTransformationToReference(parameter): """Transform points by resampling and applying the elastix transformation in the reference data""" im = parameter.Resampling.DataFiles if im is None: im = parameter.DataSource.ImageFile cf = parameter.ImageProcessing.CellCoordinateFile pa = parameter.Alignment pr = parameter.Resampling # downscale points to referenece image size points = resamplePoints(cf, im, resolutionData=pr.ResolutionData, resolutionReference=pr.ResolutionReference, orientation=pr.Orientation) # transform points #points = points[:,[1,0,2]]; points = transformPoints(points, alignmentdirectory=pa.AlignmentDirectory, transformparameterfile=None, read=True, tmpfile=None, outdirectory=None, indices=True) #points = points[:,[1,0,2]]; tf = parameter.ImageProcessing.CellTransformedCoordinateFile if tf is None: return points else: io.writePoints(tf, points) return tf
def runCellDetection(parameter): """Detect cells in data""" timer = Timer(); pp = parameter.StackProcessing; ps = parameter.DataSource; # run segmentation if parameter.ImageProcessing.Method == "SpotDetection": detectCells = iDISCO.ImageProcessing.SpotDetection.detectCells; centers, intensities = parallelProcessStack(ps.ImageFile, x = ps.XRange, y = ps.YRange, z = ps.ZRange, processes = pp.Processes, chunksizemax = pp.ChunkSizeMax, chunksizemin = pp.ChunkSizeMin, chunkoverlap = pp.ChunkOverlap, optimizechunks = pp.OptimizeChunks, optimizechunksizeincrease = pp.OptimizeChunkSizeIncrease, segmentation = detectCells, parameter = parameter.ImageProcessing); else: if haveIlastik: #ilastik does parallel processing so do sequential processing here detectCells = iDISCO.ImageProcessing.IlastikClassification.detectCells; centers, intensities = sequentiallyProcessStack(ps.ImageFile, x = ps.XRange, y = ps.YRange, z = ps.ZRange, chunksizemax = pp.ChunkSizeMax, chunksizemin = pp.ChunkSizeMin, chunkoverlap = pp.ChunkOverlap, segmentation = detectCells, parameter = parameter.ImageProcessing); else: raise RuntimeError("No Ilastik installed use SpotDectection instead!"); timer.printElapsedTime("Main"); if not parameter.ImageProcessing.Parameter.ThresholdSave is None: iid = intensities > parameter.ImageProcessing.Parameter.ThresholdSave; centers = centers[iid,:]; if not parameter.ImageProcessing.PointFile is None: io.writePoints(parameter.ImageProcessing.PointFile, centers); if not parameter.ImageProcessing.IntensityFile is None: io.writePoints(parameter.ImageProcessing.IntensityFile, intensities); return centers, intensities;
def runCellCoordinateTransformation(parameter): """Transform points by resampling applying the elastix transformation and then re-resample again""" im = parameter.Resampling.DataFiles if im is None: im = parameter.DataSource.ImageFile cf = parameter.ImageProcessing.CellCoordinateFile pa = parameter.Alignment pr = parameter.Resampling # downscale points to referenece image size points = resamplePoints(cf, im, resolutionData=pr.ResolutionData, resolutionReference=pr.ResolutionReference, orientation=pr.Orientation) # transform points points = points[:, [1, 0, 2]] # account for (y,x, z) array representaton here points = transformPoints(points, alignmentdirectory=pa.AlignmentDirectory, transformparameterfile=None, read=True, tmpfile=None, outdirectory=None, indices=False) points = points[:, [1, 0, 2]] # account for (y,x, z) array representaton here # upscale ppints back to original size points = resamplePointsInverse(points, im, resolutionData=pr.ResolutionData, resolutionReference=pr.ResolutionReference, orientation=pr.Orientation) tf = parameter.ImageProcessing.CellTransformedCoordinateFile if tf is None: return points else: io.writePoints(tf, points) return tf
def runCellCoordinateResampling(parameter): """Transform points by resampling""" im = parameter.Resampling.DataFiles; if im is None: im = parameter.DataSource.ImageFile; cf = parameter.ImageProcessing.CellCoordinateFile; pr = parameter.Resampling; # downscale points to referenece image size points = resamplePoints(cf, im, resolutionData = pr.ResolutionData, resolutionReference = pr.ResolutionReference, orientation = pr.Orientation); tf = parameter.ImageProcessing.CellTransformedCoordinateFile; if tf is None: return points; else: io.writePoints(tf, points); return tf;
def runCellCoordinateResampling(parameter): """Transform points by resampling""" im = parameter.Resampling.DataFiles if im is None: im = parameter.DataSource.ImageFile cf = parameter.ImageProcessing.CellCoordinateFile pr = parameter.Resampling # downscale points to referenece image size points = resamplePoints(cf, im, resolutionData=pr.ResolutionData, resolutionReference=pr.ResolutionReference, orientation=pr.Orientation) tf = parameter.ImageProcessing.CellTransformedCoordinateFile if tf is None: return points else: io.writePoints(tf, points) return tf
}; allParameter = joinParameter(stackProcessingParameter, spotDetectionParameter, {'x' : (100,160), 'y' : (10,140), 'z' : (2,38)}) #allParameter = joinParameter(stackProcessingParameter, spotDetectionParameter, {'x' : all, 'y' : all, 'z' : all}) result = detectCells(**allParameter); print result verbose = True; if verbose: import iDISCO.IO.IO as io import iDISCO.Visualization.Plot as plot dataraw = io.readData(spotDetectionParameter["source"]); dataraw[dataraw > 50] = 50; dataraw = dataraw.astype('float') / dataraw.max(); points = io.readPoints(spotDetectionParameter["sink"][0]); plot.plotOverlayPoints(dataraw, points, pointColor = [1,0,0]); dataraw = io.readData(spotDetectionParameter["source"], x = (100,160), y = (10,140), z = (2,38)); io.writeData( os.path.join(baseDirectory, 'Synthetic/raw.tif'), dataraw) ############################################################################## # Test Resample Points ############################################################################## import os
parameter.DataSource.ImageFile = os.path.join( basedirectory, 'Test/Data/OME/16-17-27_0_8X-s3-20HF_UltraII_C00_xyz-Table Z\d{4}.ome.tif') parameter.DataSource.ImageFile = '/run/media/ckirst/ChristophsBackuk4TB/Data/Science/Projects/BrainActiityMap/Experiment/iDISCO_2015_06/Adult cfos C row 20HF 150524.ims' #image ranges parameter.DataSource.XRange = all parameter.DataSource.YRange = all parameter.DataSource.ZRange = (100, 120) # load data data = io.readData(parameter.DataSource.ImageFile, x=parameter.DataSource.XRange, y=parameter.DataSource.YRange, z=parameter.DataSource.ZRange, resolution=0) print "Loaded data from " + parameter.DataSource.ImageFile print "Data size is: " + str(data.shape) # visualize if verbose: plt.plotTiling(15 * data) ### Process using Spot Detection # radius for background removal parameter.ImageProcessing.Parameter.Background = (15, 15)
#moving and reference images parameter.Alignment.MovingImage = os.path.join(basedirectory, 'autofluo_for_cfos_resample.tif'); parameter.Alignment.FixedImage = os.path.join(basedirectory, 'cfos_resample.tif'); parameter.Alignment.FixedImageMask = None; #elastix parameter files for alignment #parameter.Alignment.AffineParameterFile = os.path.join(parameter.Alignment.AlignmentDirectory, ''); #parameter.Alignment.BSplineParameterFile = os.path.join(parameter.Alignment.AlignmentDirectory, 'ElastixParameterBSpline.txt');# #parameter.Alignment.BSplineParameterFile = None; runInitializeElastix(parameter); pts = runCellCoordinateTransformation(parameter); io.writePoints(os.path.join(basedirectory, 'cells_to_autofluo.csv'), pts); ## Visualize cfos to auto points parameter.ImageProcessing.CellCoordinateFile = pts; parameter.ImageProcessing.CellTransformedCoordinateFile = None; pts2 = runCellCoordinateResampling(parameter) ds = dataSize(os.path.join(basedirectory, 'autofluo_for_cfos_resample.tif')); voximg = vox.voxelizePixel(pts2, ds); io.writeDataStack(os.path.join(basedirectory, 'points_transformed_cfos_to_auto.tif'), voximg) #pts0 = io.readPoints(os.path.join(basedirectory, 'cells.csv'));
}; allParameter = joinParameter(stackProcessingParameter, spotDetectionParameter, {'x' : (100,160), 'y' : (10,140), 'z' : (2,38)}) #allParameter = joinParameter(stackProcessingParameter, spotDetectionParameter, {'x' : all, 'y' : all, 'z' : all}) result = detectCells(**allParameter); print(result) verbose = True; if verbose: import iDISCO.IO.IO as io import iDISCO.Visualization.Plot as plot dataraw = io.readData(spotDetectionParameter["source"]); dataraw[dataraw > 50] = 50; dataraw = dataraw.astype('float') / dataraw.max(); points = io.readPoints(spotDetectionParameter["sink"][0]); plot.plotOverlayPoints(dataraw, points, pointColor = [1,0,0]); dataraw = io.readData(spotDetectionParameter["source"], x = (100,160), y = (10,140), z = (2,38)); io.writeData( os.path.join(baseDirectory, 'Synthetic/raw.tif'), dataraw) ############################################################################## # Test Resample Points ############################################################################## import os
#moving and reference images parameter.Alignment.MovingImage = os.path.join(basedirectory, 'Synthetic/test_iDISCO_resample.tif'); parameter.Alignment.FixedImage = os.path.join(basedirectory, 'Synthetic/test_iDISCO_reference.tif'); parameter.Alignment.FixedImageMask = None; #elastix parameter files for alignment parameter.Alignment.AffineParameterFile = os.path.join(parameter.Alignment.AlignmentDirectory, 'ElastixParameterAffine.txt'); #parameter.Alignment.BSplineParameterFile = os.path.join(parameter.Alignment.AlignmentDirectory, 'ElastixParameterBSpline.txt'); parameter.Alignment.BSplineParameterFile = None; runInitializeElastix(parameter) runCellCoordinateTransformationToReference(parameter) if verbose: refdata = io.readData(parameter.Alignment.FixedImage); pts = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile); Plot.plotOverlayPoints(0.01 * refdata, pts) ############################################################################## # Test Voxelization ############################################################################## import os from iDISCO.Parameter import * from iDISCO.Run import runVoxelization
parameter.Alignment.MovingImage = os.path.join( basedirectory, 'autofluo_for_cfos_resample.tif') parameter.Alignment.FixedImage = os.path.join(basedirectory, 'cfos_resample.tif') parameter.Alignment.FixedImageMask = None #elastix parameter files for alignment #parameter.Alignment.AffineParameterFile = os.path.join(parameter.Alignment.AlignmentDirectory, ''); #parameter.Alignment.BSplineParameterFile = os.path.join(parameter.Alignment.AlignmentDirectory, 'ElastixParameterBSpline.txt');# #parameter.Alignment.BSplineParameterFile = None; runInitializeElastix(parameter) pts = runCellCoordinateTransformation(parameter) io.writePoints(os.path.join(basedirectory, 'cells_to_autofluo.csv'), pts) ## Visualize cfos to auto points parameter.ImageProcessing.CellCoordinateFile = pts parameter.ImageProcessing.CellTransformedCoordinateFile = None pts2 = runCellCoordinateResampling(parameter) ds = dataSize(os.path.join(basedirectory, 'autofluo_for_cfos_resample.tif')) voximg = vox.voxelizePixel(pts2, ds) io.writeDataStack( os.path.join(basedirectory, 'points_transformed_cfos_to_auto.tif'), voximg) #pts0 = io.readPoints(os.path.join(basedirectory, 'cells.csv'));
### Data Source #raw data from microscope used for cell detection (ims or tif) parameter.DataSource.ImageFile = os.path.join(basedirectory, 'Test/Data/OME/16-17-27_0_8X-s3-20HF_UltraII_C00_xyz-Table Z\d{4}.ome.tif') parameter.DataSource.ImageFile = '/run/media/ckirst/ChristophsBackuk4TB/Data/Science/Projects/BrainActiityMap/Experiment/iDISCO_2015_06/Adult cfos C row 20HF 150524.ims' #image ranges parameter.DataSource.XRange = all; parameter.DataSource.YRange = all; parameter.DataSource.ZRange = (100,120); # load data data = io.readData(parameter.DataSource.ImageFile, x = parameter.DataSource.XRange, y = parameter.DataSource.YRange, z = parameter.DataSource.ZRange, resolution = 0); print "Loaded data from " + parameter.DataSource.ImageFile; print "Data size is: " + str(data.shape) # visualize if verbose: plt.plotTiling(15*data) ### Process using Spot Detection # radius for background removal parameter.ImageProcessing.Parameter.Background = (15,15); img = ip.removeBackground(data, parameter = parameter.ImageProcessing, verbose = verbose);