void writeAsNexus(PublicNexusReader & nexusReader, ostream & os) {
BlockReaderList blocks = nexusReader.GetUsedBlocksInOrder();
os << "#NEXUS\n";
for (BlockReaderList::const_iterator bIt = blocks.begin(); bIt != blocks.end(); ++bIt) {
NxsBlock * b = *bIt;
if (b)
b->WriteAsNexus(os);
}
}
////////////////////////////////////////////////////////////////////////////////
// Takes NxsReader that has successfully read a file, and processes the
// information stored in the reader.
//
// The caller is responsibel for calling DeleteBlocksFromFactories() to clean
// up (if the reader uses the factory API).
////////////////////////////////////////////////////////////////////////////////
void processContent(PublicNexusReader & nexusReader, ostream *out)
{
if (!out)
return;
BlockReaderList blocks = nexusReader.GetUsedBlocksInOrder();
*out << "#NEXUS\n";
for (BlockReaderList::const_iterator bIt = blocks.begin(); bIt != blocks.end(); ++bIt)
{
NxsBlock * b = *bIt;
if (b->GetID() == "TAXA")
b->WriteAsNexus(*out);
}
TreesToSplits::TaxaBlockToSplitsMap::const_iterator tbtsm = gTreesToSplitsB->taxaBlockToSplitsMap.begin();
for (; tbtsm != gTreesToSplitsB->taxaBlockToSplitsMap.end(); ++tbtsm) {
*out << "Begin Trees;\n";
NxsTaxaBlockAPI * tb = tbtsm->first;
if (tb && gTreesToSplitsB->taxaBlockToSplitsMap.size() > 1)
*out << "Link Taxa = " << NxsString::GetEscaped(tb->GetTitle()) << ";\n";
writeTranslateCommand(tb, *out);
const TreesToSplits::NTreesSplitsMap & ntsm = tbtsm->second;
const unsigned nt = ntsm.first;
const TreesToSplits::SplitsMap & sm = ntsm.second;
unsigned n = 1;
writeStarTreeCommand(tb, *out);
for (TreesToSplits::SplitsMap::const_iterator smIt = sm.begin(); smIt != sm.end(); ++smIt, ++n) {
const SplitInfo & si = smIt->second;
*out << "Tree split_" << n << " = " << " [&";
*out << (gTreesToSplitsB->treatAsRooted ? 'R' : 'U');
*out << "] [";
if (gTreesToSplitsB->trackFreq || gTreesToSplitsB->trackEdgeLenSummary || gTreesToSplitsB->trackEdgeLen)
*out << "&W " << ((double)si.nTimes)/((double)nt) << " ] [";
if (gTreesToSplitsB->trackHeightSummary) {
*out << "meanH =" << ((double)si.heightSum)/((double)si.nTimes);
}
*out << "] ";
if (gTreesToSplitsB->trackEdgeLenSummary)
smIt->first.writeNewick(*out, si.edgeLenSum/((double)si.nTimes), true);
else
smIt->first.writeNewick(*out, true);
*out << ";\n";
}
*out << "End;\n";
}
}
////////////////////////////////////////////////////////////////////////////////
// Takes NxsReader that has successfully read a file, and processes the
// information stored in the reader.
//
// The caller is responsibel for calling DeleteBlocksFromFactories() to clean
// up (if the reader uses the factory API).
////////////////////////////////////////////////////////////////////////////////
void processContent(PublicNexusReader & nexusReader, ostream *out)
{
if (!out)
return;
BlockReaderList blocks = nexusReader.GetUsedBlocksInOrder();
*out << "#NEXUS\n";
for (BlockReaderList::const_iterator bIt = blocks.begin(); bIt != blocks.end(); ++bIt)
{
NxsBlock * b = *bIt;
if (b->GetID() == "TAXA")
b->WriteAsNexus(*out);
else if (b->GetID() == "CHARACTERS" || b->GetID() == "DATA" )
{
NxsCharactersBlock * charactersBPtr = (NxsCharactersBlock *) b;
writeCharactersAsGapped(*out, charactersBPtr);
}
}
}
int processContent(PublicNexusReader & nexusReader,
const char *gFilename,
std::ostream *os,
INIReader & iniReader) {
BlockReaderList blocks = nexusReader.GetUsedBlocksInOrder();
if (blocks.size() == 0) {
cerr << "Error:\n No understandable content was found.\n";
exit(1);
}
const unsigned numTaxaBlocks = nexusReader.GetNumTaxaBlocks();
if (numTaxaBlocks != 1) {
std::cerr << "Expecting a file with exactly 1 TAXA block, but found " << numTaxaBlocks << " in the file " << gFilename << ".\n";
return 2;
}
NxsTaxaBlock * taxaBlock = nexusReader.GetTaxaBlock(0);
const unsigned nCharBlocks = nexusReader.GetNumCharactersBlocks(taxaBlock);
if (nCharBlocks != 1) {
std::cerr << "Expecting a file with exactly 1 CHARACTERS/DATA block, but found " << nCharBlocks << " in the file " << gFilename << ".\n";
return 3;
}
const unsigned nTreesBlocks = nexusReader.GetNumTreesBlocks(taxaBlock);
if (nTreesBlocks != 1) {
std::cerr << "Expecting a file with exactly 1 TREES block, but found " << nTreesBlocks << " in the file " << gFilename << ".\n";
return 3;
}
const NxsCharactersBlock * charBlock = nexusReader.GetCharactersBlock(taxaBlock, 0);
std::vector<const NxsDiscreteDatatypeMapper *> mappers = charBlock->GetAllDatatypeMappers();
if (mappers.size() != 1) {
std::cerr << "Expecting an unmixed characters block, but found a matrix with datatype = mixed or a datatype with augmented symbols\n";
return 4;
}
const NxsDiscreteDatatypeMapper * dm = mappers[0];
ScopedTwoDMatrix<NxsCDiscreteStateSet> compressedMatrix;
std::vector<unsigned> patternCounts;
std::vector<double> patternWeights;
bool hasWeights = true;
std::vector<NxsCharacterPattern> compressedTransposedMatrix;
std::vector<std::set<unsigned> > compressedIndexToOriginal;
std::vector<int> originalIndexToCompressed;
if (true) {
if (true) {
NxsCXXDiscreteMatrix cxxMat(*charBlock, false, 0L, false);
hasWeights = cxxMat.hasWeights();
NxsCompressDiscreteMatrix(cxxMat, compressedTransposedMatrix, &originalIndexToCompressed, &compressedIndexToOriginal);
}
std::vector<double> * wtsPtr = (hasWeights ? &patternWeights : 0L);
NxsTransposeCompressedMatrix(compressedTransposedMatrix, compressedMatrix, &patternCounts, wtsPtr);
patternWeights.clear();
for (auto i : patternCounts) {
patternWeights.push_back(double(i));
}
}
_DEBUG_VEC(patternWeights);
NxsCDiscreteStateSet ** matrixAlias = compressedMatrix.GetAlias();
const unsigned ntaxTotal = charBlock->GetNTaxTotal();
const NxsTreesBlock * treesBlock = nexusReader.GetTreesBlock(taxaBlock, 0);
//mt::ModelDescription md(mt::ModelDescription::VAR_ONLY_NO_MISSING_ASC_BIAS); //@TODO should be run-time setting
mt::ModelDescription md(mt::ModelDescription::NO_ASC_BIAS); //@TODO should be run-time setting
mt::NCL2MT ncl2mt;
for (unsigned nti = 0; nti < treesBlock->GetNumTrees(); ++nti) {
const NxsSimpleTree nst(treesBlock->GetFullTreeDescription(nti), 1, 0.1, true);
ncl2mt.processTree(os,
ntaxTotal,
charBlock,
dm,
(const NxsCDiscreteStateSet **) matrixAlias,
patternWeights,
originalIndexToCompressed,
nst,
md,
iniReader);
}
return 0;
}
void exportTrees(
PublicNexusReader & nexusReader,
MultiFormatReader::DataFormatType f,
std::string prefix,
std::ostream * fp)
{
std::ostream * fpToUse = fp;
const unsigned nTaxaBlocks = nexusReader.GetNumTaxaBlocks();
for (unsigned t = 0; t < nTaxaBlocks; ++t)
{
const NxsTaxaBlock * tb = nexusReader.GetTaxaBlock(t);
const unsigned nTreesBlocks = nexusReader.GetNumTreesBlocks(tb);
if (nTreesBlocks == 0)
continue;
NxsString tbSpecificPrefix;
if (t > 0)
tbSpecificPrefix << (1 + t);
tbSpecificPrefix << prefix;
std::vector<std::string> namesToPrint(tb->GetAllLabels());
std::vector<NxsNameToNameTrans> nameTrans = nameTranslationDict(namesToPrint, f);
if (!nameTrans.empty())
{
namesToPrint.clear();
for (std::vector<NxsNameToNameTrans>::const_iterator nIt = nameTrans.begin(); nIt != nameTrans.end(); ++nIt)
namesToPrint.push_back(nIt->second);
if (nexusReader.conversionOutputRecord.writeNameTranslationFile)
nexusReader.conversionOutputRecord.writeNameTranslation(nameTrans, tb);
}
for (unsigned i = 0; i < nTreesBlocks; ++i)
{
NxsString fn = tbSpecificPrefix;
if (i > 0)
fn << (1 + i);
fn << getFileExtension(f);
const NxsTreesBlock * trb = nexusReader.GetTreesBlock(tb, i);
ofstream outf;
if (fp == 0L)
{
openOrThrow(outf, fn);
fpToUse = &outf;
}
trb->ProcessAllTrees();
for (unsigned j = 0; j < trb->GetNumTrees(); ++j)
{
const NxsFullTreeDescription & ftd = trb->GetFullTreeDescription(j);
NxsSimpleTree tree(ftd, -1, -1.0);
std::vector<NxsSimpleNode *> & leaves = tree.GetLeavesRef();
for (std::vector<NxsSimpleNode *>::const_iterator leafIt = leaves.begin(); leafIt != leaves.end(); ++leafIt)
{
NxsSimpleNode * leaf = *leafIt;
if (leaf)
{
const std::string name = namesToPrint[leaf->GetTaxonIndex()];
if (!gQuietMode)
std::cerr << "Setting name=" << name << '\n';
leaf->SetName(name);
}
}
tree.WriteAsNewick(*fpToUse, true, true, false, tb, true);
*fpToUse << ";\n";
}
}
}
}
void exportCharacters(
PublicNexusReader & nexusReader,
MultiFormatReader::DataFormatType f,
long interleaveLen,
std::string prefix,
std::ostream * fp)
{
std::ostream * fpToUse = fp;
const unsigned nTaxaBlocks = nexusReader.GetNumTaxaBlocks();
for (unsigned t = 0; t < nTaxaBlocks; ++t)
{
const NxsTaxaBlock * tb = nexusReader.GetTaxaBlock(t);
const unsigned nCharBlocks = nexusReader.GetNumCharactersBlocks(tb);
if (nCharBlocks == 0)
continue;
NxsString tbSpecificPrefix;
if (t > 0)
tbSpecificPrefix << (1 + t);
tbSpecificPrefix << prefix;
typedef std::pair<const NxsCharactersBlock *, std::string> PairCBAndString;
typedef std::vector< PairCBAndString > VecPairCBAndString;
VecPairCBAndString cbToWrite;
for (unsigned i = 0; i < nCharBlocks; ++i)
{
NxsString fn = tbSpecificPrefix;
if (i > 0)
fn << (1 + i);
fn << getFileExtension(f);
const NxsCharactersBlock * cb = nexusReader.GetCharactersBlock(tb, i);
NxsCharactersBlock::DataTypesEnum dt = cb->GetDataType();
bool writeBlock = false;
if ((dt == NxsCharactersBlock::standard)
&& (f == MultiFormatReader::PHYLIP_DISC_FORMAT
|| f == MultiFormatReader::INTERLEAVED_PHYLIP_DISC_FORMAT
|| f == MultiFormatReader::RELAXED_PHYLIP_DISC_FORMAT
|| f == MultiFormatReader::INTERLEAVED_RELAXED_PHYLIP_DISC_FORMAT))
writeBlock = true;
else if ((dt == NxsCharactersBlock::dna || dt == NxsCharactersBlock::nucleotide)
&& (f == MultiFormatReader::PHYLIP_DNA_FORMAT
|| f == MultiFormatReader::INTERLEAVED_PHYLIP_DNA_FORMAT
|| f == MultiFormatReader::FASTA_DNA_FORMAT
|| f == MultiFormatReader::RELAXED_PHYLIP_DNA_FORMAT
|| f == MultiFormatReader::INTERLEAVED_RELAXED_PHYLIP_DNA_FORMAT))
writeBlock = true;
else if ((dt == NxsCharactersBlock::rna)
&& (f == MultiFormatReader::PHYLIP_RNA_FORMAT
|| f == MultiFormatReader::INTERLEAVED_PHYLIP_RNA_FORMAT
|| f == MultiFormatReader::FASTA_RNA_FORMAT
|| f == MultiFormatReader::RELAXED_PHYLIP_RNA_FORMAT
|| f == MultiFormatReader::INTERLEAVED_RELAXED_PHYLIP_RNA_FORMAT))
writeBlock = true;
else if ((dt == NxsCharactersBlock::protein)
&& (f == MultiFormatReader::PHYLIP_AA_FORMAT
|| f == MultiFormatReader::INTERLEAVED_PHYLIP_AA_FORMAT
|| f == MultiFormatReader::FASTA_AA_FORMAT
|| f == MultiFormatReader::RELAXED_PHYLIP_AA_FORMAT
|| f == MultiFormatReader::INTERLEAVED_RELAXED_PHYLIP_AA_FORMAT))
writeBlock = true;
if (writeBlock)
cbToWrite.push_back(std::pair<const NxsCharactersBlock *, std::string>(cb, fn));
}
if (!cbToWrite.empty())
{
std::vector<std::string> namesToPrint(tb->GetAllLabels());
std::vector<NxsNameToNameTrans> nameTrans = nameTranslationDict(namesToPrint, f);
if (!nameTrans.empty())
{
namesToPrint.clear();
for (std::vector<NxsNameToNameTrans>::const_iterator nIt = nameTrans.begin(); nIt != nameTrans.end(); ++nIt)
namesToPrint.push_back(nIt->second);
if (nexusReader.conversionOutputRecord.writeNameTranslationFile)
nexusReader.conversionOutputRecord.writeNameTranslation(nameTrans, tb);
}
for (VecPairCBAndString::const_iterator vIt = cbToWrite.begin(); vIt != cbToWrite.end(); ++vIt)
{
const NxsCharactersBlock * cbP = vIt->first;
std::string fn = vIt->second;
ofstream outf;
if (fp == 0L)
{
openOrThrow(outf, fn);
fpToUse = &outf;
}
writeCharactersBlockToStream(*cbP, *fpToUse, namesToPrint, f, interleaveLen);
}
}
}
}
bool substituteSafeTaxaLabels(PublicNexusReader &nexusReader, std::string filepath, bool evenTrivial)
{
std::ostream * outStrPtr = 0L;
std::ofstream outStream;
const unsigned nTaxaBlocks = nexusReader.GetNumTaxaBlocks();
bool someChanged = false;
std::set<std::string> safeNameSet;
try
{
for (unsigned t = 0; t < nTaxaBlocks; ++t)
{
NxsTaxaBlock * tb = nexusReader.GetTaxaBlock(t);
std::vector<std::string> safeLabelsVec;
bool changed = constructSafeLabels(*tb, &safeLabelsVec, safeNameSet);
someChanged = someChanged | changed;
if (changed || evenTrivial)
{
if (outStrPtr == 0L)
{
outStream.open(filepath.c_str());
if (!outStream.good())
{
NxsString eMessage;
eMessage << "Could not open the file \"" << filepath << "\"";
throw NxsException(eMessage);
}
outStrPtr = &outStream;
outStream << "#NEXUS\n";
}
tb->WriteAsNexus(*outStrPtr);
std::vector<NxsString> oldNameVec;
const unsigned numTaxa = tb->GetNTaxTotal();
for (unsigned i = 0; i < numTaxa; ++i)
{
NxsString oldName = tb->GetTaxonLabel(i);
oldNameVec.push_back(oldName);
NxsString newName;
newName << safeLabelsVec[i];
tb->ChangeTaxonLabel(i, newName);
}
NxsString title;
title << tb->GetTitle();
NxsString nt;
nt << "Renamed " << title;
tb->SetTitle(nt, false);
tb->WriteAsNexus(*outStrPtr);
// We can't just create a TaxaAssociationBlock instance here,
// and call WriteAsNexus because it first and second taxa block pointers
// would refer to the same instance...
NxsString taTitle;
taTitle << "Renaming " << title;
*outStrPtr << "BEGIN TaxaAssociation;\n Title " << NxsString::GetEscaped(taTitle) << " ;\n";
*outStrPtr << " Taxa " << NxsString::GetEscaped(title) << " , " << NxsString::GetEscaped(nt) << " ;\n";
*outStrPtr << " Associates ";
for (unsigned i = 0; i < numTaxa; ++i)
{
if (i > 0)
*outStrPtr << " ,\n ";
*outStrPtr << NxsString::GetEscaped(oldNameVec[i]) << " / " << NxsString::GetEscaped(safeLabelsVec[i]);
}
*outStrPtr << " ;\nEND;\n" ;
}
}
}
catch (...)
{
if (outStrPtr != 0L)
outStream.close();
throw;
}
if (outStrPtr != 0L)
outStream.close();
return someChanged;
}
////////////////////////////////////////////////////////////////////////////////
// Takes NxsReader that has successfully read a file, and processes the
// information stored in the reader.
//
// The caller is responsibel for calling DeleteBlocksFromFactories() to clean
// up (if the reader uses the factory API).
////////////////////////////////////////////////////////////////////////////////
void processContent(PublicNexusReader & nexusReader, ostream *os, ProcessActionsEnum currentAction) {
BlockReaderList blocks = nexusReader.GetUsedBlocksInOrder();
writeAsNexus(nexusReader, *os);
}
