def openedImagesmain(channel1, channel2, ignoreString, primarySize,
primaryImageThresh, secondaryImageThresh):
def writeTablesToCSV(id, roiOut, speckleOut):
try:
#append your labels to them before they're written
identifier = id[:-4]
speckleOut_ = RTC.appendColToFront(identifier, speckleOut)
roiOut_ = RTC.appendColToFront(identifier, roiOut)
#save the tables to csvs -- they will append to a currently existing csv
#or create a new one
Saves.table2CSV("speckleOutput.csv", speckleOut_)
Saves.table2CSV("AnalysisOutput.csv", roiOut_)
print("finished writing tables to csvs.")
except:
print("failed to write to csvs.")
finally:
print("")
#Begin
try:
RTC = ResultsTableToCSV(channel1, channel2, ignoreString)
primary, secondary, images = RTC.getOpenImageNames()
Binarize(primaryImageThresh, secondaryImageThresh, primary, secondary)
speckleInputs = "primary=[{}] secondary=[{}] " \
"redirect=None min_primary_size={} min_secondary_size=0.00000 " \
"show=none exclude speckle statistic secondary_object"
IJ.run("Speckle Inspector",
speckleInputs.format(primary, secondary, primarySize))
Saves = SaveStuff(primary)
Saves.saveLogs()
#Saves.saveNewImages(images)
Saves.saveAllImages(images)
speckleTableName = "Speckle List " + primary
roiTableName = "Roi Analysis"
roiOut = RTC.roiAnalysisToWrite(roiTableName)
speckleOut = RTC.readResultsTablesOfNumbers(speckleTableName)
WindowManager.closeAllWindows()
fijiDir = IJ.getDir("imagej")
fijiScriptsDir = join(fijiDir, "scripts")
writeTablesToCSV(primary, roiOut, speckleOut)
IJ.open(join(fijiScriptsDir, "SmootherSpeckling.py"))
print("script completed successfully.")
except:
print("sorry, the script broke :/")
finally:
print("")
def applyOffsets(fileList, jsonSettings, outputFilename):
# ---------------------------------------------
# Applies the nanometer offset read from the json
# configuration file (jsonSettings) to each of the
# csv files in fileList, then concatentates these
# all into one csv called outputFilename.
# ---------------------------------------------
print(outputFilename)
finalOutputCSV = list()
countFiles = 0
header = ""
for filename in fileList:
offsetX = jsonSettings['Points'][countFiles]['X']
offsetY = jsonSettings['Points'][countFiles]['Y']
countFiles += 1
print(offsetY)
print(offsetX)
rowcounter = 0
with open(filename, 'rb') as tileFile:
tileData = csv.reader(tileFile)
for row in tileData:
if rowcounter == 0:
header = row
rowcounter += 1
continue
editRow = row
editRow[1] = float(editRow[1]) + float(offsetX)
editRow[2] = float(editRow[2]) + float(offsetY)
finalOutputCSV.append(editRow)
rowcounter = 0
with open(outputFilename, 'wb') as out:
myWriter = csv.writer(out)
myWriter.writerow(header)
myWriter.writerows(finalOutputCSV)
print("Finished!")
WindowManager.closeAllWindows()
IJ.run(
"Import results", "filepath=" + outputFilename +
" fileformat=[CSV (comma separated)] livepreview=true rawimagestack= startingframe=1 append=false"
)
return
def rigidAlignment(projectPath, params, name = '', boxFactor = 1):
# rigid alignment outside trakem2 with register virtual stack plugin because bug in trakem2
projectFolder = os.path.dirname(projectPath)
projectName = os.path.splitext(os.path.basename(projectPath))[0]
project, loader, layerset, nLayers = openTrakemProject(projectPath)
exportForRigidAlignmentFolder = mkdir_p(os.path.join(projectFolder, 'exportForRigidAlignment'))
resultRigidAlignmentFolder = mkdir_p(os.path.join(projectFolder, 'resultRigidAlignment'))
bb = layerset.get2DBounds()
roi = Rectangle(int(bb.width/2 * (1 - boxFactor)), int(bb.height/2 * (1 - boxFactor)), int(bb.width*boxFactor), int(bb.height*boxFactor))
boxPath = os.path.join(resultRigidAlignmentFolder, 'alignmentBox.txt')
writeRectangle(roi, boxPath)
exportFlat(project, exportForRigidAlignmentFolder, 1, baseName = 'exportForRigidAlignment', roi = roi)
referenceName = naturalSort(os.listdir(exportForRigidAlignmentFolder))[0]
use_shrinking_constraint = 0
IJ.log('Rigid alignment with register virtual stack')
Register_Virtual_Stack_MT.exec(exportForRigidAlignmentFolder, resultRigidAlignmentFolder, resultRigidAlignmentFolder, referenceName, params, use_shrinking_constraint)
time.sleep(2)
IJ.log('Warning: rigidAlignment closing all existing windows')
WindowManager.closeAllWindows() # problematic because it also closes the log window
# IJ.getImage().close()
for l, layer in enumerate(layerset.getLayers()):
imagePath = os.path.join(exportForRigidAlignmentFolder, 'exportForRigidAlignment_' + str(l).zfill(4) + '.tif')
transformPath = os.path.join(resultRigidAlignmentFolder, 'exportForRigidAlignment_' + str(l).zfill(4) + '.xml')
aff = getAffFromRVSTransformPath(transformPath)
for patch in layer.getDisplayables(Patch):
patch.setLocation(patch.getX()-roi.x, patch.getY()-roi.y) # compensate for the extracted bounding box
# patch.setLocation(roi.x, roi.y) # compensate for the extracted bounding box
currentAff = patch.getAffineTransform()
currentAff.preConcatenate(aff)
patch.setAffineTransform(currentAff)
resizeDisplay(layerset)
project.save()
closeProject(project)
IJ.log('All LM layers have been aligned in: ' + projectPath)
def runThunderSTORM(filename):
# ---------------------------------------------
# Runs the ThunderSTORM plugin on the filename
# provided with the settings from the top of
# this file.
# ---------------------------------------------
global exportList
if virtualStack:
IJ.openVirtual(filename)
else:
IJ.open(filename)
IJ.run(stormAnalysisCmd, stormAnalysisParams)
dataStoreFilename = os.path.dirname(filename) + os.sep + os.path.splitext(
os.path.basename(filename))[0] + ".csv"
exportList.append(dataStoreFilename)
exportParams = stormExportParams.replace("%filename", dataStoreFilename)
print exportParams
IJ.run(stormExportCmd, exportParams)
WindowManager.closeAllWindows()
return exportList
# rigid alignment outside trakem2 with register virtual stack plugin because bug in trakem2
transformsPath = os.path.join(
MagC_EM_Folder, 'rigidAlignmentTransforms_' + namePlugin + '.txt')
referenceName = fc.naturalSort(os.listdir(exportForRigidAlignmentFolder))[0]
use_shrinking_constraint = 0
if len(os.listdir(resultRigidAlignmentFolder)) != 2 * len(
os.listdir(inputFolder)):
IJ.log('Rigid alignment with register virtual stack')
Register_Virtual_Stack_MT.exec(exportForRigidAlignmentFolder,
resultRigidAlignmentFolder,
resultRigidAlignmentFolder, referenceName,
regParams, use_shrinking_constraint)
time.sleep(2)
# IJ.getImage().close()
WindowManager.closeAllWindows()
IJ.log('Rigid Alignment done')
else:
IJ.log('Rigid alignment already performed - skipping')
################################################
###########################################
IJ.log('Aligning the lowEM with the new rigid transforms')
projectPath = fc.cleanLinuxPath(
fc.findFilesFromTags(MagCFolder,
['EMProject_'])[0]) # this is the low res EM
project, loader, layerset, nLayers = fc.openTrakemProject(
projectPath) # the low res EM
for l, layer in enumerate(layerset.getLayers()):
transformPath = os.path.join(
# For ImageJ/Fiji
from ij import IJ, ImagePlus, 'plugin.frame'
import inspect
import pprint as pp
imp = IJ.getImage()
a = inspect.getmembers(imp)
print(a)
## test
from ij import WindowManager as wm
wm.closeAllWindows("Others")
import inspect
from ij import IJ, ImagePlus
from ij import WindowManager as wm
IJ.selectWindow('ThunderSTORM: results')
a = wm.getCurrentWindow()
b = inspect.getmembers(a)
print(b)
'''
a = wm.getWindow('ThunderSTORM: results')
a.close()
'''
# %%
def analyze(tempFile):
# Get currently selected image
#imp = WindowManager.getCurrentImage()
imp = IJ.openImage(tempFile)
imp.show()
dims = imp.getDimensions();
imp.setDimensions(dims[2], dims[4], dims[3]);
#----------------------------
# Create the model object now
#----------------------------
# Some of the parameters we configure below need to have
# a reference to the model at creation. So we create an
# empty model now.
model = Model()
# Send all messages to ImageJ log window.
model.setLogger(Logger.IJ_LOGGER)
#------------------------
# Prepare settings object
#------------------------
settings = Settings()
settings.setFrom(imp)
print(settings.imageFileName)
# Configure detector - We use the Strings for the keys
settings.detectorFactory = LogDetectorFactory()
settings.detectorSettings = {
'DO_SUBPIXEL_LOCALIZATION' : False,
'RADIUS' : 20.,
'TARGET_CHANNEL' : 1,
'THRESHOLD' : 0.95,
'DO_MEDIAN_FILTERING' : True,
}
# Configure spot filters - Classical filter on quality
#filter1 = FeatureFilter('QUALITY', 0.5, True)
#settings.addSpotFilter(filter1)
# Configure tracker - We want to allow merges and fusions
settings.trackerFactory = SimpleSparseLAPTrackerFactory()
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() #probably good enough
#settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = False
#settings.trackerSettings['ALLOW_TRACK_MERGING'] = False
settings.trackerSettings['LINKING_MAX_DISTANCE'] = 35.0
settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE']= 60.0
settings.trackerSettings['MAX_FRAME_GAP']= 2
# Configure track analyzers - Later on we want to filter out tracks
# based on their displacement, so we need to state that we want
# track displacement to be calculated. By default, out of the GUI,
# not features are calculated.
# The displacement feature is provided by the TrackDurationAnalyzer.
settings.addTrackAnalyzer(TrackDurationAnalyzer())
#-------------------
# Instantiate plugin
#-------------------
trackmate = TrackMate(model, settings)
ok = trackmate.process()
if not ok:
sys.exit(str(trackmate.getErrorMessage()))
#----------------
# Display results
#----------------
selectionModel = SelectionModel(model)
displayer = HyperStackDisplayer(model, selectionModel, imp)
displayer.render()
displayer.refresh()
# Echo results with the logger we set at start:
model.getLogger().log(str(model))
print(str(settings))
filename = os.path.splitext(settings.imageFileName)
pathname = settings.imageFolder + "" + filename[0] + "tracks.xml"
guicontroller = TrackMateGUIController(trackmate)
newFile = File(pathname)
ExportTracksToXML(guicontroller).export(model, settings, newFile)
actionObject = CaptureOverlayAction()
actionObject.execute(trackmate)
imp = WindowManager.getCurrentImage()
fileSaver = FileSaver(imp)
fileSaver.saveAsTiffStack(settings.imageFolder + "" + filename[0] + "overlay.tif")
WindowManager.closeAllWindows()
guicontroller.quit()
selectionModel.clearSelection();
model.clearTracks(1)
