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'));
#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
### 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);
