def parse_cl_arguments(self):
"""
The function assumes that the command line parser has been setup using the initialize_argument_parser(..)
This function parses all arguments that are specific to the command-line parser itself. Analysis
arguments are added and parsed later by the add_and_parse_analysis_arguments(...) function.
The reason for this is two-fold: i) to separate the parsing of analysis arguments and arguments of the
command-line driver and ii) if the same HDF5 file is used as input and output target, then we need to
open it first here in append mode before it gets opened in read mode later by the arguments.
*Side effects:* The function sets ``self.output_target`` and ``self.profile_analysis``
"""
# Parse the arguments and convert them to a dict using vars
parsed_arguments = vars(self.parser.parse_known_args()[0])
# Clean up the arguments to remove default arguments of the driver class
# before we hand the arguments to the analysis class
if self.analysis_class_arg_name in parsed_arguments:
parsed_arguments.pop(self.analysis_class_arg_name)
# Process the --save argument to determine where we should save the output
if self.output_save_arg_name in parsed_arguments and mpi_helper.get_rank() == self.mpi_root:
# Determine the filename and experiment group from the path
self.output_target = parsed_arguments.pop(self.output_save_arg_name)
if self.output_target is not None:
output_filename, output_object_path = omsi_file_common.parse_path_string(self.output_target)
# Create the output file
if output_filename is None:
raise ValueError("ERROR: Invalid save parameter specification " + self.output_target)
elif os.path.exists(output_filename) and not os.path.isfile(output_filename):
raise ValueError("ERROR: Save parameter not specify a file.")
if not os.path.exists(output_filename):
out_file = omsi_file(output_filename, mode='a')
self.output_target = out_file.create_experiment()
self. __output_target_self = output_filename
else:
out_file = omsi_file(output_filename, mode='r+')
if output_object_path is not None:
self.output_target = omsi_file_common.get_omsi_object(out_file[output_object_path])
else:
if out_file.get_num_experiments() > 0:
self.output_target = out_file.get_experiment(0)
else:
self.output_target = out_file.create_experiment()
else:
self.output_target = parsed_arguments.pop(self.output_save_arg_name)
# The --loglovel argument
if self.log_level_arg_name in parsed_arguments:
user_log_level = parsed_arguments.pop(self.log_level_arg_name)
if user_log_level in log_helper.log_levels.keys():
log_helper.set_log_level(level=log_helper.log_levels[user_log_level])
else:
log_helper.error(module_name=__name__, message="Invalid log level specified")
def test_warp_function_save_and_recreate(self):
def my_funct(a):
return np.sum(a)
g = analysis_generic.from_function(my_funct)
res1 = g.execute(a=np.arange(10))
f = omsi_file(self.test_filename, 'a')
e = f.create_experiment()
e.create_analysis(g)
f.flush()
del f
del my_funct
f = omsi_file(self.test_filename, 'a')
e = f.get_experiment(0)
a = e.get_analysis(0)
g2 = a.restore_analysis()
res2 = g2.execute()
self.assertEquals(res1, res2)
def test_warp_function_save_and_recreate(self):
def my_funct(a):
return np.sum(a)
g = analysis_generic.from_function(my_funct)
res1 = g.execute(a=np.arange(10))
f = omsi_file(self.test_filename, 'a')
e = f.create_experiment()
e.create_analysis(g)
f.flush()
del f
del my_funct
f = omsi_file(self.test_filename, 'a')
e = f.get_experiment(0)
a = e.get_analysis(0)
g2 = a.restore_analysis()
res2 = g2.execute()
self.assertEquals(res1, res2)
def test_wrap_function_and_save(self):
def f(a):
return np.sum(a)
g = analysis_generic.from_function(f)
g.execute(a=np.arange(10))
f = omsi_file(self.test_filename, 'a')
e = f.create_experiment()
a = e.create_analysis(g)
f.flush()
self.assertNotEquals(a, None)
def main(argv=None):
"""Then main function"""
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) < 5:
print "Usage: python makeThumb.py <HDF5-File> <NMF-Index1> <NMF-Index2> <NMF-Index3>"
sys.exit(0)
# Settings
nmf_analysis_index = 1
experiment_index = 0
input_filename = argv[1]
image_index1 = int(argv[2])
image_index2 = int(argv[3])
image_index3 = int(argv[4])
apply_log_scale = True
thumbnail_filename = input_filename + "_0.png"
# Open the file and required analysis dataset
omsi_input_file = omsi_file(input_filename, 'r')
input_experiment = omsi_input_file.get_experiment(experiment_index)
input_analysis = input_experiment.get_analysis(nmf_analysis_index)
ho_data = input_analysis['ho']
# Load the required data
num_pixel_x = ho_data.shape[0]
num_pixel_y = ho_data.shape[1]
image_data1 = ho_data[:, :, image_index1].reshape((num_pixel_x, num_pixel_y))
image_data2 = ho_data[:, :, image_index2].reshape((num_pixel_x, num_pixel_y))
image_data3 = ho_data[:, :, image_index3].reshape((num_pixel_x, num_pixel_y))
# Scale the data
if apply_log_scale:
image_data1 = np.log(image_data1 + 1)
image_data2 = np.log(image_data2 + 1)
image_data3 = np.log(image_data3 + 1)
# Normalize the data values
image_data1 /= float(np.max(image_data1))
image_data2 /= float(np.max(image_data2))
image_data3 /= float(np.max(image_data3))
# Generate the grayscale images
image_channel_red = Image.fromarray(image_data1.astype('float') * 255).convert('L')
image_channel_green = Image.fromarray(image_data2.astype('float') * 255).convert('L')
image_channel_blue = Image.fromarray(image_data3.astype('float') * 255).convert('L')
# Generate the RGB image and save the file
thumbnail = Image.merge('RGB', (image_channel_red, image_channel_green, image_channel_blue))
print "Save image"
thumbnail.save(thumbnail_filename, 'PNG')
print thumbnail_filename
def test_wrap_function_and_save(self):
def f(a):
return np.sum(a)
g = analysis_generic.from_function(f)
g.execute(a=np.arange(10))
f = omsi_file(self.test_filename, 'a')
e = f.create_experiment()
a = e.create_analysis(g)
f.flush()
self.assertNotEquals(a, None)
def run_peakcube(omsiInFile, expIndex, dataIndex, LPFIndex, NPGIndex):
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile,'r+')
except:
print "Error opening input file \"",omsiInFile,"\": ", sys.exc_info()[0]
exit(0)
# Get the experiment
exp = omsiFile.get_experiment( expIndex )
data = exp.get_msidata(dataIndex)
peaksMZdata = data.mz[:]
LPFanalysis = exp.get_analysis( LPFIndex )
NPGanalysis = exp.get_analysis( NPGIndex )
peaksBins = LPFanalysis['LPF_Peaks_MZ'][:]
peaksIntensities = LPFanalysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = LPFanalysis['LPF_Peaks_ArrayIndex'][:]
NPGPeaksLabels = NPGanalysis['npghc_peaks_labels'][:]
NPGLabelsList = NPGanalysis['npghc_labels_list'][:]
print "\n--- Creating Peak Cube ---"
myPC = omsi_peakcube(name_key="omsi_peakcube_" + str(ctime()))
#myPC.omsi_peakcube_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, NPGPeaksLabels, NPGLabelsList)
myPC.execute( peaksBins = peaksBins,
peaksIntensities = peaksIntensities,
peaksArrayIndex = peaksArrayIndex,
peaksMZdata = peaksMZdata,
HCpeaksLabels = NPGPeaksLabels ,
HCLabelsList = NPGLabelsList)
PCm = myPC['npg_peak_cube_mz']
print "NPG Peak Cube Mzs: \n", PCm.shape, "\n", PCm
PMz = myPC['npg_peak_mz']
print "NPG Peak Mz: \n", PMz.shape, "\n", PMz
print "\nSaving HDF5 analysis..."
PCanalysis, PCanalysisindex = exp.create_analysis(myPC)
print "done!"
print "--- omsi_peakcube complete ---\n"
print "PeakCube Analysis Index:", PCanalysisindex
# flush of peakcube
exp.experiment.file.flush()
omsiFile.close_file()
return PCanalysisindex
def run_peakcube(omsiInFile, expIndex, dataIndex, LPFIndex, NPGIndex):
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile, 'r+')
except:
print "Error opening input file \"", omsiInFile, "\": ", sys.exc_info(
)[0]
exit(0)
# Get the experiment
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
peaksMZdata = data.mz[:]
LPFanalysis = exp.get_analysis(LPFIndex)
NPGanalysis = exp.get_analysis(NPGIndex)
peaksBins = LPFanalysis['LPF_Peaks_MZ'][:]
peaksIntensities = LPFanalysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = LPFanalysis['LPF_Peaks_ArrayIndex'][:]
NPGPeaksLabels = NPGanalysis['npghc_peaks_labels'][:]
NPGLabelsList = NPGanalysis['npghc_labels_list'][:]
print "\n--- Creating Peak Cube ---"
myPC = omsi_peakcube(name_key="omsi_peakcube_" + str(ctime()))
#myPC.omsi_peakcube_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, NPGPeaksLabels, NPGLabelsList)
myPC.execute(peaksBins=peaksBins,
peaksIntensities=peaksIntensities,
peaksArrayIndex=peaksArrayIndex,
peaksMZdata=peaksMZdata,
HCpeaksLabels=NPGPeaksLabels,
HCLabelsList=NPGLabelsList)
PCm = myPC['npg_peak_cube_mz']
print "NPG Peak Cube Mzs: \n", PCm.shape, "\n", PCm
PMz = myPC['npg_peak_mz']
print "NPG Peak Mz: \n", PMz.shape, "\n", PMz
print "\nSaving HDF5 analysis..."
PCanalysis, PCanalysisindex = exp.create_analysis(myPC)
print "done!"
print "--- omsi_peakcube complete ---\n"
print "PeakCube Analysis Index:", PCanalysisindex
# flush of peakcube
exp.experiment.file.flush()
omsiFile.close_file()
return PCanalysisindex
def run_npg(omsiInFile, expIndex, dataIndex, LPFIndex, mzth, tcut):
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile, 'r+')
except:
print "Error opening input file \"", omsiInFile, "\": ", sys.exc_info(
)[0]
exit(0)
# Get the experiment and data
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
LPFanalysis = exp.get_analysis(LPFIndex)
peaksBins = LPFanalysis['LPF_Peaks_MZ'][:]
peaksIntensities = LPFanalysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = LPFanalysis['LPF_Peaks_ArrayIndex'][:]
peaksMZdata = data.mz[:]
peaksMZ = peaksMZdata[peaksBins]
# NPG --------------
print "\n--- Executing NPG ---"
myNPG = omsi_npg(name_key="omsi_npg_" + str(ctime()))
#myNPG.omsi_npg_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, peaksMZ, MZ_TH = mzth, clusterCut = tcut)
myNPG.execute(peaksBins=peaksBins,
npg_peaks_Intensities=peaksIntensities,
npg_peaks_ArrayIndex=peaksArrayIndex,
peaksMZdata=peaksMZdata,
peaksMZ=peaksMZ,
npg_mz_threshold=mzth,
npg_cluster_treecut=tcut)
print "\n\nResults"
NPGPL = myNPG['npghc_peaks_labels']
print "NPG HC Peaks Labels: \n", NPGPL
NPGLL = myNPG['npghc_labels_list']
print "NPG HC Labels List: \n", NPGLL
print "\nSaving HDF5 analysis..."
NPGanalysis, NPGanalysisindex = exp.create_analysis(myNPG)
print "done!"
print "--- omsi_npg complete ---\n"
print "NPG Analysis Index:", NPGanalysisindex
# flush of npg
exp.experiment.file.flush()
omsiFile.close_file()
return NPGanalysisindex
def run_npg(omsiInFile, expIndex, dataIndex, LPFIndex, mzth, tcut):
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile,'r+')
except:
print "Error opening input file \"",omsiInFile,"\": ", sys.exc_info()[0]
exit(0)
# Get the experiment and data
exp = omsiFile.get_experiment( expIndex )
data = exp.get_msidata(dataIndex)
LPFanalysis = exp.get_analysis( LPFIndex )
peaksBins = LPFanalysis['LPF_Peaks_MZ'][:]
peaksIntensities = LPFanalysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = LPFanalysis['LPF_Peaks_ArrayIndex'][:]
peaksMZdata = data.mz[:]
peaksMZ = peaksMZdata[peaksBins]
# NPG --------------
print "\n--- Executing NPG ---"
myNPG = omsi_npg(name_key="omsi_npg_" + str(ctime()))
#myNPG.omsi_npg_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, peaksMZ, MZ_TH = mzth, clusterCut = tcut)
myNPG.execute( peaksBins=peaksBins,
npg_peaks_Intensities=peaksIntensities,
npg_peaks_ArrayIndex=peaksArrayIndex,
peaksMZdata=peaksMZdata,
peaksMZ=peaksMZ,
npg_mz_threshold=mzth,
npg_cluster_treecut=tcut )
print "\n\nResults"
NPGPL = myNPG['npghc_peaks_labels']
print "NPG HC Peaks Labels: \n", NPGPL
NPGLL = myNPG['npghc_labels_list']
print "NPG HC Labels List: \n", NPGLL
print "\nSaving HDF5 analysis..."
NPGanalysis, NPGanalysisindex = exp.create_analysis(myNPG)
print "done!"
print "--- omsi_npg complete ---\n"
print "NPG Analysis Index:", NPGanalysisindex
# flush of npg
exp.experiment.file.flush()
omsiFile.close_file()
return NPGanalysisindex
def main(argv=None):
"""Then main function"""
import sys
from sys import argv,exit
if argv is None:
argv = sys.argv
#Check for correct usage
if len(argv) <2 :
print "USAGE: Call \"omsiHDF5File [expIndex dataIndex] \" "
print "\n"
print "This is a simple viewer for looking at OMSI HDF5 files."
print "The viewer takes the index of the experiment and the"
print "dataset to be used as optional input"
exit(0)
#Read the input arguments
omsiOutFile = argv[1]
expIndex = 0
dataIndex = 0
if len(argv)==4 :
expIndex = int(argv[2] )
dataIndex = int(argv[3] )
#Open the input HDF5 file
try:
omsiFile = omsi_file( omsiOutFile , 'r' ) #Open file in read only mode
except:
print "Unexpected error creating the output file:", sys.exc_info()[0]
exit(0)
#Get the experiment and dataset
exp = omsiFile.get_experiment( expIndex )
data = exp.get_msidata(dataIndex)
mzdata = exp.get_instrument_info().get_instrument_mz()
if data is None:
print "Could not access image data for the experiment"
exit(0)
#Initalize the viewer
viewer = MyViewer( data , mzdata )
plt.show()
def run_lpf(omsiInFile, expIndex, dataIndex, ph, slw, smw):
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile, 'r+')
except:
print "Error opening input file \"", omsiInFile, "\": ", sys.exc_info(
)[0]
exit(0)
# Get the experiment and data
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
peaksMZdata = data.mz[:]
# LPF --------------
print "\n--- Executing LPF ---"
myLPF = omsi_lpf(name_key="omsi_lpf_" + str(ctime()))
myLPF.execute(msidata=data,
mzdata=peaksMZdata,
peakheight=ph,
slwindow=slw,
smoothwidth=smw)
print "\n\nResults"
peaksBins = myLPF['LPF_Peaks_MZ'][:]
print "peaksBins:\n", peaksBins
peaksIntensities = myLPF['LPF_Peaks_Vals'][:]
print "peaksIntensities:\n", peaksIntensities
peaksArrayIndex = myLPF['LPF_Peaks_ArrayIndex'][:]
print "peaksArrayIndex:\n", peaksArrayIndex
print "\nSaving HDF5 analysis..."
LPFanalysis, LPFanalysisindex = exp.create_analysis(myLPF)
print "done!"
print "--- omsi_lpf complete ---\n"
print "LPF Analysis Index:", LPFanalysisindex
# flush of lpf
exp.experiment.file.flush()
omsiFile.close_file()
return LPFanalysisindex
def run_lpf(omsiInFile, expIndex, dataIndex, ph, slw, smw): #Open the input HDF5 file try: omsiFile = omsi_file(omsiInFile,'r+') except: print "Error opening input file \"",omsiInFile,"\": ", sys.exc_info()[0] exit(0) # Get the experiment and data exp = omsiFile.get_experiment( expIndex ) data = exp.get_msidata(dataIndex) peaksMZdata = data.mz[:] # LPF -------------- print "\n--- Executing LPF ---" myLPF = omsi_lpf(name_key="omsi_lpf_" + str(ctime())) myLPF.execute( msidata=data, mzdata=peaksMZdata, peakheight = ph, slwindow = slw, smoothwidth = smw) print "\n\nResults" peaksBins = myLPF['LPF_Peaks_MZ'][:] print "peaksBins:\n", peaksBins peaksIntensities = myLPF['LPF_Peaks_Vals'][:] print "peaksIntensities:\n", peaksIntensities peaksArrayIndex = myLPF['LPF_Peaks_ArrayIndex'][:] print "peaksArrayIndex:\n", peaksArrayIndex print "\nSaving HDF5 analysis..." LPFanalysis, LPFanalysisindex = exp.create_analysis(myLPF) print "done!" print "--- omsi_lpf complete ---\n" print "LPF Analysis Index:", LPFanalysisindex # flush of lpf exp.experiment.file.flush() omsiFile.close_file() return LPFanalysisindex
def main(argv=None):
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) != 6:
print "USAGE: Call \"omsi_peakcube OMSI_FILE [expIndex dataIndex LPFanalysisIndex NPGanalysisIndex] \" "
print "Generates PeakCube for NPG global peaks"
exit(0)
#Read the input arguments
omsiInFile = argv[1]
expIndex = int(argv[2])
dataIndex = int(argv[3])
LPFanalysisIndex = int(argv[4])
NPGanalysisIndex = int(argv[5])
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile)
except:
print "Error opening input file:", sys.exc_info()[0]
exit(0)
print "Input file: ", omsiInFile
print "LPF Analysis Index: ", LPFanalysisIndex
print "NPG Analysis Index: ", NPGanalysisIndex
#Get the experiment and data
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
peaksMZdata = data.mz[:]
LPFanalysis = exp.get_analysis(LPFanalysisIndex)
NPGanalysis = exp.get_analysis(NPGanalysisIndex)
print "\n[loading data...]"
peaksBins = LPFanalysis['LPF_Peaks_MZ'][:]
peaksIntensities = LPFanalysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = LPFanalysis['LPF_Peaks_ArrayIndex'][:]
NPGPL = NPGanalysis['npghc_peaks_labels'][:]
NPGLL = NPGanalysis['npghc_labels_list'][:]
print "[done!] lpf data shapes:"
print "peaksBins shape: ", peaksBins.shape
print "peaksIntensities shape: ", peaksIntensities.shape
print "peaksArrayIndex shape: ", peaksArrayIndex.shape
print "peaksMZdata shape: ", peaksMZdata.shape
print "NPGPL shape: ", NPGPL.shape
print "NPGLL shape: ", NPGLL.shape
sys.stdout.flush()
# pc
myPC = omsi_peakcube(name_key="omsi_peakcube_" + str(ctime()))
print "--- Creating Peak Cube ---"
#myPC.omsi_peakcube_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, NPGPL, NPGLL)
myPC.execute(peaksBins=peaksBins,
peaksIntensities=peaksIntensities,
peaksArrayIndex=peaksArrayIndex,
peaksMZdata=peaksMZdata,
HCpeaksLabels=NPGPL,
HCLabelsList=NPGLL)
PCm = myPC['npg_peak_cube_mz']
print "NPG Peak Cube Mzs: \n", PCm.shape, "\n", PCm
PMz = myPC['npg_peak_mz']
print "NPG Peak Mz: \n", PMz.shape, "\n", PMz
print "\nsaving HDF5 analysis..."
PCanalysis, PCanalysisindex = exp.create_analysis(myPC)
print "done!"
print "--- omsi_peakcube complete ---\n"
print "Peak Cube analysis index:", PCanalysisindex
print "omsi_peakcube complete for input file: ", omsiInFile, "\n"
def setUp(self):
self.named_temporary_file = tempfile.NamedTemporaryFile()
self.test_filename = self.named_temporary_file.name
self.testfile = omsi_file(self.test_filename)
self.exp = self.testfile.create_experiment()
def setUp(self):
self.named_temporary_file = tempfile.NamedTemporaryFile()
self.test_filename = self.named_temporary_file.name
self.testfile = omsi_file(self.test_filename)
self.exp = self.testfile.create_experiment()
def get_omsi_object(cls, h5py_object, resolve_dependencies=False):
"""
This static method is convenience function used to retrieve the corresponding interface class for a
given h5py group object.
:param h5py_object: h5py object for which the corresponding omsi_file API object should be generated.
This may also be a string describing the requested object based on a combination of the
path to the file and a path ot the object <filename.h5>:<object_path>
:param resolve_dependencies: Set to True if omsi_file_dependencydata objects should be resolved to retrieve
the dependent object the dependency is pointing to. Dependencies are resolved recursively,
i.e., if a dependency points to another dependency then that one will be resolved as well.
Default value is False, i.e., the omis_file_dependency object itself is returned.
:returns: None in case no corresponding object was found. Otherwise an instance of:
* omsi_file : If the given object is a h5py.File object
* omsi_file_experiment : If the given object is an experiment groupt
* omsi_file_methods : If the given object is a method group
* omsi_file_instrument : If the given object is an instrument group
* omsi_file_analysis : If the given object is an analysis group
* omsi_file_msidata : If the given object is a MSI data group
* omsi_file_dependencydata : If the fiven object is a dependency group
* The input h5py_object: If the given object is a h5py.Dataset or h5py.Group
* None: In case that an unknown type is given.
"""
from omsi.dataformat.omsi_file.experiment import omsi_file_experiment
from omsi.dataformat.omsi_file.main_file import omsi_file
from omsi.dataformat.omsi_file.dependencies import omsi_file_dependencies, omsi_file_dependencydata
from omsi.dataformat.omsi_file.instrument import omsi_file_instrument
from omsi.dataformat.omsi_file.methods import omsi_file_methods
from omsi.dataformat.omsi_file.analysis import omsi_file_analysis
from omsi.dataformat.omsi_file.msidata import omsi_file_msidata
from omsi.dataformat.omsi_file.metadata_collection import omsi_file_metadata_collection
# If the input object is already an omsi API object then return it as is
if isinstance(h5py_object, omsi_file) or \
isinstance(h5py_object, omsi_file_experiment) or \
isinstance(h5py_object, omsi_file_methods) or\
isinstance(h5py_object, omsi_file_instrument) or \
isinstance(h5py_object, omsi_file_analysis) or \
isinstance(h5py_object, omsi_file_msidata) or \
isinstance(h5py_object, omsi_file_dependencies) or \
isinstance(h5py_object, omsi_file_dependencydata) or \
isinstance(h5py_object, omsi_file_metadata_collection):
return h5py_object
# IF we have an h5py.File then create and omsi_file
if isinstance(h5py_object, h5py.File):
return omsi_file(h5py_object)
# If we have an h5py.Group, then try to create a corresponding omsi API object
elif isinstance(h5py_object, h5py.Group):
# Check if the group has an explicit type attribute
try:
# Try to determine the type of the group based on the
# attributes
type_attribute = h5py_object.attrs[omsi_format_common.type_attribute]
if type_attribute == "omsi_file_experiment":
return omsi_file_experiment(h5py_object)
elif type_attribute == "omsi_file_methods" or type_attribute == "omsi_file_methods":
return omsi_file_methods(h5py_object)
elif type_attribute == "omsi_file_instrument":
return omsi_file_instrument(h5py_object)
elif type_attribute == "omsi_file_analysis":
return omsi_file_analysis(h5py_object)
elif type_attribute == "omsi_file_msidata":
return omsi_file_msidata(h5py_object)
elif type_attribute == "omsi_file":
return omsi_file(h5py_object)
elif type_attribute == "omsi_file_dependencydata":
omsiobject = omsi_file_dependencydata(h5py_object)
if resolve_dependencies:
return omsi_file_common.get_omsi_object(
omsi_file_common.get_h5py_object(omsiobject.get_dependency_omsiobject(),
resolve_dependencies))
else:
return omsiobject
elif type_attribute == "omsi_file_dependencies":
return omsi_file_dependencies(h5py_object)
elif type_attribute == 'omsi_file_metadata_collection':
return omsi_file_metadata_collection(h5py_object)
else:
return h5py_object
except:
# If the attribute is missing, then try to determine the type
# based on he name of group
groupname = h5py_object.name.split("/")[-1]
parentgroupname = h5py_object.parent.name.split("/")[-1]
if groupname.startswith(omsi_format_experiment.exp_groupname):
return omsi_file_experiment(h5py_object)
elif groupname.startswith(omsi_format_methods.methods_groupname) or \
groupname.startswith(omsi_format_methods.methods_old_groupname):
return omsi_file_methods(h5py_object)
elif groupname.startswith(omsi_format_instrument.instrument_groupname):
return omsi_file_instrument(h5py_object)
elif groupname.startswith(omsi_format_analysis.analysis_groupname):
return omsi_file_analysis(h5py_object)
elif groupname.startswith(omsi_format_data.data_groupname):
return omsi_file_msidata(h5py_object)
elif groupname.startswith(omsi_format_dependencies.dependencies_groupname):
return omsi_file_dependencies(h5py_object)
elif parentgroupname.startswith(omsi_format_dependencies.dependencies_groupname):
omsiobject = omsi_file_dependencydata(h5py_object)
if resolve_dependencies:
return omsi_file_common.get_omsi_object(
omsi_file_common.get_h5py_object(omsiobject.get_dependency_omsiobject(),
resolve_dependencies))
else:
return omsiobject
elif parentgroupname.startswith(omsi_format_metadata_collection.metadata_collection_groupname_default):
return omsi_file_metadata_collection(h5py_object)
elif groupname == "": # We are at the root group
return omsi_file(h5py_object.file)
else:
return h5py_object
# If we have an hpy.Dataset then we don't have a corresponding API object. Return as is
elif isinstance(h5py_object, h5py.Dataset):
return h5py_object
elif isinstance(h5py_object, basestring):
import os
filename, object_path = cls.parse_path_string(h5py_object)
if filename is not None and os.path.exists(filename) and os.path.isfile(filename):
try:
curr_omsi_file = omsi_file(filename, 'r')
except:
return None
else:
return None
if object_path is not None:
try:
file_object = curr_omsi_file.managed_group[object_path]
except KeyError:
return None
return omsi_file_common.get_omsi_object(file_object, resolve_dependencies=True)
else:
if isinstance(curr_omsi_file, omsi_file):
return curr_omsi_file
else:
raise ValueError('omsi_file_common.Invalid path or file')
else:
return None
def main(argv=None):
"""Then main function"""
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) < 3:
print_help()
sys.exit(0)
infile = argv[1]
experiment_index = int(argv[2])
analysis_index = int(argv[3])
output_filename = argv[4]
# Open the file and get to the data
# Note the analysis and experiment index may vary for different datasets
omsi_input_file = omsi_file(infile, 'r')
input_experiment = omsi_input_file.get_experiment(experiment_index)
input_analysis = input_experiment.get_analysis(analysis_index)
# Get the peak finding data abd load it all
input_dataset = input_analysis['peak_cube']
input_mz_dataset = input_analysis['peak_mz']
print input_analysis.items()
# Load all the peak finding data
peak_cube = input_dataset[:]
peak_mz = input_mz_dataset[:]
x_dim = peak_cube.shape[0]
y_dim = peak_cube.shape[1]
num_slices = peak_cube.shape[2]
# Generate the images
print "Generating images"
names = []
for row_index in range(0, num_slices):
sys.stdout.write("[" +
str(int(100. * float(row_index) /
float(num_slices))) + "%]" + "\r")
sys.stdout.flush()
image_data = peak_cube[:, :, row_index]
image_data = image_data.reshape((x_dim, y_dim))
image_data = image_data / np.max(image_data)
output_images = Image.fromarray(image_data.astype('float') * 255)
name = output_filename + str(peak_mz[row_index])
# Replace the "." in the string to make sure pdflatex does not complain about the filename
name = name.replace(".", "_")
name += ".png"
names.append(name)
output_images.convert('L').save(name, 'PNG')
# Generate the latex file
print "Generating LaTeX file"
tex_filename = output_filename + "summary.tex"
latex_file = open(tex_filename, 'w')
latex_file.write("\documentclass[a4paper,10pt]{article}\n")
latex_file.write("\usepackage[utf8x]{inputenc}\n")
latex_file.write("\usepackage{graphicx}\n")
latex_file.write("\\title{Peak Images}\n")
latex_file.write("\\author{Oliver Ruebel}\n")
latex_file.write("\date{" + str(datetime.date.today()) + "}\n")
latex_file.write("\\begin{document}\n")
latex_file.write("\maketitle\n ")
# Write the latex table with the image files
number_of_columns = 3
res = float(x_dim) / float(y_dim)
number_of_rows = int(1.29 / (0.3 * (float(x_dim) / float(y_dim))))
if number_of_rows < 1:
number_of_rows = 1
print "WARNING: Images may not fit on a single page. Reduce the width of image plots"
total_number_of_rows = int(len(names) / float(number_of_columns) + 0.5)
for row_index in range(0, total_number_of_rows):
sys.stdout.write(
"[" +
str(int(100. * float(row_index) / float(total_number_of_rows))) +
"%]" + "\r")
sys.stdout.flush()
if row_index % number_of_rows == 0:
latex_file.write("\\begin{center}\n")
latex_file.write("\\begin{tabular}{lll}\n")
for column_index in xrange(0, number_of_columns):
index = row_index * number_of_columns + column_index
if index < peak_mz.size:
latex_file.write(str(peak_mz[index]))
else:
latex_file.write(" ")
if column_index < (number_of_columns - 1):
latex_file.write(" & ")
else:
latex_file.write(" \\\\ \n")
for column_index in xrange(0, number_of_columns):
index = row_index * number_of_columns + column_index
if index < len(names):
latex_file.write("\includegraphics[width=0.3\\textwidth]{" +
os.path.basename(names[index]) + "}")
else:
latex_file.write(" ")
if column_index < (number_of_columns - 1):
latex_file.write(" & ")
else:
latex_file.write(" \\\\ \n")
if row_index % number_of_rows == (number_of_rows - 1) or row_index == (
total_number_of_rows - 1):
latex_file.write("\\end{tabular}\n")
latex_file.write("\\end{center}\n")
latex_file.write("\\end{document}\n")
latex_file.close()
print "Building the PDF file"
abs_path = os.path.abspath(tex_filename)
latex_dir = os.path.dirname(abs_path)
latex_filename = os.path.basename(abs_path)
subprocess.call(["pdflatex", latex_filename], cwd=latex_dir)
def save_arrayed_image_to_omsi_file(arrayedImage, filename=None, spotSpectra=None):
"""
Save the data from an ArrayedImage and additional spot spectru to and OpenMSI-compliant HDF5 file
:param filename: Name of the output file. If filename is None, then we will ask for a filename via input
:param arrayedImage: Instance of OMAAT ArrayedImage to be saved
:param spotSpectra: data frame or numpy array of spot spectra generated by OMAAT
Requires: This function requires the following packages: BASTet, h5y, numpy, pandas, pickle, datetime
:return: Instance of omsi.dataformat.omsi_file.main_file.omsi_file of the generated output OpenMSI file
"""
from omsi.analysis.generic import analysis_generic
from omsi.dataformat.omsi_file.main_file import omsi_file
import h5py
import pickle
import datetime
import numpy as np
import pandas as pd
if filename is None:
filename = input("Output filename: ")
dt = datetime.datetime.now()
curr_ana = analysis_generic(name_key="openmsi_arrayed_analysis_results_{:d}-{:d}-{:d}_{:d}h{:d}.csv".format(dt.year,dt.month,dt.day,dt.hour,dt.minute))
dtypes = curr_ana.get_default_dtypes()
groups = curr_ana.get_default_parameter_groups()
curr_ana.real_analysis_type = 'omaat_lib.ArrayedImage'
curr_ana.data_names = ['spotLocations', 'xCenters', 'yCenters', 'baseImage', 'imStack', 'spectraDF', 'arrayedImageP', 'spotSpectraP', 'spotSpectra']
curr_ana['spotLocations'] = arrayedImage.spotLocations
if isinstance(arrayedImage.spotList, list):
for spot_index, spot in enumerate(arrayedImage.spotList):
spot_name = 'spot_'+str(spot_index)
curr_ana.data_names.append(spot_name)
curr_ana[spot_name] = spot
curr_ana['xCenters'] = arrayedImage.xCenters
curr_ana['yCenters'] = arrayedImage.yCenters
curr_ana['baseImage'] = arrayedImage.baseImage
curr_ana['imStack'] = arrayedImage.imStack
try:
curr_ana['spectraDF'] = arrayedImage.spectra_df
except AttributeError:
curr_ana['spectraDF'] = None
curr_ana['arrayedImageP'] = pickle.dumps(arrayedImage)
if curr_ana['spectraDF'] is None:
curr_ana['spectraDF'] = arrayedImage.resultsDataFrame()
if spotSpectra is not None:
if isinstance(spotSpectra, pd.DataFrame):
curr_ana['spotSpectra'] = spotSpectra.as_matrix()
curr_ana['spotSpectraP'] = pickle.dumps(spotSpectra)
else:
curr_ana['spotSpectra'] = np.asarray(spotSpectra)
if curr_ana['spotSpectra'].dtype == np.dtype('O'):
curr_ana.pop('spotSpectra')
raise ValueError("Unsupported format for spotSpectra. Conversion to numpy resulted in type 'O'")
curr_ana.add_parameter(name='Nrows',
help='Number of rows',
dtype=dtypes['int'],
required=True,
default=12,
choices=None,
group=groups['settings'],
data=arrayedImage.Nrows)
curr_ana.add_parameter(name='Ncolumns',
help='Number of columns',
dtype=dtypes['int'],
required=True,
default=12,
choices=None,
group=groups['settings'],
data=arrayedImage.Ncolumns)
curr_ana.add_parameter(name='mz',
help='The m/z axis of the input data',
dtype=dtypes['ndarray'],
required=True,
group=groups['input'],
data=arrayedImage.mz)
curr_ana.add_parameter(name='ions',
help='List of ions used',
dtype=dtypes['ndarray'],
required=True,
group=groups['input'],
data=arrayedImage.ions)
curr_ana.add_parameter(name='originalSize',
help='Original size',
dtype=dtypes['ndarray'],
required=True,
group=groups['input'],
data=arrayedImage.originalSize)
curr_ana.add_parameter(name='filename',
help='The name of the input file',
dtype=dtypes['unicode'],
required=True,
group=groups['input'],
data=arrayedImage.filename)
curr_ana.add_parameter(name='expIndex',
help='The index of the experiment in the input file',
dtype=dtypes['int'],
required=True,
group=groups['input'],
data=arrayedImage.expIndex)
curr_ana.add_parameter(name='dataIndex',
help='The index of the dataset in the input file',
dtype=dtypes['int'],
required=True,
group=groups['input'],
data=arrayedImage.dataIndex)
outfile = omsi_file(h5py.File(filename))
exp = outfile.create_experiment(exp_identifier='OMAAT store')
exp.create_analysis(curr_ana)
outfile.flush()
return outfile
def main(argv=None):
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) != 6:
print "USAGE: Call \"omsi_peakcube OMSI_FILE [expIndex dataIndex LPFanalysisIndex NPGanalysisIndex] \" "
print "Generates PeakCube for NPG global peaks"
exit(0)
#Read the input arguments
omsiInFile = argv[1]
expIndex = int(argv[2])
dataIndex = int(argv[3])
LPFanalysisIndex = int(argv[4])
NPGanalysisIndex = int(argv[5])
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile)
except:
print "Error opening input file:", sys.exc_info()[0]
exit(0)
print "Input file: ", omsiInFile
print "LPF Analysis Index: ", LPFanalysisIndex
print "NPG Analysis Index: ", NPGanalysisIndex
#Get the experiment and data
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
peaksMZdata = data.mz[:]
LPFanalysis = exp.get_analysis(LPFanalysisIndex)
NPGanalysis = exp.get_analysis(NPGanalysisIndex)
print "\n[loading data...]"
peaksBins = LPFanalysis['LPF_Peaks_MZ'][:]
peaksIntensities = LPFanalysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = LPFanalysis['LPF_Peaks_ArrayIndex'][:]
NPGPL = NPGanalysis['npghc_peaks_labels'][:]
NPGLL = NPGanalysis['npghc_labels_list'][:]
print "[done!] lpf data shapes:"
print "peaksBins shape: ", peaksBins.shape
print "peaksIntensities shape: ", peaksIntensities.shape
print "peaksArrayIndex shape: ", peaksArrayIndex.shape
print "peaksMZdata shape: ", peaksMZdata.shape
print "NPGPL shape: ", NPGPL.shape
print "NPGLL shape: ", NPGLL.shape
sys.stdout.flush()
# pc
myPC = omsi_peakcube(name_key="omsi_peakcube_" + str(ctime()))
print "--- Creating Peak Cube ---"
#myPC.omsi_peakcube_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, NPGPL, NPGLL)
myPC.execute(peaksBins=peaksBins,
peaksIntensities=peaksIntensities,
peaksArrayIndex=peaksArrayIndex,
peaksMZdata=peaksMZdata,
HCpeaksLabels=NPGPL,
HCLabelsList=NPGLL)
PCm = myPC['npg_peak_cube_mz']
print "NPG Peak Cube Mzs: \n", PCm.shape, "\n", PCm
PMz = myPC['npg_peak_mz']
print "NPG Peak Mz: \n", PMz.shape, "\n", PMz
print "\nsaving HDF5 analysis..."
PCanalysis, PCanalysisindex = exp.create_analysis(myPC)
print "done!"
print "--- omsi_peakcube complete ---\n"
print "Peak Cube analysis index:", PCanalysisindex
print "omsi_peakcube complete for input file: ", omsiInFile, "\n"
def setUp(self):
self.named_temporary_file = tempfile.NamedTemporaryFile()
self.test_filename = self.named_temporary_file.name
self.testfile = omsi_file(self.test_filename)
def main(argv=None):
"""Then main function"""
import sys
from sys import argv,exit
if argv is None:
argv = sys.argv
#Check for correct usage
if len(argv) <3 :
printHelp()
exit(0)
infile = argv[1]
expIndex = int(argv[2])
anaIndex = int(argv[3])
outfileName = argv[4]
#Open the file and get to the data
#Note the analysis and experiment index may vary for different datasets
f = omsi_file( infile , 'r' )
e = f.get_experiment(expIndex)
ana = e.get_analysis(anaIndex)
#Get the peak finding data abd load it all
pc = ana[ 'peak_cube' ]
pm = ana[ 'peak_mz' ]
#Load all the peak finding data
peakCube = pc[:]
peakMZ = pm[:]
xdim = peakCube.shape[0]
ydim = peakCube.shape[1]
numSlices = peakCube.shape[2]
#Generate the images
print "Generating images"
names = []
for i in range(0,numSlices) :
sys.stdout.write("[" +str( int( 100.* float(i)/float(numSlices) )) +"%]"+ "\r")
sys.stdout.flush()
imData = peakCube[:,:,i]
imData = imData.reshape((xdim,ydim))
imData = imData / np.max(imData)
a = Image.fromarray( imData.astype('float') * 255 )
name = outfileName + str(peakMZ[i])
name = name.replace( "." , "_" ) #Replace the "." in the string to make sure pdflatex does not complain about the filename
name = name +".png"
names.append( name )
a.convert('L').save( name , 'PNG' )
#Generate the latex file
print "Generating LaTeX file"
texFileName = outfileName+"summary.tex"
latexFile = open( texFileName , 'w' )
latexFile.write("\documentclass[a4paper,10pt]{article}\n")
latexFile.write("\usepackage[utf8x]{inputenc}\n")
latexFile.write("\usepackage{graphicx}\n")
latexFile.write("\\title{Peak Images}\n")
latexFile.write("\\author{Oliver Ruebel}\n")
latexFile.write("\date{"+str(datetime.date.today())+"}\n")
latexFile.write("\\begin{document}\n")
latexFile.write("\maketitle\n ")
#Write the latex table with the image files
numRows = 6
numCols = 3
totalNumRows = int( len(names) / float(numCols) +0.5 )
for i in range( 0 , totalNumRows ):
sys.stdout.write("[" +str( int( 100.* float(i)/float(totalNumRows) )) +"%]"+ "\r")
sys.stdout.flush()
if i % numRows == 0 :
latexFile.write("\\begin{center}\n")
latexFile.write("\\begin{tabular}{lll}\n")
for ci in xrange(0,numCols) :
index = i*numCols+ci
if index < peakMZ.size :
latexFile.write(str(peakMZ[index]))
else :
latexFile.write(" ")
if ci < (numCols-1) :
latexFile.write(" & ")
else :
latexFile.write( " \\\\ \n")
for ci in xrange(0,numCols) :
index = i*numCols+ci
if index < len(names) :
latexFile.write("\includegraphics[width=0.3\\textwidth]{"+names[index]+"}")
else :
latexFile.write(" ")
if ci < (numCols-1) :
latexFile.write(" & ")
else :
latexFile.write( " \\\\ \n")
if i%numRows == (numRows-1) or i == (totalNumRows-1) :
latexFile.write("\\end{tabular}\n")
latexFile.write("\\end{center}\n")
latexFile.write("\\end{document}\n")
def main(argv=None):
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) != 5:
print "USAGE: Call \"omsi_npg OMSI_FILE [expIndex dataIndex LPFanalysisIndex] \" "
print "Nearby-Peaks Global peakfinding"
exit(0)
#Read the input arguments
omsiInFile = argv[1]
expIndex = int(argv[2])
dataIndex = int(argv[3])
analysisIndex = int(argv[4])
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile)
except:
print "Error opening input file:", sys.exc_info()[0]
exit(0)
print "Input file: ", omsiInFile
print "LPF Analysis Index: ", analysisIndex
#Get the experiment and data
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
analysis = exp.get_analysis(analysisIndex)
print "\n[loading data...]"
peaksBins = analysis['LPF_Peaks_MZ'][:]
peaksIntensities = analysis['LPF_Peaks_Vals'][:]
peaksArrayIndex = analysis['LPF_Peaks_ArrayIndex'][:]
peaksMZdata = data.mz[:]
peaksMZ = peaksMZdata[peaksBins]
print "[done!] lpf data shapes:"
print "peaksBins shape: ", peaksBins.shape
print "peaksIntensities shape: ", peaksIntensities.shape
print "peaksArrayIndex shape: ", peaksArrayIndex.shape
print "peaksMZdata shape: ", peaksMZdata.shape
print "peaksMZ shape: ", peaksMZ.shape
sys.stdout.flush()
# npg
myNPG = omsi_npg(name_key="omsi_npg_" + str(ctime()))
print "--- Executing NPG ---"
#myNPG.omsi_npg_exec(peaksBins, peaksIntensities, peaksArrayIndex, peaksMZdata, peaksMZ)
myNPG.execute(peaksBins=peaksBins,
npg_peaks_Intensities=peaksIntensities,
npg_peaks_ArrayIndex=peaksArrayIndex,
peaksMZdata=peaksMZdata,
peaksMZ=peaksMZ)
print "\nResults:"
NPGPL = myNPG['npghc_peaks_labels']
print "NPG HC Peaks Labels: \n", NPGPL
NPGLL = myNPG['npghc_labels_list']
print "NPG HC Labels List: \n", NPGLL
print "\nsaving HDF5 analysis..."
NPGanalysis, analysisindex = exp.create_analysis(myNPG)
print "done!"
print "npg analysis index:", analysisindex
print "omsi_npg complete for input file: ", omsiInFile, "\n"
def main(argv=None):
"""Then main function"""
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) < 2:
print "USAGE: Call \"omsi_lpf OMSI_FILE [expIndex dataIndex peakHeight] \" "
print "Local peakfinding using opencl"
exit(0)
#Read the input arguments
omsiInFile = argv[1]
sys.stdout.flush()
expIndex = 0
dataIndex = 0
mypeakheight = 10
if len(argv) == 4:
expIndex = int(argv[2])
dataIndex = int(argv[3])
if len(argv) == 5:
expIndex = int(argv[2])
dataIndex = int(argv[3])
mypeakheight = int(argv[4])
#Open the input HDF5 file
try:
omsiFile = omsi_file(omsiInFile, 'a')
except:
print "Unexpected openeing the input file:", sys.exc_info()[0]
exit(0)
print "Input file: ", omsiInFile
#Get the experiment and dataset
exp = omsiFile.get_experiment(expIndex)
data = exp.get_msidata(dataIndex)
mzdata = data.mz[:]
#Execute the peak finding
myLPF = omsi_lpf(name_key="omsi_lpf_" + str(ctime()))
print "--- Executing LPF ---"
myLPF.execute(data, mzdata, peakheight=mypeakheight)
print "\n\nGetting peak finding analysis results"
pmz = myLPF['LPF_Peaks_MZ']
print "pmz:\n", pmz
pv = myLPF['LPF_Peaks_Vals']
print "pv:\n", pv
pai = myLPF['LPF_Peaks_ArrayIndex']
print "pai:\n", pai
print "\nsaving HDF5 analysis..."
analysis, analysisindex = exp.create_analysis(myLPF)
print "done!"
print "lpf analysis index:", analysisindex
print "omsi_lpf complete for input file: ", omsiInFile, "\n"
def parse_cl_arguments(self):
"""
The function assumes that the command line parser has been setup using the initialize_argument_parser(..)
This function parses all arguments that are specific to the command-line parser itself. Analysis workflow
arguments are added and parsed later by the add_and_parse_workflow_arguments(...) function.
The reason for this is two-fold: i) to separate the parsing of analysis arguments and arguments of the
command-line driver and ii) if the same HDF5 file is used as input and output target, then we need to
open it first here in append mode before it gets opened in read mode later by the arguments.
*Side effects:* The function sets:
- ``self.output_target``
- ``self.profile_analyses``
"""
# Parse the arguments and convert them to a dict using vars
parsed_arguments = vars(self.parser.parse_known_args()[0])
# Process the --save argument to determine where we should save the output
if self.output_save_arg_name in parsed_arguments and mpi_helper.get_rank(
) == self.mpi_root:
# Determine the filename and experiment group from the path
self.output_target = parsed_arguments.pop(
self.output_save_arg_name)
if self.output_target is not None:
output_filename, output_object_path = omsi_file_common.parse_path_string(
self.output_target)
# Create the output file
if output_filename is None:
raise ValueError(
"ERROR: Invalid save parameter specification " +
self.output_target)
elif os.path.exists(output_filename
) and not os.path.isfile(output_filename):
raise ValueError(
"ERROR: Save parameter not specify a file.")
if not os.path.exists(output_filename):
out_file = omsi_file(output_filename, mode='a')
self.output_target = out_file.create_experiment()
self.__output_target_self = output_filename
else:
out_file = omsi_file(output_filename, mode='r+')
if output_object_path is not None:
self.output_target = omsi_file_common.get_omsi_object(
out_file[output_object_path])
else:
if out_file.get_num_experiments() > 0:
self.output_target = out_file.get_experiment(0)
else:
self.output_target = out_file.create_experiment()
else:
self.output_target = parsed_arguments.pop(
self.output_save_arg_name)
# Process the --profile profiling argument
if self.profile_arg_name in parsed_arguments:
self.profile_analyses = parsed_arguments.pop(self.profile_arg_name)
# Process the --memprofile argument
if self.profile_mem_arg_name in parsed_arguments:
self.profile_analyses_mem = parsed_arguments.pop(
self.profile_mem_arg_name)
# The --loglevel argument
if self.log_level_arg_name in parsed_arguments:
self.user_log_level = parsed_arguments.pop(self.log_level_arg_name)
if self.user_log_level in log_helper.log_levels.keys():
log_helper.set_log_level(
level=log_helper.log_levels[self.user_log_level])
else:
self.user_log_level = None
log_helper.error(module_name=__name__,
message="Invalid log level specified")
# The --script arguments
if self.script_arg_name in parsed_arguments:
self.script_files = parsed_arguments.pop(self.script_arg_name)
if self.workflow_executor is None:
self.create_workflow_executor_object()
else:
self.workflow_executor.add_analysis_from_scripts(
script_files=self.script_files)
def setUp(self):
self.named_temporary_file = tempfile.NamedTemporaryFile()
self.test_filename = self.named_temporary_file.name
self.testfile = omsi_file(self.test_filename)
def get_omsi_object(cls, h5py_object, resolve_dependencies=False):
"""
This static method is convenience function used to retrieve the corresponding interface class for a
given h5py group object.
:param h5py_object: h5py object for which the corresponding omsi_file API object should be generated.
This may also be a string describing the requested object based on a combination of the
path to the file and a path ot the object <filename.h5>:<object_path>
:param resolve_dependencies: Set to True if omsi_file_dependencydata objects should be resolved to retrieve
the dependent object the dependency is pointing to. Dependencies are resolved recursively,
i.e., if a dependency points to another dependency then that one will be resolved as well.
Default value is False, i.e., the omis_file_dependency object itself is returned.
:returns: None in case no corresponding object was found. Otherwise an instance of:
* omsi_file : If the given object is a h5py.File object
* omsi_file_experiment : If the given object is an experiment groupt
* omsi_file_methods : If the given object is a method group
* omsi_file_instrument : If the given object is an instrument group
* omsi_file_analysis : If the given object is an analysis group
* omsi_file_msidata : If the given object is a MSI data group
* omsi_file_dependencydata : If the fiven object is a dependency group
* The input h5py_object: If the given object is a h5py.Dataset or h5py.Group
* None: In case that an unknown type is given.
"""
from omsi.dataformat.omsi_file.experiment import omsi_file_experiment
from omsi.dataformat.omsi_file.main_file import omsi_file
from omsi.dataformat.omsi_file.dependencies import omsi_file_dependencies, omsi_file_dependencydata
from omsi.dataformat.omsi_file.instrument import omsi_file_instrument
from omsi.dataformat.omsi_file.methods import omsi_file_methods
from omsi.dataformat.omsi_file.analysis import omsi_file_analysis
from omsi.dataformat.omsi_file.msidata import omsi_file_msidata
from omsi.dataformat.omsi_file.metadata_collection import omsi_file_metadata_collection
# If the input object is already an omsi API object then return it as is
if isinstance(h5py_object, omsi_file) or \
isinstance(h5py_object, omsi_file_experiment) or \
isinstance(h5py_object, omsi_file_methods) or\
isinstance(h5py_object, omsi_file_instrument) or \
isinstance(h5py_object, omsi_file_analysis) or \
isinstance(h5py_object, omsi_file_msidata) or \
isinstance(h5py_object, omsi_file_dependencies) or \
isinstance(h5py_object, omsi_file_dependencydata) or \
isinstance(h5py_object, omsi_file_metadata_collection):
return h5py_object
# IF we have an h5py.File then create and omsi_file
if isinstance(h5py_object, h5py.File):
return omsi_file(h5py_object)
# If we have an h5py.Group, then try to create a corresponding omsi API object
elif isinstance(h5py_object, h5py.Group):
# Check if the group has an explicit type attribute
try:
# Try to determine the type of the group based on the
# attributes
type_attribute = h5py_object.attrs[
omsi_format_common.type_attribute]
if type_attribute == "omsi_file_experiment":
return omsi_file_experiment(h5py_object)
elif type_attribute == "omsi_file_methods" or type_attribute == "omsi_file_methods":
return omsi_file_methods(h5py_object)
elif type_attribute == "omsi_file_instrument":
return omsi_file_instrument(h5py_object)
elif type_attribute == "omsi_file_analysis":
return omsi_file_analysis(h5py_object)
elif type_attribute == "omsi_file_msidata":
return omsi_file_msidata(h5py_object)
elif type_attribute == "omsi_file":
return omsi_file(h5py_object)
elif type_attribute == "omsi_file_dependencydata":
omsiobject = omsi_file_dependencydata(h5py_object)
if resolve_dependencies:
return omsi_file_common.get_omsi_object(
omsi_file_common.get_h5py_object(
omsiobject.get_dependency_omsiobject(),
resolve_dependencies))
else:
return omsiobject
elif type_attribute == "omsi_file_dependencies":
return omsi_file_dependencies(h5py_object)
elif type_attribute == 'omsi_file_metadata_collection':
return omsi_file_metadata_collection(h5py_object)
else:
return h5py_object
except:
# If the attribute is missing, then try to determine the type
# based on he name of group
groupname = h5py_object.name.split("/")[-1]
parentgroupname = h5py_object.parent.name.split("/")[-1]
if groupname.startswith(omsi_format_experiment.exp_groupname):
return omsi_file_experiment(h5py_object)
elif groupname.startswith(omsi_format_methods.methods_groupname) or \
groupname.startswith(omsi_format_methods.methods_old_groupname):
return omsi_file_methods(h5py_object)
elif groupname.startswith(
omsi_format_instrument.instrument_groupname):
return omsi_file_instrument(h5py_object)
elif groupname.startswith(
omsi_format_analysis.analysis_groupname):
return omsi_file_analysis(h5py_object)
elif groupname.startswith(omsi_format_data.data_groupname):
return omsi_file_msidata(h5py_object)
elif groupname.startswith(
omsi_format_dependencies.dependencies_groupname):
return omsi_file_dependencies(h5py_object)
elif parentgroupname.startswith(
omsi_format_dependencies.dependencies_groupname):
omsiobject = omsi_file_dependencydata(h5py_object)
if resolve_dependencies:
return omsi_file_common.get_omsi_object(
omsi_file_common.get_h5py_object(
omsiobject.get_dependency_omsiobject(),
resolve_dependencies))
else:
return omsiobject
elif parentgroupname.startswith(
omsi_format_metadata_collection.
metadata_collection_groupname_default):
return omsi_file_metadata_collection(h5py_object)
elif groupname == "": # We are at the root group
return omsi_file(h5py_object.file)
else:
return h5py_object
# If we have an hpy.Dataset then we don't have a corresponding API object. Return as is
elif isinstance(h5py_object, h5py.Dataset):
return h5py_object
elif isinstance(h5py_object, basestring):
import os
filename, object_path = cls.parse_path_string(h5py_object)
if filename is not None and os.path.exists(
filename) and os.path.isfile(filename):
try:
curr_omsi_file = omsi_file(filename, 'r')
except:
return None
else:
return None
if object_path is not None:
try:
file_object = curr_omsi_file.managed_group[object_path]
except KeyError:
return None
return omsi_file_common.get_omsi_object(
file_object, resolve_dependencies=True)
else:
if isinstance(curr_omsi_file, omsi_file):
return curr_omsi_file
else:
raise ValueError('omsi_file_common.Invalid path or file')
else:
return None
def main(argv=None):
"""Then main function"""
if argv is None:
argv = sys.argv
# Check for correct usage
if len(argv) < 3:
print_help()
sys.exit(0)
infile = argv[1]
experiment_index = int(argv[2])
analysis_index = int(argv[3])
output_filename = argv[4]
# Open the file and get to the data
# Note the analysis and experiment index may vary for different datasets
omsi_input_file = omsi_file(infile, 'r')
input_experiment = omsi_input_file.get_experiment(experiment_index)
input_analysis = input_experiment.get_analysis(analysis_index)
# Get the peak finding data abd load it all
input_dataset = input_analysis['peak_cube']
input_mz_dataset = input_analysis['peak_mz']
print input_analysis.items()
# Load all the peak finding data
peak_cube = input_dataset[:]
peak_mz = input_mz_dataset[:]
x_dim = peak_cube.shape[0]
y_dim = peak_cube.shape[1]
num_slices = peak_cube.shape[2]
# Generate the images
print "Generating images"
names = []
for row_index in range(0, num_slices):
sys.stdout.write("[" + str(int(100. * float(row_index)/float(num_slices))) + "%]" + "\r")
sys.stdout.flush()
image_data = peak_cube[:, :, row_index]
image_data = image_data.reshape((x_dim, y_dim))
image_data = image_data / np.max(image_data)
output_images = Image.fromarray(image_data.astype('float') * 255)
name = output_filename + str(peak_mz[row_index])
# Replace the "." in the string to make sure pdflatex does not complain about the filename
name = name.replace(".", "_")
name += ".png"
names.append(name)
output_images.convert('L').save(name, 'PNG')
# Generate the latex file
print "Generating LaTeX file"
tex_filename = output_filename+"summary.tex"
latex_file = open(tex_filename, 'w')
latex_file.write("\documentclass[a4paper,10pt]{article}\n")
latex_file.write("\usepackage[utf8x]{inputenc}\n")
latex_file.write("\usepackage{graphicx}\n")
latex_file.write("\\title{Peak Images}\n")
latex_file.write("\\author{Oliver Ruebel}\n")
latex_file.write("\date{"+str(datetime.date.today())+"}\n")
latex_file.write("\\begin{document}\n")
latex_file.write("\maketitle\n ")
# Write the latex table with the image files
number_of_columns = 3
res = float(x_dim) / float(y_dim)
number_of_rows = int(1.29 / (0.3*(float(x_dim)/float(y_dim))))
if number_of_rows < 1:
number_of_rows = 1
print "WARNING: Images may not fit on a single page. Reduce the width of image plots"
total_number_of_rows = int(len(names) / float(number_of_columns) + 0.5)
for row_index in range(0, total_number_of_rows):
sys.stdout.write("[" + str(int(100. * float(row_index)/float(total_number_of_rows))) + "%]" + "\r")
sys.stdout.flush()
if row_index % number_of_rows == 0:
latex_file.write("\\begin{center}\n")
latex_file.write("\\begin{tabular}{lll}\n")
for column_index in xrange(0, number_of_columns):
index = row_index*number_of_columns+column_index
if index < peak_mz.size:
latex_file.write(str(peak_mz[index]))
else:
latex_file.write(" ")
if column_index < (number_of_columns-1):
latex_file.write(" & ")
else:
latex_file.write(" \\\\ \n")
for column_index in xrange(0, number_of_columns):
index = row_index*number_of_columns+column_index
if index < len(names):
latex_file.write("\includegraphics[width=0.3\\textwidth]{"+os.path.basename(names[index])+"}")
else:
latex_file.write(" ")
if column_index < (number_of_columns-1):
latex_file.write(" & ")
else:
latex_file.write(" \\\\ \n")
if row_index % number_of_rows == (number_of_rows-1) or row_index == (total_number_of_rows-1):
latex_file.write("\\end{tabular}\n")
latex_file.write("\\end{center}\n")
latex_file.write("\\end{document}\n")
latex_file.close()
print "Building the PDF file"
abs_path = os.path.abspath(tex_filename)
latex_dir = os.path.dirname(abs_path)
latex_filename = os.path.basename(abs_path)
subprocess.call(["pdflatex", latex_filename], cwd=latex_dir)
