import java.util.Collections;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
+
+import org.forester.phylogeny.Phylogeny;
+import org.forester.phylogeny.PhylogenyNode;
+import org.forester.phylogeny.iterators.PhylogenyNodeIterator;
/**
* Routines for manipulating the order of a multiple sequence alignment TODO:
static TreeModel lastTree = null;
+ static Phylogeny lastAptxTree = null;
+
static boolean sortTreeAscending = true;
/*
true);
for (int i = 0; i < nSeq; i++)
{
- scores[i] = (float) PIDModel.computePID(align.getSequenceAt(i)
- .getSequenceAsString(), refSeq, pidParams);
+ scores[i] = (float) PIDModel.computePID(
+ align.getSequenceAt(i).getSequenceAsString(), refSeq,
+ pidParams);
seqs[i] = align.getSequenceAt(i);
}
List<SequenceI> algn;
synchronized (algn = align.getSequences())
{
- List<SequenceI> tmp = new ArrayList<SequenceI>();
+ List<SequenceI> tmp = new ArrayList<>();
for (int i = 0; i < seqs.length; i++)
{
{
// MAINTAINS ORIGNAL SEQUENCE ORDER,
// ORDERS BY GROUP SIZE
- List<SequenceGroup> groups = new ArrayList<SequenceGroup>();
+ List<SequenceGroup> groups = new ArrayList<>();
if (groups.hashCode() != lastGroupHash)
{
// NOW ADD SEQUENCES MAINTAINING ALIGNMENT ORDER
// /////////////////////////////////////////////
- List<SequenceI> seqs = new ArrayList<SequenceI>();
+ List<SequenceI> seqs = new ArrayList<>();
for (int i = 0; i < groups.size(); i++)
{
// tmp2 = tmp.retainAll(mask);
// return tmp2.addAll(mask.removeAll(tmp2))
- ArrayList<SequenceI> seqs = new ArrayList<SequenceI>();
+ ArrayList<SequenceI> seqs = new ArrayList<>();
int i, idx;
boolean[] tmask = new boolean[mask.size()];
}
else
{
- setReverseOrder(align, vectorSubsetToArray(tmp, align.getSequences()));
+ setReverseOrder(align,
+ vectorSubsetToArray(tmp, align.getSequences()));
}
}
{
int nSeq = align.getHeight();
- List<SequenceI> tmp = new ArrayList<SequenceI>();
+ List<SequenceI> tmp = new ArrayList<>();
- tmp = _sortByTree(tree.getTopNode(), tmp, align.getSequences());
+ tmp = _sortByTree(tree.getTopNode(), tmp);
if (tmp.size() != nSeq)
{
if (tmp.size() != nSeq)
{
- System.err
- .println("WARNING: tmp.size()="
- + tmp.size()
- + " != nseq="
- + nSeq
- + " in getOrderByTree - tree contains sequences not in alignment");
+ System.err.println("WARNING: tmp.size()=" + tmp.size() + " != nseq="
+ + nSeq
+ + " in getOrderByTree - tree contains sequences not in alignment");
}
}
return tmp;
}
+
+
+ private static List<SequenceI> getOrderByTree(Phylogeny aptxTree,
+ Map<PhylogenyNode, SequenceI> nodesWithBoundSeqs)
+ {
+ List<SequenceI> seqsByTreeOrder = new ArrayList<>();
+ if (!aptxTree.isEmpty())
+ {
+ for (final PhylogenyNodeIterator iter = aptxTree
+ .iteratorPreorder(); iter.hasNext();)
+ {
+ PhylogenyNode treeNode = iter.next();
+ seqsByTreeOrder.add(nodesWithBoundSeqs.get(treeNode));
+ }
+
+ }
+ return seqsByTreeOrder;
+
+
+ }
+
/**
* Sorts the alignment by a given tree
*
}
else
{
- setReverseOrder(align, vectorSubsetToArray(tmp, align.getSequences()));
+ setReverseOrder(align,
+ vectorSubsetToArray(tmp, align.getSequences()));
+ }
+ }
+
+ /**
+ * Sorts the alignment by a given tree from Archaeopteryx
+ *
+ * @param align
+ * alignment to order
+ * @param tree
+ * tree which has
+ */
+ public static void sortByTree(AlignmentI align,
+ Map<PhylogenyNode, SequenceI> aptxNodesWithSeqs,
+ Phylogeny aptxTree) throws IllegalArgumentException
+ {
+ List<SequenceI> tmp = getOrderByTree(aptxTree, aptxNodesWithSeqs);
+
+ if (!tmp.isEmpty())
+ {
+ if (lastAptxTree != aptxTree)
+ {
+ sortTreeAscending = true;
+ lastAptxTree = aptxTree;
+ }
+ else
+ {
+ sortTreeAscending = !sortTreeAscending;
+ }
+
+ if (sortTreeAscending)
+ {
+ setOrder(align, tmp);
+ }
+ else
+ {
+ setReverseOrder(align,
+ vectorSubsetToArray(tmp, align.getSequences()));
+ }
+ }
+ else
+ {
+ throw new IllegalArgumentException();
}
}
* @return DOCUMENT ME!
*/
private static List<SequenceI> _sortByTree(SequenceNode node,
- List<SequenceI> tmp, List<SequenceI> seqset)
+ List<SequenceI> tmp)
{
if (node == null)
{
}
else
{
- _sortByTree(left, tmp, seqset);
- _sortByTree(right, tmp, seqset);
+ _sortByTree(left, tmp);
+ _sortByTree(right, tmp);
}
return tmp;
}
+
+
// Ordering Objects
// Alignment.sortBy(OrderObj) - sequence of sequence pointer refs in
// appropriate order
public static String FEATURE_DENSITY = "density";
- private static boolean containsIgnoreCase(final String lab,
- final List<String> labs)
- {
- if (labs == null)
- {
- return true;
- }
- if (lab == null)
- {
- return false;
- }
- for (String label : labs)
- {
- if (lab.equalsIgnoreCase(label))
- {
- return true;
- }
- }
- return false;
- }
-
/**
* Sort sequences by feature score or density, optionally restricted by
* feature types, feature groups, or alignment start/end positions.
* get sequence residues overlapping column region
* and features for residue positions and specified types
*/
- // TODO new method findPositions(startCol, endCol)? JAL-2544
- int startResidue = seqs[i].findPosition(startCol);
- int endResidue = seqs[i].findPosition(endCol);
String[] types = featureTypes == null ? null : featureTypes
.toArray(new String[featureTypes.size()]);
- List<SequenceFeature> sfs = seqs[i].getFeatures().findFeatures(
- startResidue, endResidue, types);
+ List<SequenceFeature> sfs = seqs[i].findFeatures(startCol + 1,
+ endCol + 1, types);
seqScores[i] = 0;
scores[i] = 0.0;
SequenceFeature sf = it.next();
/*
- * double-check feature overlaps columns (JAL-2544)
- * (could avoid this with a findPositions(fromCol, toCol) method)
- * findIndex returns base 1 column values, startCol/endCol are base 0
+ * accept all features with null or empty group, otherwise
+ * check group is one of the currently visible groups
*/
- if (seqs[i].findIndex(sf.getBegin()) > endCol + 1
- || seqs[i].findIndex(sf.getEnd()) < startCol + 1)
- {
- it.remove();
- continue;
- }
-
String featureGroup = sf.getFeatureGroup();
if (groups != null && featureGroup != null
+ && !"".equals(featureGroup)
&& !groups.contains(featureGroup))
{
it.remove();