ExitCodes main_(int, const char**)
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
//input file names
String in = getStringOption_("in");
//input file type
FileHandler fh;
FileTypes::Type in_type = FileTypes::nameToType(getStringOption_("in_type"));
if (in_type == FileTypes::UNKNOWN)
{
in_type = fh.getType(in);
writeDebug_(String("Input file type: ") + FileTypes::typeToName(in_type), 2);
}
if (in_type == FileTypes::UNKNOWN)
{
writeLog_("Error: Could not determine input file type!");
return PARSE_ERROR;
}
//output file names and types
String out = getStringOption_("out");
FileTypes::Type out_type = FileTypes::nameToType(getStringOption_("out_type"));
if (out_type == FileTypes::UNKNOWN)
{
out_type = fh.getTypeByFileName(out);
}
if (out_type == FileTypes::UNKNOWN)
{
writeLog_("Error: Could not determine output file type!");
return PARSE_ERROR;
}
bool TIC_DTA2D = getFlag_("TIC_DTA2D");
writeDebug_(String("Output file type: ") + FileTypes::typeToName(out_type), 1);
//-------------------------------------------------------------
// reading input
//-------------------------------------------------------------
typedef MSExperiment<Peak1D> MSExperimentType;
MSExperimentType exp;
typedef MSExperimentType::SpectrumType SpectrumType;
typedef FeatureMap<> FeatureMapType;
FeatureMapType fm;
ConsensusMap cm;
writeDebug_(String("Loading input file"), 1);
if (in_type == FileTypes::CONSENSUSXML)
{
ConsensusXMLFile().load(in, cm);
cm.sortByPosition();
if ((out_type != FileTypes::FEATUREXML) &&
(out_type != FileTypes::CONSENSUSXML))
{
// You you will lose information and waste memory. Enough reasons to issue a warning!
writeLog_("Warning: Converting consensus features to peaks. You will lose information!");
exp.set2DData(cm);
}
}
else if (in_type == FileTypes::EDTA)
{
EDTAFile().load(in, cm);
cm.sortByPosition();
if ((out_type != FileTypes::FEATUREXML) &&
(out_type != FileTypes::CONSENSUSXML))
{
// You you will lose information and waste memory. Enough reasons to issue a warning!
writeLog_("Warning: Converting consensus features to peaks. You will lose information!");
exp.set2DData(cm);
}
}
else if (in_type == FileTypes::FEATUREXML ||
in_type == FileTypes::TSV ||
in_type == FileTypes::PEPLIST ||
in_type == FileTypes::KROENIK)
{
fh.loadFeatures(in, fm, in_type);
fm.sortByPosition();
if ((out_type != FileTypes::FEATUREXML) &&
(out_type != FileTypes::CONSENSUSXML))
{
// You will lose information and waste memory. Enough reasons to issue a warning!
writeLog_("Warning: Converting features to peaks. You will lose information! Mass traces are added, if present as 'num_of_masstraces' and 'masstrace_intensity_<X>' (X>=0) meta values.");
exp.set2DData<true>(fm);
}
}
else
{
fh.loadExperiment(in, exp, in_type, log_type_);
}
//-------------------------------------------------------------
// writing output
//-------------------------------------------------------------
writeDebug_(String("Writing output file"), 1);
if (out_type == FileTypes::MZML)
{
//add data processing entry
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
CONVERSION_MZML));
MzMLFile f;
f.setLogType(log_type_);
ChromatogramTools().convertSpectraToChromatograms(exp, true);
f.store(out, exp);
}
else if (out_type == FileTypes::MZDATA)
{
//annotate output with data processing info
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
CONVERSION_MZDATA));
MzDataFile f;
f.setLogType(log_type_);
ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp);
f.store(out, exp);
}
else if (out_type == FileTypes::MZXML)
{
//annotate output with data processing info
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
CONVERSION_MZXML));
MzXMLFile f;
f.setLogType(log_type_);
ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp);
f.store(out, exp);
}
else if (out_type == FileTypes::DTA2D)
{
//add data processing entry
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
DTA2DFile f;
f.setLogType(log_type_);
ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp);
if (TIC_DTA2D)
{
// store the total ion chromatogram (TIC)
f.storeTIC(out, exp);
}
else
{
// store entire experiment
f.store(out, exp);
}
}
else if (out_type == FileTypes::MGF)
{
//add data processing entry
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
MascotGenericFile f;
f.setLogType(log_type_);
f.store(out, exp);
}
else if (out_type == FileTypes::FEATUREXML)
{
if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) ||
(in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK))
{
fm.applyMemberFunction(&UniqueIdInterface::setUniqueId);
}
else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA)
{
ConsensusMap::convert(cm, true, fm);
}
else // not loaded as feature map or consensus map
{
// The feature specific information is only defaulted. Enough reasons to issue a warning!
writeLog_("Warning: Converting peaks to features will lead to incomplete features!");
fm.clear();
fm.reserve(exp.getSize());
typedef FeatureMapType::FeatureType FeatureType;
FeatureType feature;
feature.setQuality(0, 1); // override default
feature.setQuality(1, 1); // override default
feature.setOverallQuality(1); // override default
for (MSExperimentType::ConstIterator spec_iter = exp.begin();
spec_iter != exp.end();
++spec_iter
)
{
feature.setRT(spec_iter->getRT());
for (SpectrumType::ConstIterator peak1_iter = spec_iter->begin();
peak1_iter != spec_iter->end();
++peak1_iter
)
{
feature.setMZ(peak1_iter->getMZ());
feature.setIntensity(peak1_iter->getIntensity());
feature.setUniqueId();
fm.push_back(feature);
}
}
fm.updateRanges();
}
addDataProcessing_(fm, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
FeatureXMLFile().store(out, fm);
}
else if (out_type == FileTypes::CONSENSUSXML)
{
if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) ||
(in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK))
{
fm.applyMemberFunction(&UniqueIdInterface::setUniqueId);
ConsensusMap::convert(0, fm, cm);
}
// nothing to do for consensus input
else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA)
{
}
else // experimental data
{
ConsensusMap::convert(0, exp, cm, exp.size());
}
addDataProcessing_(cm, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
ConsensusXMLFile().store(out, cm);
}
else if (out_type == FileTypes::EDTA)
{
if (fm.size() > 0 && cm.size() > 0)
{
LOG_ERROR << "Internal error: cannot decide on container (Consensus or Feature)! This is a bug. Please report it!";
return INTERNAL_ERROR;
}
if (fm.size() > 0) EDTAFile().store(out, fm);
else if (cm.size() > 0) EDTAFile().store(out, cm);
}
else
{
writeLog_("Unknown output file type given. Aborting!");
printUsage_();
return ILLEGAL_PARAMETERS;
}
return EXECUTION_OK;
}
ExitCodes main_(int, const char**)
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
//input file names
String in = getStringOption_("in");
bool write_mzML_index = getFlag_("write_mzML_index");
//input file type
FileHandler fh;
FileTypes::Type in_type = FileTypes::nameToType(getStringOption_("in_type"));
if (in_type == FileTypes::UNKNOWN)
{
in_type = fh.getType(in);
writeDebug_(String("Input file type: ") + FileTypes::typeToName(in_type), 2);
}
if (in_type == FileTypes::UNKNOWN)
{
writeLog_("Error: Could not determine input file type!");
return PARSE_ERROR;
}
//output file names and types
String out = getStringOption_("out");
FileTypes::Type out_type = FileTypes::nameToType(getStringOption_("out_type"));
if (out_type == FileTypes::UNKNOWN)
{
out_type = fh.getTypeByFileName(out);
}
if (out_type == FileTypes::UNKNOWN)
{
writeLog_("Error: Could not determine output file type!");
return PARSE_ERROR;
}
bool TIC_DTA2D = getFlag_("TIC_DTA2D");
bool process_lowmemory = getFlag_("process_lowmemory");
writeDebug_(String("Output file type: ") + FileTypes::typeToName(out_type), 1);
String uid_postprocessing = getStringOption_("UID_postprocessing");
//-------------------------------------------------------------
// reading input
//-------------------------------------------------------------
typedef MSExperiment<Peak1D> MSExperimentType;
MSExperimentType exp;
typedef MSExperimentType::SpectrumType SpectrumType;
typedef FeatureMap FeatureMapType;
FeatureMapType fm;
ConsensusMap cm;
writeDebug_(String("Loading input file"), 1);
if (in_type == FileTypes::CONSENSUSXML)
{
ConsensusXMLFile().load(in, cm);
cm.sortByPosition();
if ((out_type != FileTypes::FEATUREXML) &&
(out_type != FileTypes::CONSENSUSXML))
{
// You you will lose information and waste memory. Enough reasons to issue a warning!
writeLog_("Warning: Converting consensus features to peaks. You will lose information!");
exp.set2DData(cm);
}
}
else if (in_type == FileTypes::EDTA)
{
EDTAFile().load(in, cm);
cm.sortByPosition();
if ((out_type != FileTypes::FEATUREXML) &&
(out_type != FileTypes::CONSENSUSXML))
{
// You you will lose information and waste memory. Enough reasons to issue a warning!
writeLog_("Warning: Converting consensus features to peaks. You will lose information!");
exp.set2DData(cm);
}
}
else if (in_type == FileTypes::FEATUREXML ||
in_type == FileTypes::TSV ||
in_type == FileTypes::PEPLIST ||
in_type == FileTypes::KROENIK)
{
fh.loadFeatures(in, fm, in_type);
fm.sortByPosition();
if ((out_type != FileTypes::FEATUREXML) &&
(out_type != FileTypes::CONSENSUSXML))
{
// You will lose information and waste memory. Enough reasons to issue a warning!
writeLog_("Warning: Converting features to peaks. You will lose information! Mass traces are added, if present as 'num_of_masstraces' and 'masstrace_intensity_<X>' (X>=0) meta values.");
exp.set2DData<true>(fm);
}
}
else if (process_lowmemory)
{
// Special switch for the low memory options:
// We can transform the complete experiment directly without first
// loading the complete data into memory. PlainMSDataWritingConsumer will
// write out mzML to disk as they are read from the input.
if (in_type == FileTypes::MZML && out_type == FileTypes::MZML)
{
PlainMSDataWritingConsumer consumer(out);
consumer.getOptions().setWriteIndex(write_mzML_index);
consumer.addDataProcessing(getProcessingInfo_(DataProcessing::CONVERSION_MZML));
MzMLFile mzmlfile;
mzmlfile.setLogType(log_type_);
mzmlfile.transform(in, &consumer);
return EXECUTION_OK;
}
else if (in_type == FileTypes::MZXML && out_type == FileTypes::MZML)
{
PlainMSDataWritingConsumer consumer(out);
consumer.getOptions().setWriteIndex(write_mzML_index);
consumer.addDataProcessing(getProcessingInfo_(DataProcessing::CONVERSION_MZML));
MzXMLFile mzxmlfile;
mzxmlfile.setLogType(log_type_);
mzxmlfile.transform(in, &consumer);
return EXECUTION_OK;
}
else
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Process_lowmemory option can only be used with mzML / mzXML input and mzML output data types.");
}
}
else
{
fh.loadExperiment(in, exp, in_type, log_type_);
}
//-------------------------------------------------------------
// writing output
//-------------------------------------------------------------
writeDebug_(String("Writing output file"), 1);
if (out_type == FileTypes::MZML)
{
//add data processing entry
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
CONVERSION_MZML));
MzMLFile f;
f.setLogType(log_type_);
f.getOptions().setWriteIndex(write_mzML_index);
ChromatogramTools().convertSpectraToChromatograms(exp, true);
f.store(out, exp);
}
else if (out_type == FileTypes::MZDATA)
{
//annotate output with data processing info
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
CONVERSION_MZDATA));
MzDataFile f;
f.setLogType(log_type_);
ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp);
f.store(out, exp);
}
else if (out_type == FileTypes::MZXML)
{
//annotate output with data processing info
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
CONVERSION_MZXML));
MzXMLFile f;
f.setLogType(log_type_);
ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp);
f.store(out, exp);
}
else if (out_type == FileTypes::DTA2D)
{
//add data processing entry
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
DTA2DFile f;
f.setLogType(log_type_);
ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp);
if (TIC_DTA2D)
{
// store the total ion chromatogram (TIC)
f.storeTIC(out, exp);
}
else
{
// store entire experiment
f.store(out, exp);
}
}
else if (out_type == FileTypes::MGF)
{
//add data processing entry
addDataProcessing_(exp, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
MascotGenericFile f;
f.setLogType(log_type_);
f.store(out, exp, getFlag_("MGF_compact"));
}
else if (out_type == FileTypes::FEATUREXML)
{
if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) ||
(in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK))
{
if (uid_postprocessing == "ensure")
{
fm.applyMemberFunction(&UniqueIdInterface::ensureUniqueId);
} else if (uid_postprocessing == "reassign")
{
fm.applyMemberFunction(&UniqueIdInterface::setUniqueId);
}
}
else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA)
{
MapConversion::convert(cm, true, fm);
}
else // not loaded as feature map or consensus map
{
// The feature specific information is only defaulted. Enough reasons to issue a warning!
writeLog_("Warning: Converting peaks to features will lead to incomplete features!");
fm.clear();
fm.reserve(exp.getSize());
typedef FeatureMapType::FeatureType FeatureType;
FeatureType feature;
feature.setQuality(0, 1); // override default
feature.setQuality(1, 1); // override default
feature.setOverallQuality(1); // override default
for (MSExperimentType::ConstIterator spec_iter = exp.begin();
spec_iter != exp.end();
++spec_iter
)
{
feature.setRT(spec_iter->getRT());
for (SpectrumType::ConstIterator peak1_iter = spec_iter->begin();
peak1_iter != spec_iter->end();
++peak1_iter
)
{
feature.setMZ(peak1_iter->getMZ());
feature.setIntensity(peak1_iter->getIntensity());
feature.setUniqueId();
fm.push_back(feature);
}
}
fm.updateRanges();
}
addDataProcessing_(fm, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
FeatureXMLFile().store(out, fm);
}
else if (out_type == FileTypes::CONSENSUSXML)
{
if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) ||
(in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK))
{
if (uid_postprocessing == "ensure")
{
fm.applyMemberFunction(&UniqueIdInterface::ensureUniqueId);
} else if (uid_postprocessing == "reassign")
{
fm.applyMemberFunction(&UniqueIdInterface::setUniqueId);
}
MapConversion::convert(0, fm, cm);
}
// nothing to do for consensus input
else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA)
{
}
else // experimental data
{
MapConversion::convert(0, exp, cm, exp.size());
}
addDataProcessing_(cm, getProcessingInfo_(DataProcessing::
FORMAT_CONVERSION));
ConsensusXMLFile().store(out, cm);
}
else if (out_type == FileTypes::EDTA)
{
if (fm.size() > 0 && cm.size() > 0)
{
LOG_ERROR << "Internal error: cannot decide on container (Consensus or Feature)! This is a bug. Please report it!";
return INTERNAL_ERROR;
}
if (fm.size() > 0) EDTAFile().store(out, fm);
else if (cm.size() > 0) EDTAFile().store(out, cm);
}
else if (out_type == FileTypes::CSV)
{
// as ibspectra is currently the only csv/text based format we assume
// that out_type == FileTypes::CSV means ibspectra, if more formats
// are added we need a more intelligent strategy to decide which
// conversion is requested
// IBSpectra selected as output type
if (in_type != FileTypes::CONSENSUSXML)
{
LOG_ERROR << "Incompatible input data: FileConverter can only convert consensusXML files to ibspectra format.";
return INCOMPATIBLE_INPUT_DATA;
}
IBSpectraFile ibfile;
ibfile.store(out, cm);
}
else
{
writeLog_("Unknown output file type given. Aborting!");
printUsage_();
return ILLEGAL_PARAMETERS;
}
return EXECUTION_OK;
}