本文整理汇总了C++中Tree::GetLeafId方法的典型用法代码示例。如果您正苦于以下问题:C++ Tree::GetLeafId方法的具体用法?C++ Tree::GetLeafId怎么用?C++ Tree::GetLeafId使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Tree
的用法示例。
在下文中一共展示了Tree::GetLeafId方法的8个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: SetClustalWWeights
void MSA::SetClustalWWeights(const Tree &tree)
{
const unsigned uSeqCount = GetSeqCount();
const unsigned uLeafCount = tree.GetLeafCount();
WEIGHT *Weights = new WEIGHT[uSeqCount];
CalcClustalWWeights(tree, Weights);
for (unsigned n = 0; n < uLeafCount; ++n)
{
const WEIGHT w = Weights[n];
const unsigned uLeafNodeIndex = tree.LeafIndexToNodeIndex(n);
const unsigned uId = tree.GetLeafId(uLeafNodeIndex);
const unsigned uSeqIndex = GetSeqIndex(uId);
#if DEBUG
if (GetSeqName(uSeqIndex) != tree.GetLeafName(uLeafNodeIndex))
Quit("MSA::SetClustalWWeights: names don't match");
#endif
SetSeqWeight(uSeqIndex, w);
}
NormalizeWeights((WEIGHT) 1.0);
delete[] Weights;
}
示例2: AlignSubFam
void AlignSubFam(SeqVect &vAll, const Tree &GuideTree, unsigned uNodeIndex,
MSA &msaOut)
{
const unsigned uSeqCount = vAll.GetSeqCount();
const char *InTmp = "asf_in.tmp";
const char *OutTmp = "asf_out.tmp";
unsigned *Leaves = new unsigned[uSeqCount];
unsigned uLeafCount;
GetLeaves(GuideTree, uNodeIndex, Leaves, &uLeafCount);
SeqVect v;
for (unsigned i = 0; i < uLeafCount; ++i)
{
unsigned uLeafNodeIndex = Leaves[i];
unsigned uId = GuideTree.GetLeafId(uLeafNodeIndex);
Seq &s = vAll.GetSeqById(uId);
v.AppendSeq(s);
}
#if TRACE
{
Log("Align subfam[node=%d, size=%d] ", uNodeIndex, uLeafCount);
for (unsigned i = 0; i < uLeafCount; ++i)
Log(" %s", v.GetSeqName(i));
Log("\n");
}
#endif
TextFile fIn(InTmp, true);
v.ToFASTAFile(fIn);
fIn.Close();
char CmdLine[4096];
sprintf(CmdLine, "probcons %s > %s 2> /dev/null", InTmp, OutTmp);
// sprintf(CmdLine, "muscle -in %s -out %s -maxiters 1", InTmp, OutTmp);
system(CmdLine);
TextFile fOut(OutTmp);
msaOut.FromFile(fOut);
for (unsigned uSeqIndex = 0; uSeqIndex < uLeafCount; ++uSeqIndex)
{
const char *Name = msaOut.GetSeqName(uSeqIndex);
unsigned uId = vAll.GetSeqIdFromName(Name);
msaOut.SetSeqId(uSeqIndex, uId);
}
unlink(InTmp);
unlink(OutTmp);
delete[] Leaves;
}
示例3: BuildDiffs
static void BuildDiffs(const Tree &tree, unsigned uTreeNodeIndex,
const bool bIsDiff[], Tree &Diffs, unsigned uDiffsNodeIndex,
unsigned IdToDiffsLeafNodeIndex[])
{
#if TRACE
Log("BuildDiffs(TreeNode=%u IsDiff=%d IsLeaf=%d)\n",
uTreeNodeIndex, bIsDiff[uTreeNodeIndex], tree.IsLeaf(uTreeNodeIndex));
#endif
if (bIsDiff[uTreeNodeIndex])
{
unsigned uLeafCount = tree.GetLeafCount();
unsigned *Leaves = new unsigned[uLeafCount];
GetLeaves(tree, uTreeNodeIndex, Leaves, &uLeafCount);
for (unsigned n = 0; n < uLeafCount; ++n)
{
const unsigned uLeafNodeIndex = Leaves[n];
const unsigned uId = tree.GetLeafId(uLeafNodeIndex);
if (uId >= tree.GetLeafCount())
Quit("BuildDiffs, id out of range");
IdToDiffsLeafNodeIndex[uId] = uDiffsNodeIndex;
#if TRACE
Log(" Leaf id=%u DiffsNode=%u\n", uId, uDiffsNodeIndex);
#endif
}
delete[] Leaves;
return;
}
if (tree.IsLeaf(uTreeNodeIndex))
Quit("BuildDiffs: should never reach leaf");
const unsigned uTreeLeft = tree.GetLeft(uTreeNodeIndex);
const unsigned uTreeRight = tree.GetRight(uTreeNodeIndex);
const unsigned uDiffsLeft = Diffs.AppendBranch(uDiffsNodeIndex);
const unsigned uDiffsRight = uDiffsLeft + 1;
BuildDiffs(tree, uTreeLeft, bIsDiff, Diffs, uDiffsLeft, IdToDiffsLeafNodeIndex);
BuildDiffs(tree, uTreeRight, bIsDiff, Diffs, uDiffsRight, IdToDiffsLeafNodeIndex);
}
示例4: MakeRootMSA
void MakeRootMSA(const SeqVect &v, const Tree &GuideTree, ProgNode Nodes[],
MSA &a)
{
#if TRACE
Log("MakeRootMSA Tree=");
GuideTree.LogMe();
#endif
const unsigned uSeqCount = v.GetSeqCount();
unsigned uColCount = uInsane;
unsigned uSeqIndex = 0;
const unsigned uTreeNodeCount = GuideTree.GetNodeCount();
const unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex();
const PWPath &RootPath = Nodes[uRootNodeIndex].m_Path;
const unsigned uRootColCount = RootPath.GetEdgeCount();
const unsigned uEstringSize = uRootColCount + 1;
short *Estring1 = new short[uEstringSize];
short *Estring2 = new short[uEstringSize];
SetProgressDesc("Root alignment");
unsigned uTreeNodeIndex = GetFirstNodeIndex(GuideTree);
do
{
Progress(uSeqIndex, uSeqCount);
unsigned uId = GuideTree.GetLeafId(uTreeNodeIndex);
const Seq &s = *(v[uId]);
Seq sRootE;
short *es = MakeRootSeqE(s, GuideTree, uTreeNodeIndex, Nodes, sRootE,
Estring1, Estring2);
Nodes[uTreeNodeIndex].m_EstringL = EstringNewCopy(es);
#if VALIDATE
Seq sRoot;
MakeRootSeq(s, GuideTree, uTreeNodeIndex, Nodes, sRoot);
if (!sRoot.Eq(sRootE))
{
Log("sRoot=");
sRoot.LogMe();
Log("sRootE=");
sRootE.LogMe();
Quit("Root seqs differ");
}
#if TRACE
Log("MakeRootSeq=\n");
sRoot.LogMe();
#endif
#endif
if (uInsane == uColCount)
{
uColCount = sRootE.Length();
a.SetSize(uSeqCount, uColCount);
}
else
{
assert(uColCount == sRootE.Length());
}
a.SetSeqName(uSeqIndex, s.GetName());
a.SetSeqId(uSeqIndex, uId);
for (unsigned uColIndex = 0; uColIndex < uColCount; ++uColIndex)
a.SetChar(uSeqIndex, uColIndex, sRootE[uColIndex]);
++uSeqIndex;
uTreeNodeIndex = GetNextNodeIndex(GuideTree, uTreeNodeIndex);
}
while (NULL_NEIGHBOR != uTreeNodeIndex);
delete[] Estring1;
delete[] Estring2;
ProgressStepsDone();
assert(uSeqIndex == uSeqCount);
}
示例5: LeafIndexesToIds
void LeafIndexesToIds(const Tree &tree, const unsigned Leaves[], unsigned uCount,
unsigned Ids[])
{
for (unsigned n = 0; n < uCount; ++n)
Ids[n] = tree.GetLeafId(Leaves[n]);
}
示例6: DiffTreesE
void DiffTreesE(const Tree &NewTree, const Tree &OldTree,
unsigned NewNodeIndexToOldNodeIndex[])
{
#if TRACE
Log("DiffTreesE NewTree:\n");
NewTree.LogMe();
Log("\n");
Log("OldTree:\n");
OldTree.LogMe();
#endif
if (!NewTree.IsRooted() || !OldTree.IsRooted())
Quit("DiffTrees: requires rooted trees");
const unsigned uNodeCount = NewTree.GetNodeCount();
const unsigned uOldNodeCount = OldTree.GetNodeCount();
const unsigned uLeafCount = NewTree.GetLeafCount();
const unsigned uOldLeafCount = OldTree.GetLeafCount();
if (uNodeCount != uOldNodeCount || uLeafCount != uOldLeafCount)
Quit("DiffTreesE: different node counts");
{
unsigned *IdToOldNodeIndex = new unsigned[uNodeCount];
for (unsigned uOldNodeIndex = 0; uOldNodeIndex < uNodeCount; ++uOldNodeIndex)
{
if (OldTree.IsLeaf(uOldNodeIndex))
{
unsigned Id = OldTree.GetLeafId(uOldNodeIndex);
IdToOldNodeIndex[Id] = uOldNodeIndex;
}
}
// Initialize NewNodeIndexToOldNodeIndex[]
// All internal nodes are marked as changed, but may be updated later.
for (unsigned uNewNodeIndex = 0; uNewNodeIndex < uNodeCount; ++uNewNodeIndex)
{
if (NewTree.IsLeaf(uNewNodeIndex))
{
unsigned uId = NewTree.GetLeafId(uNewNodeIndex);
assert(uId < uLeafCount);
unsigned uOldNodeIndex = IdToOldNodeIndex[uId];
assert(uOldNodeIndex < uNodeCount);
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = uOldNodeIndex;
}
else
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = NODE_CHANGED;
}
delete[] IdToOldNodeIndex;
}
// Depth-first traversal of tree.
// The order guarantees that a node is visited before
// its parent is visited.
for (unsigned uNewNodeIndex = NewTree.FirstDepthFirstNode();
NULL_NEIGHBOR != uNewNodeIndex;
uNewNodeIndex = NewTree.NextDepthFirstNode(uNewNodeIndex))
{
if (NewTree.IsLeaf(uNewNodeIndex))
continue;
// If either child is changed, flag this node as changed and continue.
unsigned uNewLeft = NewTree.GetLeft(uNewNodeIndex);
unsigned uOldLeft = NewNodeIndexToOldNodeIndex[uNewLeft];
if (NODE_CHANGED == uOldLeft)
{
NewNodeIndexToOldNodeIndex[uNewLeft] = NODE_CHANGED;
continue;
}
unsigned uNewRight = NewTree.GetRight(uNewNodeIndex);
unsigned uOldRight = NewNodeIndexToOldNodeIndex[uNewRight];
if (NODE_CHANGED == NewNodeIndexToOldNodeIndex[uNewRight])
{
NewNodeIndexToOldNodeIndex[uNewRight] = NODE_CHANGED;
continue;
}
unsigned uOldParentLeft = OldTree.GetParent(uOldLeft);
unsigned uOldParentRight = OldTree.GetParent(uOldRight);
if (uOldParentLeft == uOldParentRight)
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = uOldParentLeft;
else
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = NODE_CHANGED;
}
#if TRACE
{
Log("NewToOld ");
for (unsigned uNewNodeIndex = 0; uNewNodeIndex < uNodeCount; ++uNewNodeIndex)
{
Log(" [%3u]=", uNewNodeIndex);
if (NODE_CHANGED == NewNodeIndexToOldNodeIndex[uNewNodeIndex])
Log(" X");
else
Log("%3u", NewNodeIndexToOldNodeIndex[uNewNodeIndex]);
if ((uNewNodeIndex+1)%8 == 0)
Log("\n ");
}
//.........这里部分代码省略.........
示例7: ProgressiveAlign
void ProgressiveAlign(const SeqVect &v, const Tree &GuideTree, MSA &a)
{
assert(GuideTree.IsRooted());
#if TRACE
Log("GuideTree:\n");
GuideTree.LogMe();
#endif
const unsigned uSeqCount = v.Length();
const unsigned uNodeCount = 2*uSeqCount - 1;
ProgNode *ProgNodes = new ProgNode[uNodeCount];
unsigned uJoin = 0;
unsigned uTreeNodeIndex = GuideTree.FirstDepthFirstNode();
SetProgressDesc("Align node");
do
{
if (GuideTree.IsLeaf(uTreeNodeIndex))
{
if (uTreeNodeIndex >= uNodeCount)
Quit("TreeNodeIndex=%u NodeCount=%u\n", uTreeNodeIndex, uNodeCount);
ProgNode &Node = ProgNodes[uTreeNodeIndex];
unsigned uId = GuideTree.GetLeafId(uTreeNodeIndex);
if (uId >= uSeqCount)
Quit("Seq index out of range");
const Seq &s = *(v[uId]);
Node.m_MSA.FromSeq(s);
Node.m_MSA.SetSeqId(0, uId);
Node.m_uLength = Node.m_MSA.GetColCount();
}
else
{
Progress(uJoin, uSeqCount - 1);
++uJoin;
const unsigned uMergeNodeIndex = uTreeNodeIndex;
ProgNode &Parent = ProgNodes[uMergeNodeIndex];
const unsigned uLeft = GuideTree.GetLeft(uTreeNodeIndex);
const unsigned uRight = GuideTree.GetRight(uTreeNodeIndex);
ProgNode &Node1 = ProgNodes[uLeft];
ProgNode &Node2 = ProgNodes[uRight];
PWPath Path;
AlignTwoMSAs(Node1.m_MSA, Node2.m_MSA, Parent.m_MSA, Path);
Parent.m_uLength = Parent.m_MSA.GetColCount();
Node1.m_MSA.Clear();
Node2.m_MSA.Clear();
}
uTreeNodeIndex = GuideTree.NextDepthFirstNode(uTreeNodeIndex);
}
while (NULL_NEIGHBOR != uTreeNodeIndex);
ProgressStepsDone();
unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex();
const ProgNode &RootProgNode = ProgNodes[uRootNodeIndex];
a.Copy(RootProgNode.m_MSA);
delete[] ProgNodes;
ProgNodes = 0;
}
示例8: DiffTrees
void DiffTrees(const Tree &Tree1, const Tree &Tree2, Tree &Diffs,
unsigned IdToDiffsLeafNodeIndex[])
{
#if TRACE
Log("Tree1:\n");
Tree1.LogMe();
Log("\n");
Log("Tree2:\n");
Tree2.LogMe();
#endif
if (!Tree1.IsRooted() || !Tree2.IsRooted())
Quit("DiffTrees: requires rooted trees");
const unsigned uNodeCount = Tree1.GetNodeCount();
const unsigned uNodeCount2 = Tree2.GetNodeCount();
const unsigned uLeafCount = Tree1.GetLeafCount();
const unsigned uLeafCount2 = Tree2.GetLeafCount();
assert(uLeafCount == uLeafCount2);
if (uNodeCount != uNodeCount2)
Quit("DiffTrees: different node counts");
// Allocate tables so we can convert tree node index to
// and from the unique id with a O(1) lookup.
unsigned *NodeIndexToId1 = new unsigned[uNodeCount];
unsigned *IdToNodeIndex2 = new unsigned[uNodeCount];
bool *bIsBachelor1 = new bool[uNodeCount];
bool *bIsDiff1 = new bool[uNodeCount];
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
NodeIndexToId1[uNodeIndex] = uNodeCount;
bIsBachelor1[uNodeIndex] = false;
bIsDiff1[uNodeIndex] = false;
// Use uNodeCount as value meaning "not set".
IdToNodeIndex2[uNodeIndex] = uNodeCount;
}
// Initialize node index <-> id lookup tables
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (Tree1.IsLeaf(uNodeIndex))
{
const unsigned uId = Tree1.GetLeafId(uNodeIndex);
if (uId >= uNodeCount)
Quit("Diff trees requires existing leaf ids in range 0 .. (N-1)");
NodeIndexToId1[uNodeIndex] = uId;
}
if (Tree2.IsLeaf(uNodeIndex))
{
const unsigned uId = Tree2.GetLeafId(uNodeIndex);
if (uId >= uNodeCount)
Quit("Diff trees requires existing leaf ids in range 0 .. (N-1)");
IdToNodeIndex2[uId] = uNodeIndex;
}
}
// Validity check. This verifies that the ids
// pre-assigned to the leaves in Tree1 are unique
// (note that the id<N check above does not rule
// out two leaves having duplicate ids).
for (unsigned uId = 0; uId < uLeafCount; ++uId)
{
unsigned uNodeIndex2 = IdToNodeIndex2[uId];
if (uNodeCount == uNodeIndex2)
Quit("DiffTrees, check 2");
}
// Ids assigned to internal nodes are N, N+1 ...
// An internal node id uniquely identifies a set
// of two or more leaves.
unsigned uInternalNodeId = uLeafCount;
// Depth-first traversal of tree.
// The order guarantees that a node is visited before
// its parent is visited.
for (unsigned uNodeIndex1 = Tree1.FirstDepthFirstNode();
NULL_NEIGHBOR != uNodeIndex1;
uNodeIndex1 = Tree1.NextDepthFirstNode(uNodeIndex1))
{
#if TRACE
Log("Main loop: Node1=%u IsLeaf=%d IsBachelor=%d\n",
uNodeIndex1,
Tree1.IsLeaf(uNodeIndex1),
bIsBachelor1[uNodeIndex1]);
#endif
// Leaves are trivial; nothing to do.
if (Tree1.IsLeaf(uNodeIndex1) || bIsBachelor1[uNodeIndex1])
continue;
// If either child is a bachelor, flag
// this node as a bachelor and continue.
unsigned uLeft1 = Tree1.GetLeft(uNodeIndex1);
if (bIsBachelor1[uLeft1])
//.........这里部分代码省略.........