Exemplos de Plot em Python

Exemplo n.º 1

Arquivo: Voxelization.py Projeto: mgxd/ClearMap

def test():
    """Test voxelization module"""
    
    import iDISCO.Analysis.Voxelization as self
    reload(self)
    
    import iDISCO.Analysis.VoxelizationCode as vox
    import numpy
    
    
    points = numpy.random.rand(200,3) * 10;
    
    #use cython code
    vi = vox.voxelizeSphere(points, 20,20,20, 5,5,5);
    
    import iDISCO.Visualization.Plot as Plot

    Plot.plotTiling(vi)
    
    #use voxelize
    vi = self.voxelize(points, dataSize = (20,20,20), average = (5,5,5));
    
    Plot.plotTiling(vi)
    
    
    #weighted voxelization 
    points = numpy.random.rand(10,3) * 10;    
    weights = numpy.random.rand(10);
    
    #use voxelize
    vi = self.voxelize(points, dataSize = (20,20,20), average = (5,5,5));
    viw =  self.voxelize(points, dataSize = (20,20,20), average = (5,5,5), weights = weights);
    
    Plot.plotTiling(vi)
    Plot.plotTiling(viw)

Exemplo n.º 2

Arquivo: FileList.py Projeto: fshen11/fredClearMap

def test():
    """Test FileList module"""
    import ClearMap.IO.FileList as self
    reload(self)

    from iDISCO.Parameter import iDISCOPath
    import os
    import numpy

    basedir = iDISCOPath()
    fn = os.path.join(basedir, 'Test/Data/FileList/test\d{4}.tif')

    data = numpy.random.rand(20, 50, 10)
    data[5:15, 20:45, 2:9] = 0
    data = 20 * data
    data = data.astype('int32')

    print "writing raw image to: " + fn
    self.writeData(fn, data)

    print "Loading raw image from: " + fn
    img = self.readData(fn)
    print "Image size: " + str(img.shape)

    diff = img - data
    print(diff.max(), diff.min())

    fn = os.path.join(
        basedir,
        'Test/Data/OME/16-17-27_0_8X-s3-20HF_UltraII_C00_xyz-Table Z\d{4}.ome.tif'
    )

    fp, fl = self.readFileList(fn)
    print "Found " + str(len(fl)) + " images!"

    #dataSize
    print "dataSize  is %s" % str(self.dataSize(fn))
    print "dataZSize is %s" % str(self.dataZSize(fn))

    print "dataSize  is %s" % str(self.dataSize(fn, x=(10, 20)))
    print "dataZSize is %s" % str(self.dataZSize(fn))

    img = self.readData(fn, z=(17, all))
    print "Image size: " + str(img.shape)

    import iDISCO.Visualization.Plot as plt
    plt.plotTiling(img)

Exemplo n.º 3

Arquivo: FileList.py Projeto: ChristophKirst/ClearMapUnstable

def test():
    """Test FileList module"""
    import ClearMap.IO.FileList as self

    reload(self)

    from iDISCO.Parameter import iDISCOPath
    import os
    import numpy

    basedir = iDISCOPath()
    fn = os.path.join(basedir, "Test/Data/FileList/test\d{4}.tif")

    data = numpy.random.rand(20, 50, 10)
    data[5:15, 20:45, 2:9] = 0
    data = 20 * data
    data = data.astype("int32")

    print "writing raw image to: " + fn
    self.writeData(fn, data)

    print "Loading raw image from: " + fn
    img = self.readData(fn)
    print "Image size: " + str(img.shape)

    diff = img - data
    print (diff.max(), diff.min())

    fn = os.path.join(basedir, "Test/Data/OME/16-17-27_0_8X-s3-20HF_UltraII_C00_xyz-Table Z\d{4}.ome.tif")

    fp, fl = self.readFileList(fn)
    print "Found " + str(len(fl)) + " images!"

    # dataSize
    print "dataSize  is %s" % str(self.dataSize(fn))
    print "dataZSize is %s" % str(self.dataZSize(fn))

    print "dataSize  is %s" % str(self.dataSize(fn, x=(10, 20)))
    print "dataZSize is %s" % str(self.dataZSize(fn))

    img = self.readData(fn, z=(17, all))
    print "Image size: " + str(img.shape)

    import iDISCO.Visualization.Plot as plt

    plt.plotTiling(img)

Exemplo n.º 4

Arquivo: Voxelization.py Projeto: fshen11/fredClearMap

def test():
    """Test voxelization module"""

    import iDISCO.Analysis.Voxelization as self
    reload(self)

    import iDISCO.Analysis.VoxelizationCode as vox
    import numpy

    points = numpy.random.rand(200, 3) * 10

    #use cython code
    vi = vox.voxelizeSphere(points, 20, 20, 20, 5, 5, 5)

    import iDISCO.Visualization.Plot as Plot

    Plot.plotTiling(vi)

    #use voxelize
    vi = self.voxelize(points, dataSize=(20, 20, 20), average=(5, 5, 5))

    Plot.plotTiling(vi)

    #weighted voxelization
    points = numpy.random.rand(10, 3) * 10
    weights = numpy.random.rand(10)

    #use voxelize
    vi = self.voxelize(points, dataSize=(20, 20, 20), average=(5, 5, 5))
    viw = self.voxelize(points,
                        dataSize=(20, 20, 20),
                        average=(5, 5, 5),
                        weights=weights)

    Plot.plotTiling(vi)
    Plot.plotTiling(viw)

Exemplo n.º 5

Arquivo: test_elastix_transform.py Projeto: ChristophKirst/ClearMap

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

import iDISCO.Visualization.Plot as Plot
import iDISCO.IO.IO as io

Exemplo n.º 6

Arquivo: test_chain_data.py Projeto: MoritzNegwer/FriendlyClearmap

runInitializeElastix(parameter)

#pts = io.readPoints(parameter.ImageProcessing.CellCoordinateFile);
#pts = pts[0:10000, :];
#pts[0,:] = [0,0,0];
#pts = pts[:, [1,0,2]];

runCellCoordinateTransformationToReference(parameter)

#pts2 = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile);
#pts2 = pts2[:,[1,0,2]];

if verbose:
    refdata = io.readData(parameter.Alignment.FixedImage)
    #pts = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile);
    Plot.plotOverlayPoints(0.1 * refdata, pts2)

refdata.shape

pts2 = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile)
#pts2 = pts2[:,[1,0,2]];
voximg = vox.voxelizePixel(pts2, refdata.shape)
io.writeDataStack(os.path.join(basedirectory, 'points_transformed_pixel.tif'),
                  voximg)

##############################################################################
# Test Resample Points
##############################################################################

import os
import numpy

Exemplo n.º 7

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)
print img.dtype
print img.shape

# size of differeence of gaussian filter
parameter.ImageProcessing.Parameter.Dog = (7, 7, 11)

Exemplo n.º 8

Arquivo: test_chain_data.py Projeto: ChristophKirst/ClearMap

#pts = io.readPoints(parameter.ImageProcessing.CellCoordinateFile);
#pts = pts[0:10000, :];
#pts[0,:] = [0,0,0];
#pts = pts[:, [1,0,2]];

runCellCoordinateTransformationToReference(parameter)

#pts2 = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile);
#pts2 = pts2[:,[1,0,2]];


if verbose:
    refdata = io.readData(parameter.Alignment.FixedImage);
    #pts = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile);
    Plot.plotOverlayPoints(0.1 * refdata, pts2)


refdata.shape

pts2 = io.readPoints(parameter.ImageProcessing.CellTransformedCoordinateFile);
#pts2 = pts2[:,[1,0,2]];
voximg = vox.voxelizePixel(pts2, refdata.shape);
io.writeDataStack(os.path.join(basedirectory, 'points_transformed_pixel.tif'), voximg)






##############################################################################

Exemplo n.º 9

Arquivo: test_chain_synthetic.py Projeto: MoritzNegwer/FriendlyClearmap

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

import iDISCO.Settings as settings
import iDISCO.IO.IO as io
import iDISCO.Visualization.Plot as plot

Exemplo n.º 10

Arquivo: process_template.py Projeto: ChristophKirst/ClearMapUnstable

resultDirectory  = alignData(**RegistrationAlignmentParameter);


#
detectCells(**ImageProcessingParameter);


points, intensities = io.readPoints(ImageProcessingParameter["sink"]);
points, intensities = thresholdPoints(points, intensities, threshold = (20, 900), row = (3,3));
io.writePoints(FilteredCellsFile, (points, intensities));


# Check Cell; detection
import iDISCO.Visualization.Plot as plt;
pointSource= os.path.join(BaseDirectory, FilteredCellsFile[0]);
data = plt.overlayPoints(cFosFile, pointSource, pointColor = None, **cFosFileRange);
io.writeData(os.path.join(BaseDirectory, 'cells_check.tif'), data);


# Transform point coordinates

points = io.readPoints(CorrectionResamplingPointsParameter["pointSource"]);
points = resamplePoints(**CorrectionResamplingPointsParameter);
points = transformPoints(points, transformDirectory = CorrectionAlignmentParameter["resultDirectory"], indices = False, resultDirectory = None);
CorrectionResamplingPointsInverseParameter["pointSource"] = points;
points = resamplePointsInverse(**CorrectionResamplingPointsInverseParameter);
RegistrationResamplingPointParameter["pointSource"] = points;
points = resamplePoints(**RegistrationResamplingPointParameter);
points = transformPoints(points, transformDirectory = RegistrationAlignmentParameter["resultDirectory"], indices = False, resultDirectory = None);
io.writePoints(TransformedCellsFile, points);

Exemplo n.º 11

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

import iDISCO.Visualization.Plot as Plot
import iDISCO.IO.IO as io

Exemplo n.º 12

Arquivo: test_chain_synthetic.py Projeto: ChristophKirst/ClearMap

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

import iDISCO.Settings as settings
import iDISCO.IO.IO as io
import iDISCO.Visualization.Plot as plot

Exemplo n.º 13

Arquivo: test.py Projeto: ChristophKirst/ClearMap

#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);
print img.dtype
print img.shape

# size of differeence of gaussian filter
parameter.ImageProcessing.Parameter.Dog = (7, 7, 11);

img = ip.dogFilter(img, parameter = parameter.ImageProcessing, verbose =  verbose);

Exemplo n.º 14

Arquivo: process_Ilastik_template.py Projeto: fshen11/fredClearMap

points, intensities = io.readPoints(ImageProcessingParameter["sink"])

#Thresholding: the threshold parameter is either intensity or size in voxel, depending on the chosen "row"
#row = (0,0) : peak intensity from the raw data
#row = (1,1) : peak intensity from the DoG filtered data
#row = (2,2) : peak intensity from the background subtracted data
#row = (3,3) : voxel size from the watershed
points, intensities = thresholdPoints(points, intensities, threshold=20, row=1)
io.writePoints(FilteredCellsFile, (points, intensities))

## Check Cell detection (For the testing phase only, remove when running on the full size dataset)
#######################
import iDISCO.Visualization.Plot as plt
pointSource = os.path.join(BaseDirectory, FilteredCellsFile[0])
data = plt.overlayPoints(cFosFile,
                         pointSource,
                         pointColor=None,
                         **cFosFileRange)
io.writeData(os.path.join(BaseDirectory, 'cells_check.tif'), data)

# Transform point coordinates
#############################
points = io.readPoints(CorrectionResamplingPointsParameter["pointSource"])
points = resamplePoints(**CorrectionResamplingPointsParameter)
points = transformPoints(
    points,
    transformDirectory=CorrectionAlignmentParameter["resultDirectory"],
    indices=False,
    resultDirectory=None)
CorrectionResamplingPointsInverseParameter["pointSource"] = points
points = resamplePointsInverse(**CorrectionResamplingPointsInverseParameter)
RegistrationResamplingPointParameter["pointSource"] = points