def DimensionCalculator(url):
dimension = 0
ij = imagej.init('./Imagej/Fiji.app', headless=False) # Start ImageJ from local file
image = ij.io().open(url)
ij.ui().show(image)
macro = """
run("8-bit");
setAutoThreshold("Default dark");
//run("Threshold...");
//setThreshold(128, 255);
setAutoThreshold("Default dark");
setOption("BlackBackground", true);
run("Convert to Mask", "method=Default background=Dark calculate black");
run("Fractal Box Count...", "box=2,3,4,6,8,12,16,32,64");
saveAs("Results","./Results/ResultsBC.csv");
run("Close")
run("Close")
run("Close")
"""
ij.py.run_macro(macro)
# reading results from saved csv file
with open('./Results/ResultsBC.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
line_count += 1
else:
dimension = row[10]
line_count += 1
#print(f'Dimension is {dimension}, source image: {url}')
return dimension
def stitch_all_samples(config, parallelize=0):
"""
"""
# TODO: Fill in docstring
workspace_directory = config["workspace_directory"]
input_directory = Path(workspace_directory, "unstitched")
output_directory = Path(workspace_directory, "stitched")
output_directory.mkdir(exist_ok=True)
samples = config["samples"]
path_to_fiji = config["path_to_fiji"]
# TODO: Figure out if it's possible to parallelize by sample here.
imagej_instance = imagej.init(path_to_fiji)
if parallelize > 1:
num_processes = mp.cpu_count()
processes = []
for sample in samples:
process = mp.Process(target=stitch_single_sample,
args=(sample, input_directory,
output_directory, imagej_instance,
parallelize - 1))
process.start()
processes.append(process)
for process in processes:
process.join()
else:
for sample in samples:
stitch_single_sample(sample, input_directory, output_directory,
imagej_instance, parallelize)
def analyze_connection(in_dir, out_dir, in_filename='0000.tif', verbose=False):
# unet = UNet(inifile='setting.ini')
# ds = dataset.Dataset()
os.makedirs(out_dir, exist_ok=True)
# for windows
fiji_path = os.getenv('FIJI_PATH',
r'C:\Users\tamaki\Downloads\fiji-win64\Fiji.app')
if not os.path.exists(fiji_path):
# for mac
fiji_path = '/Users/tamaki/Research/isu/work/Fiji.app'
ij = imagej.init(fiji_path) # taking long time in first time
if verbose:
print('fiji imagej version : {}'.format(ij.getVersion()))
ij.batchmode = True
#ij.ui().showUI()
# if not os.path.exists(unet.output_path):
# os.mkdir(unet.output_path)
from imagej_reader import Process3DOC
sample_path = os.path.join(in_dir, in_filename)
savedir = out_dir
savename = 'aaa'
Process3DOC(ij, sample_path, savedir, savename)
if verbose:
print('completed')
def __init__(
self,
log_file='./utils/polus-imagej-util/full.log',
log_template='./utils/polus-imagej-util/classes/logtemplates/mainlog.txt'
):
"""A method to instantiate a class Populate object
Args:
log_file: A str representing the path to the log file.
log_template: A str representing the path to a txt file which is
used as the log header. This file should explain the format of
the final log file.
Raises:
None
"""
# Instantiate the imagej instance
self._ij = imagej.init(
'sc.fiji:fiji:2.1.1+net.imagej:imagej-legacy:0.37.4',
headless=True)
# Store the log output file and log template file path
self.log_file = log_file
self.log_template = log_template
# Create dictionary to store all plugins
self._plugins = {}
# Create logger for class member
self.__logger(self.log_file, self.log_template)
# Create imagej plug in by calling the parser member method
self._parser()
def ij(request):
ij_dir = request.config.getoption('--ij')
headless = bool(request.config.getoption('--headless'))
ij_wrapper = imagej.init(ij_dir)
return ij_wrapper
def ijstitch(chdf, infile):
#conda create -n imagej -c conda-forge openjdk=8 pyimagej
#conda install -c conda-forge maven
#conda install -c conda-forge pyjnius
#conda install -c conda-forge imglyb
import imagej
ij = imagej.init(os.path.expanduser('~/utils/Fiji.app/'),
new_instance=True)
#ij = imagej.init('sc.fiji:fiji',new_instance=True)
plugin = 'Grid/Collection stitching'
args = {
'type': '[Positions from file]',
'order': '[Defined by TileConfiguration]',
'directory': '[]',
'layout_file': infile,
'regression_threshold': '0.0001',
'fusion_method': '[Linear Blending]',
'max/avg_displacement_threshold': '0.20',
'absolute_displacement_threshold': '0.30',
'subpixel_accuracy': True,
#'downsample_tiles':True,'x':'.25', 'y':'.25','interpolation':'Bicubic average',"width":'512','height':'384','outputFile':infile+'.registered.txt',
'compute_overlap': True,
'use_virtual_input_images': True,
'computation_parameters': '[Save memory (but be slower)]',
'image_output': '[Fuse and display]'
}
#ij.py.run_plugin(plugin, args,ij1_style=False)
#ij.py.run_macro('run("Grid/Collection stitching", "type=[Positions from file] order=[Defined by TileConfiguration] directory=[] layout_file=/home/mt/tmp/HOECHST.stitchy fusion_method=Average regression_threshold=0 max/avg_displacement_threshold=2.50 absolute_displacement_threshold=3.50 compute_overlap subpixel_accuracy downsample_tiles use_virtual_input_images computation_parameters=[Save memory (but be slower)] image_output=[Fuse and display] x=.25 y=.25 width=512 height=384 interpolation=Bicubic average");\n')
#ij.py.run_script(language='js',script='importClass(Packages.ij.IJ);IJ.run("Grid/Collection stitching", "type=[Positions from file] order=[Defined by TileConfiguration] directory=[] layout_file=/home/mt/tmp/HOECHST.stitchy fusion_method=[Linear Blending] regression_threshold=.01 max/avg_displacement_threshold=.250 absolute_displacement_threshold=.35 compute_overlap subpixel_accuracy downsample_tiles use_virtual_input_images computation_parameters=[Save memory (but be slower)] image_output=[Fuse and display] x=.2 y=.2 width=410 height=307 interpolation=Bicubic average");')
ij.getContext().dispose()
def __init__(self, headless=False, version="2.1.0", plugins=[]) -> None:
# concatenade version plus plugins
build = [version] + plugins if len(plugins) > 0 else version
self._ij = imagej.init(build, headless=headless)
if not headless: self._ij.ui().showUI()
super().__init__()
def ij_instance(self, q_in: mp.Queue, q_out: mp.Queue):
"""
Function to be spawned in parallel with separate processes.
Initializes ImageJ and feed in macro code with file names from multiprocessing.Queue.
:param q_in: Input file names
:param q_out: Mainly to track progress
"""
# Use latest Fiji as default.
ij = imagej.init(
'sc.fiji:fiji') if self.ij_path is None else imagej.init(
self.ij_path.as_posix())
q_out.put('ready')
while q_in.qsize() > 0:
file = q_in.get()
ij.py.run_macro(self.build_macro(file))
q_out.put(file)
def create(self):
self.ij = imagej.init(self['fiji_directory'], headless=False)
import jnius
global GLVector, jArray, jFloat
jArray = jnius.autoclass("java.lang.reflect.Array")
jFloat = jnius.autoclass("java.lang.Float")
GLVector = jnius.autoclass('cleargl.GLVector')
self.ij.ui().showUI()
return self.run().getOutput('sciView')
def ij_fixture(request):
"""
Create an ImageJ instance to be used by the whole testing environment
:param request: Pytest variable passed in to fixtures
:return: pyimageJ instance
"""
ij_dir = request.config.getoption('--ij')
headless = request.config.getoption('--headless')
ij_wrapper = imagej.init(ij_dir, headless=headless)
return ij_wrapper
def main():
unet = UNet(inifile='setting.ini')
ds = dataset.Dataset()
fiji_path = os.path.join(unet.fiji_dir)
ij = imagej.init(fiji_path, headless=False)
print(ij.getVersion())
ij.batchmode = True
if not os.path.exists(unet.output_path):
os.mkdir(unet.output_path)
Process3DOC(ij, unet)
def ij_fixture(request):
"""
Create an ImageJ instance to be used by the whole testing environment
:param request: Pytest variable passed in to fixtures
"""
ij_dir = request.config.getoption("--ij")
legacy = request.config.getoption("--legacy")
headless = request.config.getoption("--headless")
mode = "headless" if headless else "interactive"
ij_wrapper = imagej.init(ij_dir, mode=mode, add_legacy=legacy)
yield ij_wrapper
ij_wrapper.dispose()
import argparse
import sys
import unittest
import imagej
if "--ij" in sys.argv:
parser = argparse.ArgumentParser()
parser.add_argument('--ij',
default='/Applications/Fiji.app',
help="set ij_dir")
args = parser.parse_args()
print("set ij_dir to " + args.ij)
ij_dir = args.ij
ij = imagej.init(ij_dir)
sys.argv = sys.argv[2:]
else:
ij_dir = None # Use newest release version, downloaded from Maven.
ij = imagej.init(ij_dir)
from jnius import autoclass
import numpy as np
class TestImageJ(unittest.TestCase):
def testFrangi(self):
input_array = np.array([[1000, 1000, 1000, 2000, 3000],
[5000, 8000, 13000, 21000, 34000]])
result = np.zeros(input_array.shape)
ij.op().filter().frangiVesselness(ij.py.to_java(result),
ij.py.to_java(input_array), [1, 1],
4)
import numpy as np
import multiprocessing
import shutil
import pandas as pd
from StyleFrame import StyleFrame, Styler
import sites_of_interest_parser as sip
import os
import imagej
# Using lower level ImageJ APIs to do the stitching. Avoiding calling ImageJ1 plugins allows to use a maven
# distribution of ImageJ and makes this parallelizable as no temporary files are written and read anymore.
# See here: https://github.com/imagej/pyimagej/issues/35
# https://forum.image.sc/t/using-imagej-functions-like-type-conversion-and-setting-pixel-size-via-pyimagej/25755/10
ij = imagej.init('sc.fiji:fiji:2.0.0-pre-10+ch.fmi:faim-ij2-visiview-processing:0.0.1')
class Stitcher:
""" Stitches Talos images based on csv files containing the necessary information
This class handles the stitching of Talos images based on a csv file like the one created by the MapsXmlParser.
It creates the necessary folders, calls MapsXmlParser for the parsing and saving of the necessary metadata and then
manages the stitching of all annotations. Current implementation of stitching is hard-coded to stitch_radius = 1,
the size of the Talos images and an overlap of 10% in its stitching parameters in the stitch_annotated_tiles
function
Args:
base_path (str): Path (as a string) to the directory containing the project_name folder.
project_name (str): Name of the directory containing the MAPSProject.xml file and the LayersData
folder of the MAPS project. Will be used as the location for the output folders. Must be in base_path folder
import os
os.environ[
'PYJNIUS_JAR'] = r'C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\share\pyjnius\pyjnius.jar'
os.environ[
'PATH'] = r'C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\jre\bin\server;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\install\Library\jre\bin\server;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\install\Library\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\jre\bin\server;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\mingw-w64\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\usr\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Scripts;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\Library\mingw-w64\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\Library\usr\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\Library\bin;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\Scripts;C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\bin;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\ProgramData\Oracle\Java\javapath;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Program Files\MATLAB\R2017a\runtime\win64;C:\Program Files\MATLAB\R2017a\bin;C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\110\Tools\Binn\;C:\Program Files (x86)\Microsoft SQL Server\120\Tools\Binn\;C:\Program Files\Microsoft SQL Server\120\Tools\Binn\;C:\Program Files\Microsoft SQL Server\120\DTS\Binn\;C:\Program Files (x86)\Windows Kits\8.1\Windows Performance Toolkit\;C:\apache-maven-3.3.9\bin;C:\ProgramData\chocolatey\bin;C:\Program Files (x86)\AMD\ATI.ACE\Core-Static;C:\Program Files (x86)\Aperio\Common;C:\Program Files\PuTTY\;C:\Program Files\Java\jdk1.8.0_91\bin\;C:\Program Files (x86)\Google\Chrome\Application;C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common;C:\ProgramData\Oracle\Java\javapath;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\MATLAB\R2016a\runtime\win64;C:\Program Files\MATLAB\R2016a\bin;C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\110\Tools\Binn\;C:\Program Files (x86)\Microsoft SQL Server\120\Tools\Binn\;C:\Program Files\Microsoft SQL Server\120\Tools\Binn\;C:\Program Files\Microsoft SQL Server\120\DTS\Binn\;C:\Program Files (x86)\Windows Kits\8.1\Windows Performance Toolkit\;C:\Users\mpinkert\AppData\Local\Programs\Git\cmd;C:\Users\mpinkert\AppData\Local\Microsoft\WindowsApps;C:\Users\mpinkert\AppData\Local\Programs\MiKTeX 2.9\miktex\bin\x64'
os.environ['JAVA_HOME'] = r'C:\Program Files\Java\jdk1.8.0_91'
os.environ[
'JDK_HOME'] = r'C:\Users\mpinkert\AppData\Local\Continuum\anaconda3\envs\pyimagej\Library'
import imagej
ij = imagej.init(r'C:\Users\mpinkert\Desktop\Fiji.app')
from jnius import autoclass, JavaException, cast
macro = r"""
run("Grid/Collection stitching", "type=[Grid: row-by-row] order=[Right & Down ]""" +\
r""" grid_size_x=3 grid_size_y=1 tile_overlap=27 first_file_index_i=0""" +\
r""" directory=F:\\Research\\LINK\\US\\2018-08-17\\ file_names=FirstImage3D_Overlap-27_{i}.tif""" +\
r""" output_textfile_name=TileConfiguration.txt fusion_method=[Linear Blending]""" +\
r""" regression_threshold=0.30 max/avg_displacement_threshold=2.50 absolute_displacement_threshold=3.50""" +\
r""" computation_parameters=[Save memory (but be slower)] image_output=[Write to disk] """ + \
r"""output_directory=[F:\\Research\\LINK\\US\\2018-08-17\\grid output]");
"""
try:
test = ij.script().run('macro.ijm', macro, True).get()
except JavaException as e:
print("e.classname -- {}".format(e.classname))
print("e.innermessage -- {}".format(e.innermessage))
for st in e.stacktrace:
print(st)
return ij.ResultsTable.getResultsTable()
return None
def get_dataframe(table):
"""
Convert results table to pandas Dataframe.
"""
Table = sj.jimport('org.scijava.table.Table')
sci_table = ij.convert().convert(table, Table)
return ij.py.from_java(sci_table)
if __name__ == "__main__":
# initialize imagej
ij = imagej.init(mode='interactive')
print(f"ImageJ version: {ij.getVersion()}")
# load sample data and run blob detection
img = ij.io().open('../sample-data/test_image.tif')
img_xr = ij.py.from_java(img)
detected_blobs = find_blobs(img_xr,
min_sigma=0.5,
max_sigma=3,
num_sigma=10,
threshold=0.0075)
results_table = process(img, detected_blobs)
df = get_dataframe(results_table)
print(f"Output: \n{df}")
def run(imagej_dir,
segmentation_results_dir,
ground_truth_binary_masks_dir,
windows=False):
ij = imagej.init(imagej_dir)
path = Path(segmentation_results_dir)
if (windows):
base_directory = (str(path.parent))
else:
base_directory = '/' + (str(path.parent))
Temp_dir = base_directory + '/Temp'
if os.path.exists(Temp_dir):
shutil.rmtree(Temp_dir)
os.mkdir(Temp_dir)
for root, dirs, files in os.walk(segmentation_results_dir, topdown=True):
if (len(dirs) > 0):
childdirs = dirs
parentdir = [ground_truth_binary_masks_dir, segmentation_results_dir]
childdirs_imgs = []
print("iterating the segmentation results directories ...")
for item in tqdm(childdirs):
Test_directory = parentdir[
1] + "/" + item + "/*.png" # Specify labels directory
files = glob.glob(Test_directory)
X_data = []
for myFile in files:
image = io.imread(myFile)
X_data.append(image)
tmp = np.asarray(X_data, dtype='float32')
if (np.max(tmp) > 1): tmp = tmp / 255.0
childdirs_imgs.append(tmp)
tmp = np.vstack((tmp, tmp))
imsave(Temp_dir + '/' + item + '.tif', tmp)
Ground_data = np.asarray(list(imread_collection(parentdir[0] + "/*.png")),
dtype='float32')
Ground_dataTmp = np.vstack((Ground_data, Ground_data))
zipdata = zip(childdirs, childdirs_imgs)
mydict = dict(zipdata)
if (np.max(Ground_data) > 1): Ground_data = Ground_data / 255.0
if (np.max(Ground_dataTmp) > 1): Ground_dataTmp = Ground_dataTmp / 255.0
imsave(Temp_dir + '/Ground.tif', Ground_dataTmp)
Language_extension = "BeanShell"
macroVRand = """
import trainableSegmentation.metrics.*;
#@output String VRand
metric = new RandError( originalLabels, proposedLabels );
maxThres = 1.0;
maxScore = metric.getMaximalVRandAfterThinning( 0.0, maxThres, 0.1, true );
VRand = maxScore;
"""
macroVInfo = """
import trainableSegmentation.metrics.*;
#@output String VInfo
metric = new VariationOfInformation( originalLabels, proposedLabels );
maxThres =1.0;
maxScore = metric.getMaximalVInfoAfterThinning( 0.0, maxThres, 0.1 );
VInfo = maxScore;
"""
current_path = Temp_dir
if (windows):
current_path = current_path.replace("\\", "/")
VRandDf = []
VInfoDf = []
print("Retrieving Rand/Info metrics for the networks ...")
for item in tqdm(childdirs):
macroVRandTmp = (
'\nimport ij.IJ;\noriginalLabels=IJ.openImage("' + current_path +
'/' + 'Ground' + '.tif");' + '\nproposedLabels=IJ.openImage("' +
current_path + '/' + item + '.tif");' +
'\nimport trainableSegmentation.metrics.*;' +
'\n#@output String VRand' +
'\nmetric = new RandError( originalLabels, proposedLabels );' +
'\nmaxThres = 1.0;' +
'\nmaxScore = metric.getMaximalVRandAfterThinning( 0.0, maxThres, 0.1, true );'
+ '\nVRand = maxScore;')
VRand = float(
ij.py.run_script(Language_extension,
macroVRandTmp).getOutput('VRand'))
VRandDf.append(VRand)
macroVInfoTmp = (
'\nimport ij.IJ;\noriginalLabels=IJ.openImage("' + current_path +
'/' + 'Ground' + '.tif");' + '\nproposedLabels=IJ.openImage("' +
current_path + '/' + item + '.tif");' +
'\nimport trainableSegmentation.metrics.*;' +
'\n#@output String VInfo' +
'\nmetric = new VariationOfInformation( originalLabels, proposedLabels );'
+ '\nmaxThres = 1.0;' +
'\nmaxScore = metric.getMaximalVInfoAfterThinning( 0.0, maxThres, 0.1 );'
+ '\nVInfo = maxScore;')
VInfo = float(
ij.py.run_script(Language_extension,
macroVInfoTmp).getOutput('VInfo'))
VInfoDf.append(VInfo)
print("Retrieving standard metrics for the segmentation results ...")
Ground = Ground_data.flatten()
Ground = (Ground > 0.5).astype(np.int_)
F1score = []
accuracy = []
sensitivity = []
specificity = []
PPV = []
NPV = []
Jaccard = []
for item in tqdm(mydict):
itemTmp = mydict[item]
itemTmp = (itemTmp > 0.5).astype(np.int_)
itemTmp = itemTmp.flatten()
tn, fp, fn, tp = confusion_matrix(Ground, itemTmp).ravel()
accuracy.append((tp + tn) / (tp + tn + fp + fn))
sn = tp / (tp + fn)
sensitivity.append(sn)
specificity.append(tn / (tn + fp))
pr = tp / (tp + fp)
PPV.append(pr)
NPV.append(tn / (tn + fn))
Jaccard.append(jaccard_score(Ground, itemTmp))
F1score.append(2 * (pr * sn) / (pr + sn))
MyDataFrameDict = {
'Network': childdirs,
'F1-score': F1score,
'VRand': VRandDf,
'VInfo': VInfoDf,
'accuracy': accuracy,
'sensitivity': sensitivity,
'specificity': specificity,
'PPV': PPV,
'NPV': NPV,
'Jaccard': Jaccard
}
df = pd.DataFrame(MyDataFrameDict,
index=childdirs,
columns=[
'F1-score', 'VRand', 'VInfo', 'accuracy',
'sensitivity', 'specificity', 'PPV', 'NPV', 'Jaccard'
])
df = df.round(decimals=5)
cm = sns.diverging_palette(20, 130, n=len(childdirs), l=70, as_cmap=True)
styles = [
dict(props=[("font-family", "Times New Roman"), ("text-align",
"center")])
]
pd.set_option('precision', 5)
df.sort_index(axis=0, inplace=True)
html = (df.style.set_table_styles(styles).background_gradient(cmap=cm))
f = open("Dataframe_output.html", "w")
f.write(html.render())
f.close()
# html.to_csv('results.csv')
plt.figure(figsize=(6, 6), dpi=300)
sns.set(font_scale=0.8, font="sans-serif")
csfont = {'fontname': 'sans-serif'}
heat_map = sns.heatmap(df, cmap="Spectral")
plt.suptitle(
"Heatmap of the segmentation methods relative to different metrics",
fontsize=10,
y=1)
plt.xlabel("Metrics", fontsize=8, **csfont)
plt.ylabel("Methods", fontsize=8, **csfont)
plt.autoscale()
plt.savefig('Heatmap_output.png', dpi=300)
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
import multiscale.ultrasound.reconstruction as recon
import imagej
from pathlib import Path
ij = imagej.init('C:/users/mpinkert/Fiji.app/')
# stitch_dir = r'F:\Research\LINK' #
stitch_dir = r'C:\Users\mpinkert\Box\Research\LINK'
study_dir = 'Mouse images'
date = r'2019-10-21 - Mouse 210'
base_dir_list = ['L22 Fiducial Z16696']
#pl_path = Path(r'C:\Users\mpinkert\Box\Research\LINK\Phantom Trials\2019-05-04', '2019-05-04_US - 3X 100YSep.pos')
pl_path_base = Path(stitch_dir, study_dir, date)
runs = ['1']
for base_dir in base_dir_list:
for run in runs:
# pl_path = pl_path_base
pl_path = Path(pl_path_base, base_dir + '.pos')
def start_imagej_process(input_queue, output_queue, init_string):
"""Python script to run when starting a new ImageJ process.
All commands are initiated by adding a dictionary with a {pyimagej_key_command} entry to the {input_queue}. This
indicating which supported command should be executed. Some commands may take additional input, which is specified
in the dictionary with {pyimagej_key_input}.
Outputs are returned by adding a dictionary to the {output_queue} with the {pyimagej_key_output} key, or
{pyimagej_key_error} if an error occurred during script execution.
Supported commands
----------
{pyimagej_cmd_script_parse} : parse the parameters from an imagej script.
inputs: script filename
outputs: dictionary with mappings
{pyimagej_script_parse_inputs} -> dictionary of input field name/value pairs
{pyimagej_script_parse_outputs} -> dictionary of output field name/value pairs
{pyimagej_cmd_script_run} : takes a set of named inputs from CellProfiler and runs the given imagej script
inputs: dictionary with mappings
{pyimagej_script_run_file_key} -> script filename
{pyimagej_script_run_input_key} -> input parameter name/value dictionary
outputs: dictionary containing output field name/value pairs
{pyimagej_cmd_exit} : shut down the pyimagej daemon.
inputs: none
outputs: none
Return values
----------
{pyimagej_status_cmd_unknown} : unrecognized command, no further output is coming
Parameters
----------
input_queue : multiprocessing.Queue, required
This Queue will be polled for input commands to run through ImageJ
output_queue : multiprocessing.Queue, required
This Queue will be filled with outputs to return to CellProfiler
init_string : str, optional
This can be a path to a local ImageJ installation, or an initialization string per imagej.init(),
e.g. sc.fiji:fiji:2.1.0
"""
ij = False
try:
if init_string:
# Attempt to initialize with the given string
ij = imagej.init(init_string)
else:
ij = imagej.init()
except jpype.JException as ex:
# Initialization failed
output_queue.put(PYIMAGEJ_STATUS_STARTUP_FAILED)
jpype.shutdownJVM()
return
script_service = ij.script()
# Signify output is complete
output_queue.put(PYIMAGEJ_STATUS_STARTUP_COMPLETE)
# Main daemon loop, polling the input queue
while True:
command_dictionary = input_queue.get()
cmd = command_dictionary[PYIMAGEJ_KEY_COMMAND]
if cmd == PYIMAGEJ_CMD_SCRIPT_PARSE:
script_path = command_dictionary[PYIMAGEJ_KEY_INPUT]
script_file = Path(script_path)
script_info = script_service.getScript(script_file)
script_inputs = {}
script_outputs = {}
for script_in in script_info.inputs():
script_inputs[str(script_in.getName())] = str(script_in.getType().toString())
for script_out in script_info.outputs():
script_outputs[str(script_out.getName())] = str(script_out.getType().toString())
output_queue.put({PYIMAGEJ_SCRIPT_PARSE_INPUTS: script_inputs,
PYIMAGEJ_SCRIPT_PARSE_OUTPUTS: script_outputs})
elif cmd == PYIMAGEJ_CMD_SCRIPT_RUN:
script_path = (command_dictionary[PYIMAGEJ_KEY_INPUT])[PYIMAGEJ_SCRIPT_RUN_FILE_KEY]
script_file = Path(script_path)
input_map = (command_dictionary[PYIMAGEJ_KEY_INPUT])[PYIMAGEJ_SCRIPT_RUN_INPUT_KEY]
convert_types = (command_dictionary[PYIMAGEJ_KEY_INPUT])[PYIMAGEJ_SCRIPT_RUN_CONVERT_IMAGES]
preprocess_script_inputs(ij, input_map, convert_types)
script_out_map = script_service.run(script_file, True, input_map).get().getOutputs()
output_dict = {}
for entry in script_out_map.entrySet():
key = str(entry.getKey())
value = convert_java_to_python_type(ij, entry.getValue())
if value is not None:
output_dict[key] = value
output_queue.put({PYIMAGEJ_KEY_OUTPUT: output_dict})
elif cmd == PYIMAGEJ_CMD_EXIT:
break
else:
output_queue.put({PYIMAGEJ_KEY_ERROR: PYIMAGEJ_STATUS_CMD_UNKNOWN})
# Shut down the daemon
ij.getContext().dispose()
jpype.shutdownJVM()
#import imglyb
#import numpy as np
#from skimage import data, io, filters
import imagej
ij = imagej.init('sc.fiji:fiji')
#ij=imagej.init()
print(f'this is fijis version: ij.getVersion()')
# Import an image with scikit-image.
# NB: Blood vessel image from: https://www.fi.edu/heart/blood-vessels
img = io.imread(
'https://www.fi.edu/sites/fi.live.franklinds.webair.com/files/styles/featured_large/public/General_EduRes_Heart_BloodVessels_0.jpg'
)
img = np.mean(img, axis=2)
# Invoke ImageJ's Frangi vesselness op.
vessels = np.zeros(img.shape, dtype=img.dtype)
ij.op().filter().frangiVesselness(ij.py.to_java(vessels), ij.py.to_java(img),
[1, 1], 20)
# macro='Run_QA_Portland2019'
# language_extension = 'ijm'
# result_script = ij.py.run_script(language_extension, macro)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 17 17:33:59 2020
@author: bene
"""
import numpy as np
import imagej
import imagej
ij = imagej.init('/Applications/Fiji.app')
#ij = imagej.init('sc.fiji:fiji:2.0.0-pre-10')
ij.getVersion()
#%%
macro = """
open("/Users/bene/Dropbox/Dokumente/Promotion/PROJECTS/STORMoChip/2020_01_13-EColi_TetraSpecs100_P20_Video_RAW_Fluct/E.Coli_2_my_raw_result-1.tif - drift corrected.tif");
run("Slice Keeper", "first=1 last=100 increment=1");
run("Estimate Drift", "time=1 max=50 reference=[first frame (default, better for fixed)] show_drift_plot choose=/Users/bene/Downloads/test.njt");
close();
close();
close();
run("Correct Drift", "choose=/Users/bene/Downloads/testDriftTable.njt");
run("SRRF Analysis", "ring=1 radiality_magnification=5 axes=6 frames_per_time-point=0 start=0 end=0 max=100 preferred=0");
saveAs("Tiff", "/Users/bene/Downloads/result.tif");
"""
result = ij.py.run_macro(macro)
import jpype
import numpy as np
from bfio import BioReader, BioWriter
from pathlib import Path
# Bioformats throws a debug message, disable the loci debugger to mute it
def disable_loci_logs():
DebugTools = scyjava.jimport("loci.common.DebugTools")
DebugTools.setRootLevel("WARN")
scyjava.when_jvm_starts(disable_loci_logs)
print("Starting JVM...")
# This is the version of ImageJ pre-downloaded into the docker container
ij = imagej.init("sc.fiji:fiji:2.1.1+net.imagej:imagej-legacy:0.37.4",
headless=True)
# ArrayImgs = scyjava.jimport('net.imglib2.img.array.ArrayImgs')
# UnsafeUtil = scyjava.jimport('net.imglib2.img.basictypelongaccess.unsafe.UnsafeUtil')
# Arrays = scyjava.jimport('java.util.Arrays')
# OwningFloatUnsafe = scyjava.jimport('net.imglib2.img.basictypelongaccess.unsafe.owning.OwningFloatUnsafe')
# Fraction = scyjava.jimport('net.imglib2.util.Fraction')
# LongStream = scyjava.jimport('java.util.stream.LongStream')
NUMPY_TYPES = {
"uint8": (np.uint8, imglyb.types.UnsignedByteType),
"byte": (np.int8, imglyb.types.ByteType),
"uint16": (np.uint16, imglyb.types.UnsignedShortType),
"short": (np.int16, imglyb.types.ShortType),
"uint32": (np.uint32, imglyb.types.UnsignedIntType),
"int": (np.int32, imglyb.types.IntType),
def demo(args):
available_cuda = torch.cuda.is_available()
if not available_cuda:
print('gpu not avaibable')
if args.use_cuda and available_cuda:
device = 'cuda:' + str(args.which_gpu)
torch.cuda.set_device(args.which_gpu)
print('use GPU')
else:
device = 'cpu'
model = md.GeneratorUNet(3, 1)
DICT_DIR = args.weights
state_dict = torch.load(DICT_DIR, map_location=torch.device(device))
if args.load_multiple_gpu_weights:
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:]
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
else:
model.load_state_dict(state_dict)
model.eval()
model.to(device)
print('loading ImageJ, please wait')
ij = imagej.init('fiji/Fiji.app/')
# use for SHG
TASK = args.input_folder
INPUT_DIR = 'input_test_' + TASK
INPUT_PATCH_DIR = 'input_patch_temp/'
OUTPUT_DIR = 'output_test_' + TASK
OUTPUT_PATCH_DIR = 'output_patch_temp/'
CHANNEL_DIR = 'channel_temp/'
if os.path.exists(CHANNEL_DIR): shutil.rmtree(CHANNEL_DIR)
os.mkdir(CHANNEL_DIR)
if os.path.exists(OUTPUT_DIR): shutil.rmtree(OUTPUT_DIR)
os.mkdir(OUTPUT_DIR)
files = [f for f in os.listdir(INPUT_DIR)]
files.sort()
window_shape = (128, 128, 3)
step_size = 96
is_crf = False
for k, fn in enumerate(files):
print('forward pass, please wait...')
if os.path.exists(INPUT_PATCH_DIR): shutil.rmtree(INPUT_PATCH_DIR)
if os.path.exists(OUTPUT_PATCH_DIR): shutil.rmtree(OUTPUT_PATCH_DIR)
os.mkdir(INPUT_PATCH_DIR)
os.mkdir(OUTPUT_PATCH_DIR)
fs = os.path.join(INPUT_DIR, fn)
img = io.imread(fs)
shape_0_factor = np.ceil(img.shape[0] / window_shape[0]) # height
shape_1_factor = np.ceil(img.shape[1] / window_shape[1]) # width
canvas_0 = int(window_shape[0] * shape_0_factor)
canvas_1 = int(window_shape[1] * shape_1_factor)
pad_0 = canvas_0 - img.shape[0]
pad_1 = canvas_1 - img.shape[1]
canvas = pad(img, ((0, pad_0), (0, pad_1), (0, 0)), mode='reflect')
windows = view_as_windows(canvas, window_shape, step_size)
with open(OUTPUT_PATCH_DIR + 'TileConfiguration.txt',
'w') as text_file:
print('dim = {}'.format(2), file=text_file)
for i in range(0, windows.shape[1]):
for j in range(0, windows.shape[0]):
patch = windows[j, i, ]
patch = np.squeeze(patch)
io.imsave(INPUT_PATCH_DIR + '/{}_{}.tiff'.format(j, i),
patch)
print('{}_{}.tiff; ; ({}, {})'.format(
j, i, i * step_size, j * step_size),
file=text_file)
csv_file_path = generate_csv(INPUT_PATCH_DIR, os.getcwd())
dataset = SynthDataset(csv_file=csv_file_path)
dataloader = DataLoader(dataset,
batch_size=1,
shuffle=False,
num_workers=1)
with open(csv_file_path) as f:
reader = csv.reader(f)
name_list = list(reader)
with torch.no_grad():
for iteration, batch in enumerate(dataloader):
input = batch['image'].float().to(device).view(
1, 3, window_shape[0], window_shape[1])
prediction = model(input)
for i in range(prediction.size(0)):
img_name = str(
name_list[iteration]).split('/')[-1].split('\'')[0]
result_patch = prediction[
i, :, :, :, ].cpu().detach().numpy().transpose(
(1, 2, 0)) * 255
result_patch = result_patch.astype(np.uint8)
io.imsave(OUTPUT_PATCH_DIR + img_name, result_patch)
print('stitching, please wait...')
os.makedirs(CHANNEL_DIR, exist_ok=True)
params = {
'type': 'Positions from file',
'order': 'Defined by TileConfiguration',
'directory': OUTPUT_PATCH_DIR,
'ayout_file': 'TileConfiguration.txt',
'fusion_method': 'Linear Blending',
'regression_threshold': '0.30',
'max/avg_displacement_threshold': '2.50',
'absolute_displacement_threshold': '3.50',
'compute_overlap': False,
'computation_parameters':
'Save computation time (but use more RAM)',
'image_output': 'Write to disk',
'output_directory': CHANNEL_DIR
}
plugin = "Grid/Collection stitching"
ij.py.run_plugin(plugin, params)
output_name = os.path.join(OUTPUT_DIR, fn)
listOfChannels = [f for f in os.listdir(CHANNEL_DIR)]
c1 = io.imread(os.path.join(CHANNEL_DIR, listOfChannels[0]))
c1 = c1[:img.shape[0], :img.shape[1]]
c1 = img_as_ubyte(c1)
c1 = exposure.rescale_intensity(c1,
in_range=args.intensity,
out_range=(0, 255))
c1 = exposure.rescale_intensity(c1,
in_range=(0, 255),
out_range=(0, 1))
print(
str(k + 1) + "/" + str(len(files)) + " output saved as: " +
output_name)
io.imsave(output_name, img_as_ubyte(c1))
if args.pilot:
break
def main(
_opName: str,
_in1: Path,
_sigma: str,
_calibration: str,
_out: Path,
) -> None:
"""Initialize ImageJ"""
# Bioformats throws a debug message, disable the loci debugger to mute it
def disable_loci_logs():
DebugTools = scyjava.jimport("loci.common.DebugTools")
DebugTools.setRootLevel("WARN")
scyjava.when_jvm_starts(disable_loci_logs)
# This is the version of ImageJ pre-downloaded into the docker container
logger.info("Starting ImageJ...")
ij = imagej.init("sc.fiji:fiji:2.1.1+net.imagej:imagej-legacy:0.37.4",
headless=True)
# ij_converter.ij = ij
logger.info("Loaded ImageJ version: {}".format(ij.getVersion()))
""" Validate and organize the inputs """
args = []
argument_types = []
arg_len = 0
# Validate opName
opName_values = [
"DefaultTubeness",
]
assert _opName in opName_values, "opName must be one of {}".format(
opName_values)
# Validate in1
in1_types = {
"DefaultTubeness": "RandomAccessibleInterval",
}
# Check that all inputs are specified
if _in1 is None and _opName in list(in1_types.keys()):
raise ValueError("{} must be defined to run {}.".format(
"in1", _opName))
elif _in1 != None:
in1_type = in1_types[_opName]
# switch to images folder if present
if _in1.joinpath("images").is_dir():
_in1 = _in1.joinpath("images").absolute()
args.append([f for f in _in1.iterdir() if f.is_file()])
arg_len = len(args[-1])
else:
argument_types.append(None)
args.append([None])
# Validate sigma
sigma_types = {
"DefaultTubeness": "double",
}
# Check that all inputs are specified
if _sigma is None and _opName in list(sigma_types.keys()):
raise ValueError("{} must be defined to run {}.".format(
"sigma", _opName))
else:
sigma = None
# Validate calibration
calibration_types = {
"DefaultTubeness": "double[]",
}
# Check that all inputs are specified
if _calibration is None and _opName in list(calibration_types.keys()):
raise ValueError("{} must be defined to run {}.".format(
"calibration", _opName))
else:
calibration = None
for i in range(len(args)):
if len(args[i]) == 1:
args[i] = args[i] * arg_len
""" Set up the output """
out_types = {
"DefaultTubeness": "IterableInterval",
}
""" Run the plugin """
try:
for ind, (in1_path, ) in enumerate(zip(*args)):
if in1_path != None:
# Load the first plane of image in in1 collection
logger.info("Processing image: {}".format(in1_path))
in1_br = BioReader(in1_path)
# Convert to appropriate numpy array
in1 = ij_converter.to_java(ij,
np.squeeze(in1_br[:, :, 0:1, 0, 0]),
in1_type)
metadata = in1_br.metadata
fname = in1_path.name
dtype = ij.py.dtype(in1)
if _sigma is not None:
sigma = ij_converter.to_java(ij, _sigma, sigma_types[_opName],
dtype)
if _calibration is not None:
calibration = ij_converter.to_java(ij, _calibration,
calibration_types[_opName],
dtype)
logger.info("Running op...")
if _opName == "DefaultTubeness":
out = ij.op().filter().tubeness(in1, sigma, calibration)
logger.info("Completed op!")
if in1_path != None:
in1_br.close()
# Saving output file to out
logger.info("Saving...")
out_array = ij_converter.from_java(ij, out, out_types[_opName])
bw = BioWriter(_out.joinpath(fname), metadata=metadata)
bw.Z = 1
bw.dtype = out_array.dtype
bw[:] = out_array.astype(bw.dtype)
bw.close()
except:
logger.error("There was an error, shutting down jvm before raising...")
raise
finally:
# Exit the program
logger.info("Shutting down jvm...")
del ij
jpype.shutdownJVM()
logger.info("Complete!")
def start_fiji():
ij = imagej.init('/srv/conda/vnc/Fiji.app', headless=False)
ij.getVersion()
return ij
import napari, sys
if len(sys.argv) <= 1:
print('Please specify one or more images as arguments.')
exit(1)
try:
import imagej
except ImportError:
raise ImportError("""This example uses ImageJ but pyimagej is not
installed. To install try 'conda install pyimagej'.""")
with napari.gui_qt():
print('--> Initializing imagej')
ij = imagej.init('sc.fiji:fiji') # Fiji includes Bio-Formats.
for i in range(1, len(sys.argv)):
path = sys.argv[i]
print('--> Reading {}'.format(path))
dataset = ij.io().open(path)
image = ij.py.from_java(dataset)
if i == 1:
viewer = napari.view_image(image)
else:
viewer.add_image(image)
ij.getContext().dispose()
# demo.py # # This example script show how to process image in the GPU via # python, numpy, pyimagej and clij. # # Author: Robert Haase, [email protected] # August 2019 #######################################################3333 # init pyimage to get access to jar files import imagej ij = imagej.init('C:/programs/fiji-win64/Fiji.app/') # load some image data from skimage import io sk_img = io.imread('https://samples.fiji.sc/blobs.png') # init clijpy to get access to the GPU from jnius import autoclass CLIJx = autoclass('net.haesleinhuepf.clijx.CLIJx') clijx = CLIJx.getInstance() # convert and array to an ImageJ2 img: import numpy as np np_arr = np.array(sk_img) ij_img = ij.py.to_java(np_arr) # push the image to the GPU input = clijx.push(ij_img) # allocate memory for the result image output = clijx.create(input)
parser.add_argument('--cols', help='Number of columns')
parser.add_argument('--rows', help='Number of rows')
parser.add_argument('--fijipath', help='Path to Fiji.app')
parser.add_argument('--grid-type',
help='Stitching pattern',
default='snake-by-rows')
parser.add_argument('--overlap',
help='Percent overlap in tiles',
type=int,
default=10)
args, _ = parser.parse_known_args()
grid = ' '.join(args.grid_type.split('-'))
round_directories = glob.glob(args.source_paths)
# ImageJ/Fiji setup
ij = imagej.init(args.fijipath)
IJM_EXTENSION = ".ijm"
STITCHING_MACRO = """
#@ String sourceDirectory
#@ String outputDirectory
#@ int overlap
#@ String grid
#@ int cols
#@ int rows
print(outputDirectory);
function action(sourceDirectory, outputDirectory, genericFilename, filename, coordinateFilename) {
run("Grid/Collection stitching", "type=[Grid: " + grid + "] order=[Right & Down ] grid_size_x=" + cols + " grid_size_y=" + rows + " tile_overlap=" + overlap + " first_file_index_i=0 directory=" + sourceDirectory + " file_names=" + genericFilename + " output_textfile_name=" + coordinateFilename + " fusion_method=[Linear Blending] regression_threshold=0.30 max/avg_displacement_threshold=2.50 absolute_displacement_threshold=3.50 subpixel_accuracy compute_overlap computation_parameters=[Save computation time (but use more RAM)] image_output=[Fuse and display]");
saveAs("png", outputDirectory + filename);
close();
}
def main(argv):
# parse directory name from command line argument
# parse command line arguments
parser = argparse.ArgumentParser(description="Process raw OPM data.")
parser.add_argument("-i",
"--ipath",
type=str,
help="supply the directory to be processed")
parser.add_argument("-d",
"--decon",
type=int,
default=0,
help="0: no deconvolution (DEFAULT), 1: deconvolution")
parser.add_argument(
"-f",
"--flatfield",
type=int,
default=0,
help=
"0: No flat field (DEFAULT), 1: flat field (FIJI) 2: flat field (python)"
)
parser.add_argument(
"-s",
"--save_type",
type=int,
default=1,
help="0: TIFF stack output, 1: BDV output (DEFAULT), 2: Zarr output")
parser.add_argument(
"-z",
"--z_down_sample",
type=int,
default=1,
help="1: No downsampling (DEFAULT), n: Nx downsampling")
args = parser.parse_args()
input_dir_string = args.ipath
decon_flag = args.decon
flatfield_flag = args.flatfield
save_type = args.save_type
z_down_sample = args.z_down_sample
# https://docs.python.org/3/library/pathlib.html
# Create Path object to directory
input_dir_path = Path(input_dir_string)
# create parameter array from scan parameters saved by acquisition code
df_metadata = data_io.read_metadata(input_dir_path /
Path('scan_metadata.csv'))
root_name = df_metadata['root_name']
scan_type = df_metadata['scan_type']
theta = df_metadata['theta']
scan_step = df_metadata['scan_step']
pixel_size = df_metadata['pixel_size']
num_t = df_metadata['num_t']
num_y = df_metadata['num_y']
num_z = df_metadata['num_z']
num_ch = df_metadata['num_ch']
num_images = df_metadata['scan_axis_positions']
y_pixels = df_metadata['y_pixels']
x_pixels = df_metadata['x_pixels']
chan_405_active = df_metadata['405_active']
chan_488_active = df_metadata['488_active']
chan_561_active = df_metadata['561_active']
chan_635_active = df_metadata['635_active']
chan_730_active = df_metadata['730_active']
active_channels = [
chan_405_active, chan_488_active, chan_561_active, chan_635_active,
chan_730_active
]
channel_idxs = [0, 1, 2, 3, 4]
channels_in_data = list(compress(channel_idxs, active_channels))
n_active_channels = len(channels_in_data)
if not (num_ch == n_active_channels):
print('Channel setup error. Check metatdata file and directory names.')
sys.exit()
# calculate pixel sizes of deskewed image in microns
deskewed_x_pixel = pixel_size / 1000.
deskewed_y_pixel = pixel_size / 1000.
deskewed_z_pixel = pixel_size / 1000.
print('Deskewed pixel sizes before downsampling (um). x=' +
str(deskewed_x_pixel) + ', y=' + str(deskewed_y_pixel) + ', z=' +
str(deskewed_z_pixel) + '.')
# create output directory
if decon_flag == 0 and flatfield_flag == 0:
output_dir_path = input_dir_path / 'deskew_output'
elif decon_flag == 0 and flatfield_flag > 0:
output_dir_path = input_dir_path / 'deskew_flatfield_output'
elif decon_flag == 1 and flatfield_flag == 0:
output_dir_path = input_dir_path / 'deskew_decon_output'
elif decon_flag == 1 and flatfield_flag > 1:
output_dir_path = input_dir_path / 'deskew_flatfield_decon_output'
output_dir_path.mkdir(parents=True, exist_ok=True)
# Create TIFF if requested
if (save_type == 0):
# create directory for data type
tiff_output_dir_path = output_dir_path / Path('tiff')
tiff_output_dir_path.mkdir(parents=True, exist_ok=True)
# Create BDV if requested
elif (save_type == 1):
# create directory for data type
bdv_output_dir_path = output_dir_path / Path('bdv')
bdv_output_dir_path.mkdir(parents=True, exist_ok=True)
# https://github.com/nvladimus/npy2bdv
# create BDV H5 file with sub-sampling for BigStitcher
bdv_output_path = bdv_output_dir_path / Path(root_name + '_bdv.h5')
bdv_writer = npy2bdv.BdvWriter(str(bdv_output_path),
nchannels=num_ch,
ntiles=num_y * num_z,
subsamp=((1, 1, 1), (4, 8, 8), (8, 16,
16)),
blockdim=((32, 128, 128), ),
compression=None)
# create blank affine transformation to use for stage translation
unit_matrix = np.array((
(1.0, 0.0, 0.0, 0.0), # change the 4. value for x_translation (px)
(0.0, 1.0, 0.0, 0.0), # change the 4. value for y_translation (px)
(0.0, 0.0, 1.0,
0.0))) # change the 4. value for z_translation (px)
# Create Zarr if requested
elif (save_type == 2):
# create directory for data type
zarr_output_dir_path = output_dir_path / Path('zarr')
zarr_output_dir_path.mkdir(parents=True, exist_ok=True)
# create name for zarr directory
zarr_output_path = zarr_output_dir_path / Path(root_name +
'_zarr.zarr')
# calculate size of one volume
# change step size from physical space (nm) to camera space (pixels)
pixel_step = scan_step / pixel_size # (pixels)
# calculate the number of pixels scanned during stage scan
scan_end = num_images * pixel_step # (pixels)
# calculate properties for final image
ny = np.int64(
np.ceil(scan_end +
y_pixels * np.cos(theta * np.pi / 180))) # (pixels)
nz = np.int64(np.ceil(y_pixels *
np.sin(theta * np.pi / 180))) # (pixels)
nx = np.int64(x_pixels) # (pixels)
# create and open zarr file
root = zarr.open(str(zarr_output_path), mode="w")
opm_data = root.zeros("opm_data",
shape=(num_t, num_y * num_z, num_ch, nz, ny, nx),
chunks=(1, 1, 1, 32, 128, 128),
dtype=np.uint16)
root = zarr.open(str(zarr_output_path), mode="rw")
opm_data = root["opm_data"]
# if retrospective flatfield is requested, import and open pyimagej in interactive mode
# because BaSiC flat-fielding plugin cannot run in headless mode
if flatfield_flag == 1:
from image_post_processing import manage_flat_field
import imagej
import scyjava
scyjava.config.add_option('-Xmx12g')
plugins_dir = Path('/home/dps/Fiji.app/plugins')
scyjava.config.add_option(f'-Dplugins.dir={str(plugins_dir)}')
ij_path = Path('/home/dps/Fiji.app')
ij = imagej.init(str(ij_path), headless=False)
ij.ui().showUI()
print(
'PyimageJ approach to flat fielding will be removed soon. Switch to GPU accelerated python BASIC code (-f 2).'
)
elif flatfield_flag == 2:
from image_post_processing import manage_flat_field_py
# if decon is requested, import microvolution wrapper
if decon_flag == 1:
from image_post_processing import mv_decon
# initialize counters
timepoints_in_data = list(range(num_t))
y_tile_in_data = list(range(num_y))
z_tile_in_data = list(range(num_z))
ch_in_BDV = list(range(n_active_channels))
tile_idx = 0
# loop over all directories. Each directory will be placed as a "tile" into the BigStitcher file
for (y_idx, z_idx) in product(y_tile_in_data, z_tile_in_data):
for (t_idx, ch_BDV_idx) in product(timepoints_in_data, ch_in_BDV):
ch_idx = channels_in_data[ch_BDV_idx]
# open stage positions file
stage_position_filename = Path('t' + str(t_idx).zfill(4) + '_y' +
str(y_idx).zfill(4) + '_z' +
str(z_idx).zfill(4) + '_ch' +
str(ch_idx).zfill(4) +
'_stage_positions.csv')
stage_position_path = input_dir_path / stage_position_filename
# check to see if stage poisition file exists yet
while (not (stage_position_filename.exists())):
time.sleep(60)
df_stage_positions = data_io.read_metadata(stage_position_path)
stage_x = np.round(float(df_stage_positions['stage_x']), 2)
stage_y = np.round(float(df_stage_positions['stage_y']), 2)
stage_z = np.round(float(df_stage_positions['stage_z']), 2)
print('y tile ' + str(y_idx + 1) + ' of ' + str(num_y) +
'; z tile ' + str(z_idx + 1) + ' of ' + str(num_z) +
'; channel ' + str(ch_BDV_idx + 1) + ' of ' +
str(n_active_channels))
print('Stage location (um): x=' + str(stage_x) + ', y=' +
str(stage_y) + ', z=' + str(stage_z) + '.')
# construct directory name
current_tile_dir_path = Path(root_name + '_t' +
str(t_idx).zfill(4) + '_y' +
str(y_idx).zfill(4) + '_z' +
str(z_idx).zfill(4) + '_ch' +
str(ch_idx).zfill(4) + '_1')
tile_dir_path_to_load = input_dir_path / current_tile_dir_path
# https://pycro-manager.readthedocs.io/en/latest/read_data.html
dataset = Dataset(str(tile_dir_path_to_load))
raw_data = data_io.return_data_numpy(dataset=dataset,
time_axis=None,
channel_axis=None,
num_images=num_images,
y_pixels=y_pixels,
x_pixels=x_pixels)
# perform flat-fielding
if flatfield_flag == 1:
print('Flatfield.')
corrected_stack = manage_flat_field(raw_data, ij)
elif flatfield_flag == 2:
corrected_stack = manage_flat_field_py(raw_data)
else:
corrected_stack = raw_data
del raw_data
# deskew
print('Deskew.')
deskewed = deskew(data=np.flipud(corrected_stack),
theta=theta,
distance=scan_step,
pixel_size=pixel_size)
del corrected_stack
# downsample in z due to oversampling when going from OPM to coverslip geometry
if z_down_sample > 1:
print('Downsample.')
deskewed_downsample = block_reduce(deskewed,
block_size=(z_down_sample,
1, 1),
func=np.mean)
else:
deskewed_downsample = deskewed
del deskewed
# run deconvolution on deskewed image
if decon_flag == 1:
print('Deconvolve.')
deskewed_downsample_decon = mv_decon(
deskewed_downsample, ch_idx, deskewed_y_pixel,
z_down_sample * deskewed_z_pixel)
else:
deskewed_downsample_decon = deskewed_downsample
del deskewed_downsample
# save deskewed image into TIFF stack
if (save_type == 0):
print('Write TIFF stack')
tiff_filename = root_name + '_t' + str(t_idx).zfill(
3) + '_p' + str(tile_idx).zfill(4) + '_c' + str(
ch_idx).zfill(3) + '.tiff'
tiff_output_path = tiff_output_dir_path / Path(tiff_filename)
tifffile.imwrite(str(tiff_output_path),
deskewed_downsample_decon,
imagej=True,
resolution=(1 / deskewed_x_pixel,
1 / deskewed_y_pixel),
metadata={
'spacing':
(z_down_sample * deskewed_z_pixel),
'unit': 'um',
'axes': 'ZYX'
})
metadata_filename = root_name + '_t' + str(t_idx).zfill(
3) + '_p' + str(tile_idx).zfill(4) + '_c' + str(
ch_idx).zfill(3) + '.csv'
metadata_output_path = tiff_output_dir_path / Path(
metadata_filename)
tiff_stage_metadata = [{
'stage_x': float(stage_x),
'stage_y': float(stage_y),
'stage_z': float(stage_z)
}]
data_io.write_metadata(tiff_stage_metadata[0],
metadata_output_path)
elif (save_type == 1):
# create affine transformation for stage translation
# swap x & y from instrument to BDV
affine_matrix = unit_matrix
affine_matrix[0, 3] = (stage_y) / (deskewed_y_pixel
) # x-translation
affine_matrix[1, 3] = (stage_x) / (deskewed_x_pixel
) # y-translation
affine_matrix[2, 3] = (-1 * stage_z) / (
z_down_sample * deskewed_z_pixel) # z-translation
# save tile in BDV H5 with actual stage positions
print('Write into BDV H5.')
bdv_writer.append_view(
deskewed_downsample_decon,
time=0,
channel=ch_BDV_idx,
tile=tile_idx,
voxel_size_xyz=(deskewed_x_pixel, deskewed_y_pixel,
z_down_sample * deskewed_z_pixel),
voxel_units='um',
calibration=(1, 1, (z_down_sample * deskewed_z_pixel) /
deskewed_y_pixel),
m_affine=affine_matrix,
name_affine='tile ' + str(tile_idx) + ' translation')
elif (save_type == 2):
print('Write data into Zarr container')
opm_data[t_idx, tile_idx,
ch_BDV_idx, :, :, :] = deskewed_downsample_decon
metadata_filename = root_name + '_t' + str(t_idx).zfill(
3) + '_p' + str(tile_idx).zfill(4) + '_c' + str(
ch_idx).zfill(3) + '.csv'
metadata_output_path = zarr_output_dir_path / Path(
metadata_filename)
zarr_stage_metadata = [{
'stage_x': float(stage_x),
'stage_y': float(stage_y),
'stage_z': float(stage_z)
}]
data_io.write_metadata(zarr_stage_metadata[0],
metadata_output_path)
# free up memory
del deskewed_downsample_decon
gc.collect()
tile_idx = tile_idx + 1
if (save_type == 2):
# write BDV xml file
# https://github.com/nvladimus/npy2bdv
# bdv_writer.write_xml(ntimes=num_t)
bdv_writer.write_xml()
bdv_writer.close()
# shut down pyimagej
if (flatfield_flag == 1):
ij.getContext().dispose()
# exit
print('Finished.')
sys.exit()
# Create an ImageJ gateway with the newest available version of ImageJ.
import imagej
from skimage import io
import numpy as np
import matplotlib
# import cairocffi as cairo
# matplotlib.use('PS')
ij = imagej.init('/home2/kdean/Desktop/Applications/Fiji', headless=False)
print('ImageJ Version:' + str(ij.getVersion()))
# Load an image.
#image_url = 'https://samples.fiji.sc/new-lenna.jpg'
# jimage = ij.io().open('/archive/MIL/marciano/20210119_capillaryLooping/Control/fluospheres_sytox/210117/Cell1/max_pos1.jpg')
# print('Image Loaded')
# Convert the image from ImageJ to xarray, a package that adds
# labeled datasets to numpy (http://xarray.pydata.org/en/stable/).
# image = ij.py.from_java(jimage)
# Display the image (backed by matplotlib).
# ij.py.show(jimage, cmap='gray')
url = '/archive/MIL/marciano/20210119_capillaryLooping/Control/fluospheres_sytox/210117/Cell1/max_pos1.jpg'
img = io.imread(url)
# ij.py.show(img)
from matplotlib import pyplot as plt
plt.subplot(121)
plt.imshow(img)
