def DirList(baseDir):
r = ImageReader()
imgStats = {}
for root, dirs, files in os.walk(str(baseDir)):
for f1 in files:
if f1.endswith(".jpg") or f1.endswith(".jpe") or f1.endswith(".jpeg"):
id = root + "/" + f1
r.setId(id)
if r is None:
print "Couldn\'t open image from file:", id
continue
w = r.getSizeX()
h = r.getSizeY()
imgStats[str(w) + "_" + str(h)] = imgStats.get(str(w) + "_" + str(h), 0)+1
IJ.log("Found image: " + str(id))
#counter += 1
r.close()
#print summary
summary = ''
for k, v in imgStats.iteritems():
dim = k.split("_")
ratio = float(dim[0])/float(dim[1])
IJ.log("Found " + str(v) + " images of dimension " + str(dim[0]) + "x" + str(dim[1]) + " apect ratio " + str(round(ratio, 2)))
summary = summary + "\nFound " + str(v) + " images of dimension " + str(dim[0]) + "x" + str(dim[1]) + " apect ratio " + str(round(ratio, 2))
return summary
def DirList(baseDir):
r = ImageReader()
imgStats = {}
for root, dirs, files in os.walk(str(baseDir)):
for f1 in files:
if f1.endswith(".jpg") or f1.endswith(".jpe") or f1.endswith(
".jpeg"):
id = root + "/" + f1
r.setId(id)
if r is None:
print "Couldn\'t open image from file:", id
continue
w = r.getSizeX()
h = r.getSizeY()
imgStats[str(w) + "_" +
str(h)] = imgStats.get(str(w) + "_" + str(h), 0) + 1
IJ.log("Found image: " + str(id))
#counter += 1
r.close()
#print summary
summary = ''
for k, v in imgStats.iteritems():
dim = k.split("_")
ratio = float(dim[0]) / float(dim[1])
IJ.log("Found " + str(v) + " images of dimension " + str(dim[0]) +
"x" + str(dim[1]) + " apect ratio " + str(round(ratio, 2)))
summary = summary + "\nFound " + str(
v) + " images of dimension " + str(dim[0]) + "x" + str(
dim[1]) + " apect ratio " + str(round(ratio, 2))
return summary
def get_ome_metadata(source, imagenames):
"""Get the stage coordinates and calibration from the ome-xml for a given list of images
Arguments:
source {string} -- Path to the images
imagenames {list} -- list of images filenames
Returns:
a tuple that contains:
dimensions {int} -- number of dimensions (2D or 3D)
stage_coordinates_x {list} -- the abosolute stage x-coordinates from ome-xml metadata
stage_coordinates_y {list} -- the abosolute stage y-coordinates from ome-xml metadata
stage_coordinates_z {list} -- the abosolute stage z-coordinates from ome-xml metadata
relative_coordinates_x_px {list} -- the relative stage x-coordinates in px
relative_coordinates_y_px {list} -- the relative stage y-coordinates in px
relative_coordinates_z_px {list} -- the relative stage z-coordinates in px
image_calibration {list} -- x,y,z image calibration in unit/px
calibration_unit {string} -- image calibration unit
image_dimensions_czt {list} -- number of images in dimensions c,z,t
"""
# open an array to store the abosolute stage coordinates from metadata
stage_coordinates_x = []
stage_coordinates_y = []
stage_coordinates_z = []
for counter, image in enumerate(imagenames):
# parse metadata
reader = ImageReader()
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(source + str(image))
# get hyperstack dimensions from the first image
if counter == 0:
frame_size_x = reader.getSizeX()
frame_size_y = reader.getSizeY()
frame_size_z = reader.getSizeZ()
frame_size_c = reader.getSizeC()
frame_size_t = reader.getSizeT()
# note the dimensions
if frame_size_z == 1:
dimensions = 2
if frame_size_z > 1:
dimensions = 3
# get the physical calibration for the first image series
physSizeX = omeMeta.getPixelsPhysicalSizeX(0)
physSizeY = omeMeta.getPixelsPhysicalSizeY(0)
physSizeZ = omeMeta.getPixelsPhysicalSizeZ(0)
# workaround to get the z-interval if physSizeZ.value() returns None.
z_interval = 1
if physSizeZ is not None:
z_interval = physSizeZ.value()
if frame_size_z > 1 and physSizeZ is None:
print "no z calibration found, trying to recover"
first_plane = omeMeta.getPlanePositionZ(0, 0)
next_plane_imagenumber = frame_size_c + frame_size_t - 1
second_plane = omeMeta.getPlanePositionZ(
0, next_plane_imagenumber)
z_interval = abs(
abs(first_plane.value()) - abs(second_plane.value()))
print "z-interval seems to be: ", z_interval
# create an image calibration
image_calibration = [
physSizeX.value(),
physSizeY.value(), z_interval
]
calibration_unit = physSizeX.unit().getSymbol()
image_dimensions_czt = [frame_size_c, frame_size_z, frame_size_t]
reader.close()
# get the plane position in calibrated units
current_position_x = omeMeta.getPlanePositionX(0, 0)
current_position_y = omeMeta.getPlanePositionY(0, 0)
current_position_z = omeMeta.getPlanePositionZ(0, 0)
# get the absolute stage positions and store them
pos_x = current_position_x.value()
pos_y = current_position_y.value()
if current_position_z is None:
print "the z-position is missing in the ome-xml metadata."
pos_z = 1.0
else:
pos_z = current_position_z.value()
stage_coordinates_x.append(pos_x)
stage_coordinates_y.append(pos_y)
stage_coordinates_z.append(pos_z)
# calculate the store the relative stage movements in px (for the grid/collection stitcher)
relative_coordinates_x_px = []
relative_coordinates_y_px = []
relative_coordinates_z_px = []
for i in range(len(stage_coordinates_x)):
rel_pos_x = (stage_coordinates_x[i] -
stage_coordinates_x[0]) / physSizeX.value()
rel_pos_y = (stage_coordinates_y[i] -
stage_coordinates_y[0]) / physSizeY.value()
rel_pos_z = (stage_coordinates_z[i] -
stage_coordinates_z[0]) / z_interval
relative_coordinates_x_px.append(rel_pos_x)
relative_coordinates_y_px.append(rel_pos_y)
relative_coordinates_z_px.append(rel_pos_z)
return (dimensions, stage_coordinates_x, stage_coordinates_y,
stage_coordinates_z, relative_coordinates_x_px,
relative_coordinates_y_px, relative_coordinates_z_px,
image_calibration, calibration_unit, image_dimensions_czt)
def run():
t_start = datetime.now()
image_paths = glob(os.path.join(str(import_dir.getPath()), '*tif'))
print '\tread image metadata'
reader = ImageReader()
in_meta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(in_meta)
x_dims = []
y_dims = []
z_dims = []
c_dims = []
t_dims = []
eff = []
spp = []
for image_path in image_paths:
print '\t parse %s' % (image_path)
reader.setId(image_path)
x_dims.append(reader.getSizeX())
y_dims.append(reader.getSizeY())
z_dims.append(reader.getSizeZ())
c_dims.append(reader.getSizeC())
t_dims.append(reader.getSizeT())
eff.append(reader.imageCount / z_dims[-1] / t_dims[-1])
spp.append(reader.getSizeC() / eff[-1])
format = FormatTools.getPixelTypeString(reader.getPixelType())
series = reader.getSeries()
big_endian = Boolean.FALSE
order = reader.getDimensionOrder()
reader.close()
# Compute the dimensions of the output file
x_dim = max(x_dims)
y_dim = max(y_dims)
z_dim = max(z_dims)
c_dim = max(c_dims)
t_dim = max(t_dims)
print '\t series: %i' % series
print '\t format: %s' % format
print '\t dimension order: %s' % order
print '\t x: %s -> %i' % (x_dims, x_dim)
print '\t y: %s -> %i' % (y_dims, y_dim)
print '\t z: %s -> %i' % (z_dims, z_dim)
print '\t c: %s -> %i' % (c_dims, c_dim)
print '\t t: %s -> %i' % (t_dims, t_dim)
print '\t effective size c: %s' % eff
print '\t samples per pixel: %s' % spp
# Get the time dimension from the number of input files
t_dim = len(image_paths)
# TODO: Tried to work out the order with Axes class, got something weird though.
dimensions = [Short(x_dim), Short(y_dim), Short(c_dim), Short(z_dim)]
pixels_per_plane = x_dim * y_dim
# Assemble the metadata for the output file
out_meta = MetadataTools.createOMEXMLMetadata()
out_meta.setImageID(MetadataTools.createLSID('Image', series), series)
out_meta.setPixelsID(MetadataTools.createLSID('Pixels', series), series)
out_meta.setPixelsBinDataBigEndian(Boolean.TRUE, 0, 0)
out_meta.setPixelsDimensionOrder(DimensionOrder.fromString(order), series)
out_meta.setPixelsType(PixelType.fromString(format), series)
out_meta.setPixelsSizeX(PositiveInteger(x_dim), series)
out_meta.setPixelsSizeY(PositiveInteger(y_dim), series)
out_meta.setPixelsSizeZ(PositiveInteger(z_dim), series)
out_meta.setPixelsSizeC(PositiveInteger(c_dim), series)
out_meta.setPixelsSizeT(PositiveInteger(t_dim), series)
for c in range(c_dim):
out_meta.setChannelID(MetadataTools.createLSID('Channel', series, c),
series, c)
out_meta.setChannelSamplesPerPixel(PositiveInteger(1), series, c)
# Initialize the BF writer
result_path = os.path.join(result_dir.getPath(), result_name)
writer = ImageWriter()
writer.setMetadataRetrieve(out_meta)
writer.setId(result_path)
print '\tcreated to %s' % (result_path)
# Write the stacks into the output file
N = len(image_paths)
for i, image_path in enumerate(image_paths):
status.showStatus(i, N, "catenating %i of %i time-points" % (i, N))
print '\t processing %s' % (image_path)
ds = io.open(image_path)
xi = ds.dimensionIndex(Axes.X)
xv = ds.dimension(xi)
yi = ds.dimensionIndex(Axes.Y)
yv = ds.dimension(yi)
zi = ds.dimensionIndex(Axes.Z)
zv = ds.dimension(zi)
ti = ds.dimensionIndex(Axes.TIME)
tv = ds.dimension(ti)
ci = ds.dimensionIndex(Axes.CHANNEL)
cv = ds.dimension(ci)
dx = float(x_dim - xv) / 2.0
dy = float(y_dim - yv) / 2.0
dz = float(z_dim - zv) / 2.0
print '\t translation vector (dx, dy, dz) = (%f, %f, %f)' % (
dx, dy, dz)
if (dx != 0) or (dy != 0) or (dz != 0):
stk = Views.translate(ds, long(dx), long(dy), long(0), long(dz))
stk = Views.extendZero(stk)
else:
stk = Views.extendZero(ds.getImgPlus().getImg())
print '\t writing planes ',
n = 0
plane = 1
byte_array = []
interval_view = Views.interval(stk, \
[Long(0), Long(0), Long(0), Long(0)], \
[Long(x_dim - 1), Long(y_dim - 1), Long(c_dim - 1), Long(z_dim - 1)])
cursor = interval_view.cursor()
while cursor.hasNext():
n += 1
cursor.fwd()
value = cursor.get().getInteger()
bytes = DataTools.shortToBytes(value, big_endian)
byte_array.extend(bytes)
if n == pixels_per_plane:
writer.saveBytes(plane - 1, byte_array)
print '.',
if ((plane) % 10) == 0:
print '\n\t ',
byte_array = []
plane += 1
n = 0
print ' '
writer.close()
t = datetime.now() - t_start
print '\twrote %i planes to %s in %i sec.' % (plane - 1, result_path,
t.total_seconds())
print '... done.'
scale = 2
# set the tile sizes to be used
tileSizeX = 1024
tileSizeY = 1024
# setup reader
reader = ImageReader()
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(file)
# add resolution metadata
for i in range(resolutions):
divScale = Math.pow(scale, i + 1)
omeMeta.setResolutionSizeX(PositiveInteger(int(reader.getSizeX() / divScale)), 0, i + 1)
omeMeta.setResolutionSizeY(PositiveInteger(int(reader.getSizeY() / divScale)), 0, i + 1)
# setup writer with tiling
writer = PyramidOMETiffWriter()
writer.setMetadataRetrieve(omeMeta)
tileSizeX = writer.setTileSizeX(tileSizeX)
tileSizeY = writer.setTileSizeY(tileSizeY)
writer.setId(outFile)
type = reader.getPixelType()
# create image scaler for downsampling
scaler = SimpleImageScaler()
# convert to Pyramidal OME-TIFF using tiling
for series in range(reader.getSeriesCount()):
# settings
file = "/path/to/inputFile.tiff"
outFile = "/path/to/outputFile.ome.tiff"
resolutions = 4
scale = 2
# setup reader and parse metadata
reader = ImageReader()
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(file)
# setup resolutions
for i in range(resolutions):
divScale = Math.pow(scale, i + 1)
omeMeta.setResolutionSizeX(PositiveInteger(int(reader.getSizeX() / divScale)), 0, i + 1)
omeMeta.setResolutionSizeY(PositiveInteger(int(reader.getSizeY() / divScale)), 0, i + 1)
# setup writer
writer = OMETiffWriter()
writer.setMetadataRetrieve(omeMeta)
writer.setId(outFile)
type = reader.getPixelType()
# read and write main image
img = reader.openBytes(0)
writer.saveBytes(0, img)
# create ImageScaler for downsampling
scaler = SimpleImageScaler()
writer = OMETiffWriter()
writer.setMetadataRetrieve(omeMeta)
writer.setInterleaved(reader.isInterleaved())
writer.setTileSizeX(tileSizeX)
writer.setTileSizeY(tileSizeY)
writer.setId(outFile)
# convert to OME-TIFF using tiled reading and writing
for series in range(reader.getSeriesCount()):
reader.setSeries(series)
writer.setSeries(series)
# convert each image in the current series
for image in range(reader.getImageCount()):
width = reader.getSizeX()
height = reader.getSizeY()
# Determined the number of tiles to read and write
nXTiles = int(math.floor(width / tileSizeX))
nYTiles = int(math.floor(height / tileSizeY))
if nXTiles * tileSizeX != width:
nXTiles = nXTiles + 1
if nYTiles * tileSizeY != height:
nYTiles = nYTiles + 1
for y in range(nYTiles):
for x in range(nXTiles):
# The x and y coordinates for the current tile
tileX = x * tileSizeX
tileY = y * tileSizeY
# Read tiles from the input file and write them to the output OME-Tiff
