def generateOverlay(project, patch, shape):
oWidth = patch.getOWidth()
oHeight = patch.getOHeight()
overlayp = ByteProcessor(oWidth, oHeight)
# TODO: Use ShortProcessor instead of ByteProcessor
imp = ImagePlus("Patch %s" % patch, overlayp)
stepX = oWidth/shape[0]
stepY = oHeight/shape[1]
color = 1
for x in xrange(shape[0]):
offsetX = x * stepX
for y in xrange(shape[1]):
offsetY = y * stepY
imp.setRoi(offsetX, offsetY, stepX, stepY)
imp.getProcessor().setValue(color)
imp.getProcessor().fill()
color += 1
imp.setRoi(None)
overlayPatch = Patch(project, "%s_overlay" % patch, 0.0, 0.0, imp)
overlayPatch.setAffineTransform(patch.getAffineTransform())
overlayPatch.setCoordinateTransform(patch.getCoordinateTransform())
return overlayPatch
def extract_stack_under_arealist():
# Check that a Display is open
display = Display.getFront()
if display is None:
IJ.log("Open a TrakEM2 Display first!")
return
# Check that an AreaList is selected and active:
ali = display.getActive()
if ali is None or not isinstance(ali, AreaList):
IJ.log("Please select an AreaList first!")
return
# Get the range of layers to which ali paints:
ls = display.getLayerSet()
ifirst = ls.indexOf(ali.getFirstLayer())
ilast = ls.indexOf(ali.getLastLayer())
layers = display.getLayerSet().getLayers().subList(ifirst, ilast + 1)
# Create a stack with the dimensions of ali
bounds = ali.getBoundingBox()
stack = ImageStack(bounds.width, bounds.height)
# Using 16-bit. To change to 8-bit, use GRAY8 and ByteProcessor in the two lines below:
type = ImagePlus.GRAY16
ref_ip = ShortProcessor(bounds.width, bounds.height)
for layer in layers:
area = ali.getArea(layer)
z = layer.getZ()
ip = ref_ip.createProcessor(bounds.width, bounds.height)
if area is None:
stack.addSlice(str(z), bp)
continue
# Create a ROI from the area of ali at layer:
aff = ali.getAffineTransformCopy()
aff.translate(-bounds.x, -bounds.y)
roi = ShapeRoi(area.createTransformedArea(aff))
# Create a cropped snapshot of the images at layer under ali:
flat = Patch.makeFlatImage(type, layer, bounds, 1.0,
layer.getDisplayables(Patch), Color.black)
b = roi.getBounds()
flat.setRoi(roi)
ip.insert(flat.crop(), b.x, b.y)
# Clear the outside of ROI (ShapeRoi is a non-rectangular ROI type)
bimp = ImagePlus("", ip)
bimp.setRoi(roi)
ip.setValue(0)
ip.setBackgroundValue(0)
IJ.run(bimp, "Clear Outside", "")
# Accumulate slices
stack.addSlice(str(z), ip)
imp = ImagePlus("AreaList stack", stack)
imp.setCalibration(ls.getCalibrationCopy())
imp.show()
def extract_stack_under_arealist():
# Check that a Display is open
display = Display.getFront()
if display is None:
IJ.log("Open a TrakEM2 Display first!")
return
# Check that an AreaList is selected and active:
ali = display.getActive()
if ali is None or not isinstance(ali, AreaList):
IJ.log("Please select an AreaList first!")
return
# Get the range of layers to which ali paints:
ls = display.getLayerSet()
ifirst = ls.indexOf(ali.getFirstLayer())
ilast = ls.indexOf(ali.getLastLayer())
layers = display.getLayerSet().getLayers().subList(ifirst, ilast +1)
# Create a stack with the dimensions of ali
bounds = ali.getBoundingBox()
stack = ImageStack(bounds.width, bounds.height)
# Using 16-bit. To change to 8-bit, use GRAY8 and ByteProcessor in the two lines below:
type = ImagePlus.GRAY16
ref_ip = ShortProcessor(bounds.width, bounds.height)
for layer in layers:
area = ali.getArea(layer)
z = layer.getZ()
ip = ref_ip.createProcessor(bounds.width, bounds.height)
if area is None:
stack.addSlice(str(z), bp)
continue
# Create a ROI from the area of ali at layer:
aff = ali.getAffineTransformCopy()
aff.translate(-bounds.x, -bounds.y)
roi = ShapeRoi(area.createTransformedArea(aff))
# Create a cropped snapshot of the images at layer under ali:
flat = Patch.makeFlatImage(type, layer, bounds, 1.0, layer.getDisplayables(Patch), Color.black)
b = roi.getBounds()
flat.setRoi(roi)
ip.insert(flat.crop(), b.x, b.y)
# Clear the outside of ROI (ShapeRoi is a non-rectangular ROI type)
bimp = ImagePlus("", ip)
bimp.setRoi(roi)
ip.setValue(0)
ip.setBackgroundValue(0)
IJ.run(bimp, "Clear Outside", "")
# Accumulate slices
stack.addSlice(str(z), ip)
imp = ImagePlus("AreaList stack", stack)
imp.setCalibration(ls.getCalibrationCopy())
imp.show()
for i in range(num_sections):
layerset.getLayer(i, 1, True)
layerset.setDimensions(im_width, im_height, LayerSet.NORTHWEST)
# ... and update the LayerTree:
project.getLayerTree().updateList(layerset)
# ... and the display slider
Display.updateLayerScroller(layerset)
filenames = sorted(os.listdir(storm_merged_folder))
filenames1 = sorted(os.listdir(conv_561_folder))
filenames2 = sorted(os.listdir(conv_merged_folder))
filenames3 = sorted(os.listdir(conv_align_folder))
#3 Load in images
for i, layer in enumerate(layerset.getLayers()):
#i = i +150 #use this to start in the middle of a dataset
filepath = os.path.join(storm_merged_folder, filenames[i])
patch = Patch.createPatch(project, filepath)
# patch.updateMipMaps()
layer.add(patch, False)
#
filepath = os.path.join(conv_merged_folder, filenames2[i])
patch = Patch.createPatch(project, filepath)
# patch.updateMipMaps()
layer.add(patch, False)
filepath = os.path.join(conv_561_folder, filenames1[i])
patch = Patch.createPatch(project, filepath)
# patch.updateMipMaps()
layer.add(patch, False)
filepath = os.path.join(conv_align_folder, filenames3[i])
patch = Patch.createPatch(project, filepath)
## Import tiles
# Get all layers
f = open(os.path.join(data_dir, "tile_location.txt"), "r")
z_list = []
for l in f.readlines():
elem = l[:-1].split(" ")
fname = elem[0]
xloc = int(elem[1])
yloc = int(elem[2])
zloc = int(elem[3])
z_list.append(zloc)
imp = IJ.openImage(os.path.join(img_dir, fname))
patch = Patch(project, imp.title, xloc, yloc, imp)
patch.project.loader.addedPatchFrom(os.path.join(img_dir, fname),
patch)
layer = layerset.getLayer(zloc, 1, True)
layer.add(patch)
f.close()
front = Display.getFront()
bounds = Rectangle(x=0, y=0, width=20000, height=20000)
front.resizeCanvas(bounds)
z_list.sort()
if z_list[0] != 0:
layer = layerset.getLayer(0, 1, False)
IJ.log('Inserting all patches')
for i in range(0, len(transforms), 8):
alignedPatchPath = transforms[i]
l = int(transforms[i + 1])
alignedPatchName = os.path.basename(alignedPatchPath)
toAlignPatchPath = fc.cleanLinuxPath(
os.path.join(os.path.dirname(alignedPatchPath),
alignedPatchName.replace(channels[-1], channel)))
toAlignPatchPath = toAlignPatchPath[:
-1] # remove a mysterious trailing character ...
IJ.log('In channel ' + str(channel) + ', inserting this image: ' +
str(toAlignPatchPath))
aff = AffineTransform(
[float(transforms[a]) for a in range(i + 2, i + 8)])
patch = Patch.createPatch(project, toAlignPatchPath)
layer = layerset.getLayers().get(l)
layer.add(patch)
patch.setAffineTransform(aff)
patch.updateBucket()
time.sleep(1)
IJ.log('Readjusting display')
fc.resizeDisplay(layerset)
IJ.log('Blending all layers')
Blending.blendLayerWise(layerset.getLayers(), True, None)
IJ.log('Exporting')
for scaleFactor in scaleFactors:
theBaseName = 'exported_downscaled_' + str(int(
1 / float(scaleFactor))) + '_' + channel
def computeRegistration():
while atomicI.get() < nSections:
l = atomicI.getAndIncrement()
if l < nSections:
IJ.log('Computing EM/LM registration for layer ' + str(l).zfill(4))
layerFolder = fc.mkdir_p(
os.path.join(registrationFolder, 'layer_' + str(l).zfill(4)))
toRegisterFolder = fc.mkdir_p(
os.path.join(layerFolder, 'toRegister'))
registeredFolder = fc.mkdir_p(
os.path.join(layerFolder, 'registered'))
# Applying appropriate filters to make lowresEM and LM look similar for layer l
imLM = IJ.openImage(imPaths['LM'][l])
imLM = fc.localContrast(imLM)
imLMPath = os.path.join(toRegisterFolder,
'imLM_' + str(l).zfill(4) + '.tif')
IJ.save(imLM, imLMPath)
imEM = IJ.openImage(imPaths['EM'][l])
imEM = fc.localContrast(imEM)
imEM = fc.blur(imEM, 2)
imEMPath = os.path.join(toRegisterFolder,
'imEM_' + str(l).zfill(4) + '.tif')
IJ.save(imEM, imEMPath)
# Compute first a simple affine registration on the non-cropped images
IJ.log(
'Computing affine and moving least squares alignment for layer '
+ str(l).zfill(4))
firstStepRegistered = False
# registration at first step with 1step/octave (less features)
pLowRes = getSIFTMatchingParameters(nOctaves[0], 1.6, 16, 4000, 8,
4)
featuresLM = getFeatures(imLMPath, pLowRes)
featuresEM = getFeatures(imEMPath, pLowRes)
matchingResults = getMatchingResults(featuresLM, featuresEM)
if matchingResults is None:
IJ.log(
'No registration matching at low resolution matching step 1 in layer '
+ str(l).zfill(4))
else:
model, inliers = matchingResults
distance = PointMatch.meanDistance(
inliers
) # mean displacement of the remaining matching features
IJ.log('---Layer ' + str(l).zfill(4) + ' distance ' +
str(distance) + ' px with ' + str(len(inliers)) +
' inliers')
if distance > matchingThreshold[0]:
IJ.log(
'Matching accuracy is lower than the threshold at the low resolution step 1 - '
+ str(l).zfill(4) + ' - distance - ' + str(distance))
else:
affTransform = model.createAffine()
s1, s2 = getScalingFactors(affTransform)
IJ.log('Layer ' + str(l).zfill(4) +
' scaling factors - step 1 - ' + str(s1) + ' - ' +
str(s2) + '--' + str(s1 * s2) + ' affDeterminant ' +
str(affTransform.getDeterminant()) + ' nInliers ' +
str(len(inliers)))
if (abs(s1 - 1) < 0.2) and (
abs(s2 - 1) < 0.2
): # scaling in both directions should be close to 1
IJ.log('First step ok - layer ' + str(l).zfill(4))
firstStepRegistered = True
loaderZ.serialize(
affTransform,
os.path.join(registeredFolder, 'affineSerialized'))
if not firstStepRegistered:
IJ.log(
'First step registration in layer ' + str(l).zfill(4) +
' with few features has failed. Trying with more features.'
)
# registration at first step with 3steps/octave (more features)
pLowRes = getSIFTMatchingParameters(3, 1.6, 64, 4000, 8, 4)
#pLowRes = getSIFTMatchingParameters(nOctaves[0], 1.6, 16, 4000, 8, 4) # for BIB
featuresLM = getFeatures(imLMPath, pLowRes)
featuresEM = getFeatures(imEMPath, pLowRes)
matchingResults = getMatchingResults(featuresLM, featuresEM)
if matchingResults is None:
IJ.log(
'No registration matching at low resolution matching step 1bis in layer '
+ str(l).zfill(4))
else:
model, inliers = matchingResults
distance = PointMatch.meanDistance(
inliers
) # mean displacement of the remaining matching features
IJ.log('---Layer ' + str(l).zfill(4) + ' distance ' +
str(distance) + ' px with ' + str(len(inliers)) +
' inliers')
if distance > matchingThreshold[0]:
IJ.log(
'Matching accuracy is lower than the threshold at the high resolution step 1bis - '
+ str(l).zfill(4) + ' - distance - ' +
str(distance))
else:
affTransform = model.createAffine()
s1, s2 = getScalingFactors(affTransform)
IJ.log('Layer ' + str(l).zfill(4) +
' scaling factors - step 1bis - ' + str(s1) +
' - ' + str(s2) + '--' + str(s1 * s2) +
' affDeterminant ' +
str(affTransform.getDeterminant()) +
' nInliers ' + str(len(inliers)))
if (abs(s1 - 1) < 0.2) and (
abs(s2 - 1) < 0.2
): # scaling in both directions should be close to 1
IJ.log('First step 1bis ok - layer ' +
str(l).zfill(4))
firstStepRegistered = True
loaderZ.serialize(
affTransform,
os.path.join(registeredFolder,
'affineSerialized'))
if not firstStepRegistered:
IJ.log('The two first step trials in layer ' +
str(l).zfill(4) + ' have failed')
else:
# Affine transform and crop the LM, and compute a high res MLS matching
with lock: # only one trakem working at a time
# apply affTransform
patch = Patch.createPatch(pZ, imLMPath)
layerZ.add(patch)
patch.setAffineTransform(affTransform)
patch.updateBucket()
# crop and export
bb = Rectangle(0, 0, widthEM, heightEM)
affineCroppedIm = loaderZ.getFlatImage(
layerZ, bb, 1, 0x7fffffff, ImagePlus.GRAY8, Patch,
layerZ.getAll(Patch), True, Color.black, None)
affineCroppedImPath = os.path.join(
toRegisterFolder,
'affineCroppedLM_' + str(l).zfill(4) + '.tif')
IJ.save(affineCroppedIm, affineCroppedImPath)
affineCroppedIm.close()
layerZ.remove(patch)
layerZ.recreateBuckets()
pHighRes = getSIFTMatchingParameters(nOctaves[1], 1.6, 64,
4096, 8, 4)
featuresLM = getFeatures(affineCroppedImPath, pHighRes)
featuresEM = getFeatures(imEMPath, pHighRes)
# get the MLS
matchingResults = getMatchingResults(featuresLM, featuresEM)
if matchingResults is None:
IJ.log(
'It cannot be, there should be a good match given that an affine was computed. Layer '
+ str(l).zfill(4))
else:
model, inliers = matchingResults
affTransform = model.createAffine()
s1, s2 = getScalingFactors(affTransform)
IJ.log('Second step determinant - layer ' +
str(l).zfill(4) + ' - determinant - ' +
str(affTransform.getDeterminant()) + ' nInliers ' +
str(len(inliers)) + 'Scaling factors - step 2 - ' +
str(s1) + ' - ' + str(s2))
if (abs(s1 - 1) < 0.2) and (abs(s2 - 1) < 0.2) and len(
inliers
) > 50: # scaling in both directions should be close to 1
distance = PointMatch.meanDistance(
inliers
) # mean displacement of the remaining matching features
if distance > matchingThreshold[1]:
IJ.log(
'Weird: matching accuracy is lower than the threshold at the high resolution step 2 - '
+ str(l).zfill(4) + ' - distance - ' +
str(distance))
else:
mlst = MovingLeastSquaresTransform()
mlst.setModel(AffineModel2D)
mlst.setAlpha(1)
mlst.setMatches(inliers)
xmlMlst = mlst.toXML('\t')
with open(
os.path.join(registeredFolder, 'MLST.xml'),
'w') as f:
f.write(xmlMlst)
loaderZ.serialize(
mlst,
os.path.join(registeredFolder,
'mlstSerialized'))
registrationStats.append(
[l, distance, len(inliers)])
registeredFolder = os.path.join(layerFolder, 'registered')
affTransformPath = os.path.join(registeredFolder, 'affineSerialized')
if os.path.isfile(affTransformPath):
affTransform = loaderZ.deserialize(affTransformPath)
for channel in channels:
affineCroppedFolder = os.path.join(LMFolder,
'affineCropped_' + channel)
LMMosaicsPath = fc.cleanLinuxPath(
os.path.join(
LMFolder, 'exported_downscaled_1_' + channel,
'exported_downscaled_1_' + channel + '_' +
str(l).zfill(4) + '.tif'))
patch = Patch.createPatch(pZ, LMMosaicsPath)
layerZ.add(patch)
IJ.log('Setting the affineTransform ' + str(affTransform))
patch.setAffineTransform(affTransform)
patch.updateBucket()
bb = Rectangle(0, 0, widthEM, heightEM)
affineCroppedIm = loaderZ.getFlatImage(layerZ, bb, 1, 0x7fffffff,
ImagePlus.GRAY8, Patch,
layerZ.getAll(Patch), True,
Color.black, None)
affineCroppedImPath = os.path.join(
affineCroppedFolder,
'affineCropped_' + channel + '_' + str(l).zfill(4) + '.tif')
IJ.save(affineCroppedIm, affineCroppedImPath)
affineCroppedIm.close()
p, loader, layerset, nLayers = fc.getProjectUtils(
fc.initTrakem(LMFolder, nLayers))
p.saveAs(projectPath, True)
layerset.setDimensions(0, 0, width0, height0)
for l, layer in enumerate(layerset.getLayers()):
layerFolder = os.path.join(registrationFolder,
'layer_' + str(l).zfill(4))
registeredFolder = os.path.join(layerFolder, 'registered')
MLSTPath = os.path.join(registeredFolder, 'MLST.xml')
if os.path.isfile(MLSTPath):
MLSTransform = CoordinateTransformXML().parse(MLSTPath)
affineCroppedImPath = os.path.join(
affineCroppedFolder,
'affineCropped_' + channel + '_' + str(l).zfill(4) + '.tif')
patch = Patch.createPatch(p, affineCroppedImPath)
layer.add(patch)
patch.setCoordinateTransform(
MLSTransform
) # does the order matter ? apparently yes, but I have to be sure that it is not an offset problem
IJ.log('Setting the mlsTransform in layer ' + str(l) + ' ' +
str(MLSTransform))
patch.updateBucket()
if idChannel < len(channels) - 2: # if it is a fluochannel
MLSTransformedFolder = fc.mkdir_p(
os.path.join(LMFolder, 'MLS_Transformed_' + str(channel),
''))
imp = loader.getFlatImage(layer, roiExport, 1, 0x7fffffff,
ImagePlus.GRAY8, Patch,
layer.getAll(Patch), True,
preprocessor_script_path = "/tmp/trakem2-n5.bsh"
with open(preprocessor_script_path, 'w') as f:
f.write(script)
# Create as many layers as indices in the Z dimension
layers = []
for z in xrange(dimensions[2]):
layer = layerset.getLayer(z, 1.0, True) # create if not there
layerset.addSilently(layer)
layers.append(layer)
# Add a single Patch instance per Layer, whose image is a 2D crop of the N5 volume
if 0 == layer.getDisplayables().size():
index = layerset.getLayerIndex(layer.getId())
patch = Patch(project, str(z), dimensions[0], dimensions[1],
dimensions[0], dimensions[1], img_type, 1.0, Color.black,
True, 0, 255, AffineTransform(), "")
layer.add(patch, False) # don't update displays
project.getLoader().setPreprocessorScriptPathSilently(
patch, preprocessor_script_path)
layerset.recreateBuckets(layers, True)
Display.updateLayerScroller(layerset)
# Export for CATMAID from raw images (strategy=0)
"""
saver = Saver("jpg")
saver.setQuality(0.75)
ExportMultilevelTiles.makePrescaledTiles(layers, Patch, Rectangle(0, 0, dimensions[0], dimensions[1]),
-1, img_type, tgt_dir, 0, saver, tile_side, 1,
True, True,