ext.edu.ucsf.rbvi.strucviz2 includes sources originally developed by Scooter Morris and Nadezhda Doncheva for the Cytoscape StructureViz2 plugin. It is released under the Berkley license and we hereby acknowledge its original copyright is held by the UCSF Computer Graphics Laboratory
and the software was developed with support by the NIH National Center for Research Resources, grant P41-RR01081.
+
+ jalview.ext.android includes code taken from the Android Open Source Project (https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/util).
+ The Apache 2.0 Licence (http://www.apache.org/licenses/LICENSE-2.0) is acknowledged in the source code.
-Licencing information for each library is given below:
+Licensing information for each library is given below:
JGoogleAnalytics_0.3.jar APL 2.0 License - http://code.google.com/p/jgoogleanalytics/
Jmol-14.2.14_2015.06.11.jar GPL/LGPLv2 http://sourceforge.net/projects/jmol/files/
<strong>Colouring above a percentage identity threshold</strong>
</p>
<p>Selecting this option causes the colour scheme to be applied to
- only those residues that occur in that column more than a certain
+ only those residues that occur in that column at least a certain
percentage of the time. For instance, selecting the threshold to be
- 100 will only colour those columns with 100% identity.</p>
- <p>To be coloured, a residue must match the consensus (most commonly occurring) residue for the column (or joint equal consensus).</p>
+ 100 will only colour those columns with 100% identity, and selecting 50 will shade residues appearing in least 50% of the rows (or sequences) in each column.</p>
<p>The percentage calculation may include or exclude gaps in the column, depending on the option selected for the <a href="../calculations/consensus.html">consensus calculation</a>.</p>
- <p>With a threshold of 0, colouring is unchanged (including non-consensus residues).</p>
+ <p>With a threshold of 0, colouring is unchanged.</p>
</body>
</html>
number and chain code ([RES]Num:Chain). Moving the mouse over an
associated residue in an alignment window highlights the associated
atoms in the displayed structures. When residues are selected in the
- Chimera window, they are highlighted on the alignment. For
- comprehensive details of Chimera's commands, refer to the tool's
- Help menu.
+ Chimera window, they are highlighted on the alignment.
+ <p>For comprehensive details of Chimera's commands, refer to the
+ tool's Help menu.</p>
+ <p>
+ <strong>Selecting residues in Jalview from Chimera</strong><br />
+ When a selection is highlighted in a Jalview window, use the
+ <em>Select→Select Highlighted Region</em> or press <em>B</em>
+ to add the mapped positions to the alignment window's column
+ selection.
+ </p>
<p>
Basic screen operations (see <a
href="http://www.cgl.ucsf.edu/chimera/current/docs/UsersGuide/mouse.html">Chimera
<td><div align="left">Create Scalable Vector Graphics
file FILE from alignment.</div></td>
</tr>
+ <tr>
+ <td><div align="center">-biojsMSA FILE</div></td>
+ <td><div align="left">Write an HTML page to display
+ the alignment with the <a href="biojsmsa.html">
+ BioJS MSAviewer MSA</a>
+ </div>
+ </td>
+ </tr>
</table>
</body>
</html>
based structure superposition was added in Jalview 2.6</em>
</p>
<p>
- <strong>Controls</strong><br> The structure is by default
- rendered as a ribbon diagram. Moving the mouse over the structure
- brings up tooltips giving the residue name, PDB residue number and
- chain code, atom name and number
- ([RES]Num:Chain.AtomName#AtomNumber). If a mapping exists to a
- residue in any associated sequences, then this will be highlighted
- in each one's alignment window. The converse also occurs - moving
- the mouse over an associated residue in an alignment window
- highlights the associated atoms in the displayed structures.
+ <strong>Controls</strong><br> The structure is by default rendered
+ as a ribbon diagram. Moving the mouse over the structure brings up
+ tooltips giving the residue name, PDB residue number and chain code,
+ atom name and number ([RES]Num:Chain.AtomName#AtomNumber). If a
+ mapping exists to a residue in any associated sequences, then this
+ will be highlighted in each one's alignment window. The converse
+ also occurs - moving the mouse over an associated residue in an
+ alignment window highlights the associated atoms in the displayed
+ structures. Press B or use
+ <em>Select→Select Highlighted columns</em> from any linked
+ alignment window to mark the columns highlighted after mousing over
+ the structure.
</p>
<p>Selecting a residue highlights its associated sequence residue
and alpha carbon location. Double clicking an atom allows distances
Settings" under the "View" menu to change the
visibility and colour of the new sequence feature.</p>
<p>
+ <p>
+ <strong>Selecting regions from Search Results</strong>
+ </p>
+ <p>
+ Press 'B' or select the <em>Select Highlighted Columns</em> option
+ from the alignment window's select menu to add columns containing
+ highlighted search results to the alignment window's column
+ selection.
+ </p>
+ <p>
+
<strong>A quick Regular Expression Guide</strong>
</p>
<p>A regular expression is not just a simple text query - although
Much of the information retrieved by Jalview about a sequence is
visualized on the alignment. Often, however, there are a huge number
of ontology terms, cross-references, links to publications and other
- kinds of data shown in the sequence ID tooltip that cannot be
- examined. In this case, you can view and export the information
- shown in a sequence's ID tooltip by right-clicking and selecting the
+ kinds of data associated with a sequence, and only some of these are shown in
+ sequence ID tooltip. To show the full set of annotation and database links for
+ a sequence, right-click and select the
<strong>"<em>(sequence's name)</em></em>→Sequence
Details ..."
</strong> entry from the <a href="../menus/popupMenu.html">pop-up menu</a>.
</p>
<p>
<strong>Annotation Reports for a range of sequences</strong><br />
- If you would like to view the tooltips for a number of sequences,
+ If you would like to view database and metadata for a number of sequences,
simply select them all and then use the <strong>Selection→Sequence
Details ...</strong> entry in the <a href="../menus/popupMenu.html">pop-up
menu</a>.
<td>Both</td>
<td>Launches the search window</td>
</tr>
+ <tr><td><strong>B</strong></td>
+ <td>Both</td>
+ <td>Mark the currently highlighted columns</td>
+ </tr>
+ <tr><td><strong>Alt 'B'</strong></td>
+ <td>Both</td>
+ <td>Mark all but the currently highlighted columns</td>
+ </tr>
+ <tr><td><strong>Control 'B'</strong></td>
+ <td>Both</td>
+ <td>Toggle the marks on the currently highlighted
+ columns (or all others if Alt is pressed)</td>
+ </tr>
<tr>
<td><strong>H</strong></td>
<td>Both</td>
Columns by Annotation</a></strong> <br /> <em>Select or Hide
columns in the alignment according to secondary structure,
labels and values shown in alignment annotation rows. </em></li>
+ <li><strong>Select Highlighted Columns</strong> <br /> <em>Selects
+ the columns currently highlighted as a result of a find, mouse
+ over, or selection event from a linked structure viewer or other
+ application. Modifiers will work on some platforms: ALT will add
+ all but the highlighted set to the column selection, and CTRL
+ (or META) will toggle the selection. </em></li>
</ul></li>
<li><strong>View</strong>
<ul>
Columns by Annotation</a></strong> <br /> <em>Select or Hide columns
in the alignment according to secondary structure, labels and
values shown in alignment annotation rows. </em></li>
+ <li><strong>Select Highlighted Columns</strong> <br /> <em>Selects
+ the columns currently highlighted as a result of a find, mouse
+ over, or selection event from a linked structure viewer or other
+ application. Modifiers will work on some platforms: ALT will add
+ all but the highlighted set to the column selection, and CTRL
+ (or META) will toggle the selection. </em></li>
</ul>
</body>
</html>
<tr>
<td width="60" nowrap>
<div align="center">
+ <strong><a name="Jalview.2.10.1">2.10.1</a><br />
+ <em>24/11/2016</em></strong>
+ </div>
+ </td>
+ <td><div align="left">
+ <em>General</em>
+ <ul>
+ <li><!-- JAL-98 -->Improved memory usage: sparse arrays used for all consensus calculations</li>
+ <li><!-- JAL- --></li>
+ </ul>
+ <em>Application</em>
+ <ul>
+ <li><!-- JAL-1723 -->Sequence ID tool tips have been tamed (databases sorted alphabetically, abridged ID sets) </li>
+ <li><!-- JAL-2282-->New replacement token for creating URLs <em>just</em> from database cross references. Users with custom links will receive a warning dialog asking them to update their preferences.</li>
+ <li><!-- JAL-2287-->Cancel button and escape listener on dialog warning user about disconnecting Jalview from a Chimera session</li>
+ <li><!-- JAL-2281-->Custom URL links for database cross-references are matched to database name regardless of case</li>
+ <li></li>
+
+
+ </ul>
+ <em>Applet</em>
+ <ul>
+ </ul>
+ <em>Build and deployment</em>
+ <ul>
+ <li></li>
+ </ul>
+ </div>
+ </td>
+ <td>
+ <div align="left">
+ <em>General</em>
+ <ul>
+ <li><!-- JAL-2286 -->Columns with more than one modal residue are not coloured or thresholded according to percent identity (first observed in Jalview 2.8.2)</li>
+ <li><!-- JAL-2301 -->Threonine incorrectly reported as not hydrophobic</li>
+ <li><!-- JAL-2318 -->Updates to documentation pages (above PID threshold, amino acid properties)</li>
+ <li><!-- JAL-2292 -->Lower case residues in sequences are not reported as mapped to residues in a structure file in the View Mapping report</li>
+ </ul>
+ <em>Application</em>
+ <ul>
+ <li><!-- JAL-2282-->Custom URL links for specific database names without regular expressions also offer invalid links from Sequence ID</li>
+ <li><!-- JAL-2315-->Removing a single configured link in the URL links pane in Connections preferences doesn't actually update Jalview configuration</li>
+ <li><!-- JAL-2272-->CTRL-Click on a selected region to open the alignment area popup menu doesn't work on El-Capitan</li>
+ <li><!-- JAL-2280 -->Jalview doesn't offer to associate mmCIF files with similarly named sequences if dropped onto the alignment</li>
+ <li><!-- JAL-2312 -->Additional mappings are shown for PDB entries where more chains exist in the PDB accession than are reported in the SIFTS file</li>
+ <li><!-- JAL-2317-->Certain structures do not get mapped to the structure view when displayed with Chimera</li>
+ <li><!-- JAL-2317-->No chains shown in the Chimera view panel's View->Show Chains submenu</li>
+
+ <li><!-- --></li>
+ <li><!-- --></li>
+ </ul>
+ <em>Applet</em>
+ <ul>
+ </ul>
+ <em>Build and deployment</em>
+ <ul>
+ <li><!-- JAL-2308, -->Failing/passing unit tests</li>
+ </ul>
+ <em>New Known Issues</em>
+ <ul>
+ <li></li>
+ </ul>
+ </div>
+ </td>
+ </tr>
+ <td width="60" nowrap>
+ <div align="center">
<strong><a name="Jalview.2.10.0b1">2.10.0b1</a><br />
<em>25/10/2016</em></strong>
</div>
<!-- JAL-1306 -->Quality and Conservation are now shown on
load even when Consensus calculation is disabled
</li>
+ <li>
+ <!-- JAL-1932 -->Remove right on penultimate column of
+ alignment does nothing
+ </li>
</ul>
<em>Application</em>
<ul>
<!-- JAL-1887 -->Incorrect start and end reported for PDB
to sequence mapping in 'View Mappings' report
</li>
+ <li>
+ <!-- JAL-2284 -->Unable to read old Jalview projects that
+ contain non-XML data added after Jalvew wrote project.
+ </li>
+ <li><!-- JAL-2118 -->Newly created annotation row reorders
+ after clicking on it to create new annotation for a
+ column.
+ </li>
<!-- may exclude, this is an external service stability issue JAL-1941
-- > RNA 3D structure not added via DSSR service</li> -->
</ul>
</ul> <em>Applet</em>
<ul>
<li>Split frame example added to applet examples page</li>
+ </ul><em>Build and Deployment</em>
+ <ul>
+ <li><!-- JAL-1888 -->New ant target for running Jalview's test suite</li>
</ul></td>
<td>
<div align="left">
<p>
<p>
<strong>Discovering Database References for Sequences</strong><br>
- Database references are associated with a sequence are displayed as a
- list in the tooltip shown when mousing over its sequence ID. Jalview
- uses references for the retrieval of <a
- href="../features/viewingpdbs.html">PDB structures</a> and <a
+ Database references associated with a sequence are displayed as an
+ abbreviated list in the tooltip shown when mousing over its sequence
+ ID, and can be viewed in full via the
+ <a href="../io/exportseqreport.html">Sequence Details</a> window. .
+ Jalview also uses references for the retrieval of
+ <a href="../features/viewingpdbs.html">PDB structures</a> and <a
href="../features/dasfeatures.html">DAS features</a>, and for
retrieving sequence cross-references such as the protein products of a
DNA sequence.
the sequence ID for the sequence (<em>since Jalview 2.10.1</em>).
</p>
<p>
+ If Jalview opens a project with links which include $SEQUENCE_ID$ tokens, it will present
+ the user with a warning message, as these links may need to be updated to use $DB_ACCESSION$, if
+ they were added before Jalview 2.10.1. The message lists the links which should be reviewed.
+ The warning can be turned off completely via a checkbox in the message dialog.
+ </p>
+ <p>
<strong>Regular Expression Substitution</strong><br> A url may
contain a string of the form $SEQUENCE_ID=/<em>regular
expression</em>/=$ or $DB_ACCESSION=/<em>regular expression</em>/=$.
action.colour = Colour
action.calculate = Calculate
action.select_all = Select all
+action.select_highlighted_columns = Select Highlighted Columns
+tooltip.select_highlighted_columns = Press B to mark highlighted columns, Ctrl-B to toggle, and Alt-B to mark all but highlighted columns
action.deselect_all = Deselect all
action.invert_selection = Invert selection
action.using_jmol = Using Jmol
label.SEQUENCE_ID_for_DB_ACCESSION1 = Please review your URL links in the 'Connections' tab of the Preferences window:
label.SEQUENCE_ID_for_DB_ACCESSION2 = URL links using '$SEQUENCE_ID$' for DB accessions now use '$DB_ACCESSION$'.
label.do_not_display_again = Do not display this message again
+label.output_seq_details = Output Sequence Details to list all database references
label.SEQUENCE_ID_no_longer_used = $SEQUENCE_ID$ no se utiliza más para accesiones DB
label.SEQUENCE_ID_for_DB_ACCESSION1 = Por favor, revise sus URLs en la pestaña 'Conexiones' de la ventana de Preferencias:
label.SEQUENCE_ID_for_DB_ACCESSION2 = URL enlaza usando '$SEQUENCE_ID$' para accesiones DB ahora usar '$DB_ACCESSION$'.
-label.do_not_display_again = No mostrar este mensaje de nuevo
\ No newline at end of file
+label.do_not_display_again = No mostrar este mensaje de nuevo
+label.output_seq_details = Seleccionar Detalles de la secuencia para ver todas
import jalview.datamodel.Annotation;
import jalview.datamodel.Profile;
import jalview.datamodel.ProfileI;
+import jalview.datamodel.Profiles;
+import jalview.datamodel.ProfilesI;
import jalview.datamodel.ResidueCount;
-import jalview.datamodel.SequenceI;
import jalview.datamodel.ResidueCount.SymbolCounts;
+import jalview.datamodel.SequenceI;
import jalview.ext.android.SparseIntArray;
import jalview.util.Comparison;
import jalview.util.Format;
}
}
- public static final ProfileI[] calculate(List<SequenceI> list,
+ public static final ProfilesI calculate(List<SequenceI> list,
int start, int end)
{
return calculate(list, start, end, false);
}
- public static final ProfileI[] calculate(List<SequenceI> sequences,
+ public static final ProfilesI calculate(List<SequenceI> sequences,
int start, int end, boolean profile)
{
SequenceI[] seqs = new SequenceI[sequences.size()];
for (int i = 0; i < sequences.size(); i++)
{
seqs[i] = sequences.get(i);
- if (seqs[i].getLength() > width)
+ int length = seqs[i].getLength();
+ if (length > width)
{
- width = seqs[i].getLength();
+ width = length;
}
}
- ProfileI[] reply = new ProfileI[width];
-
if (end >= width)
{
end = width;
}
- calculate(seqs, start, end, reply, profile);
+ ProfilesI reply = calculate(seqs, width, start, end, profile);
return reply;
}
}
* Calculate the consensus symbol(s) for each column in the given range.
*
* @param sequences
+ * @param width
+ * the full width of the alignment
* @param start
* start column (inclusive, base zero)
* @param end
* end column (exclusive)
- * @param result
- * array in which to store profile per column
* @param saveFullProfile
* if true, store all symbol counts
*/
- public static final void calculate(final SequenceI[] sequences,
- int start, int end, ProfileI[] result, boolean saveFullProfile)
+ public static final ProfilesI calculate(final SequenceI[] sequences,
+ int width, int start, int end, boolean saveFullProfile)
{
// long now = System.currentTimeMillis();
int seqCount = sequences.length;
int nucleotideCount = 0;
int peptideCount = 0;
+ ProfileI[] result = new ProfileI[width];
+
for (int column = start; column < end; column++)
{
/*
result[column] = profile;
}
+ return new Profiles(result);
// long elapsed = System.currentTimeMillis() - now;
// System.out.println(elapsed);
}
* the annotation row to add annotations to
* @param profiles
* the source consensus data
- * @param iStart
- * start column
- * @param width
- * end column
+ * @param startCol
+ * start column (inclusive)
+ * @param endCol
+ * end column (exclusive)
* @param ignoreGaps
* if true, normalise residue percentages ignoring gaps
* @param showSequenceLogo
* number of sequences
*/
public static void completeConsensus(AlignmentAnnotation consensus,
- ProfileI[] profiles, int iStart, int width, boolean ignoreGaps,
+ ProfilesI profiles, int startCol, int endCol, boolean ignoreGaps,
boolean showSequenceLogo, long nseq)
{
// long now = System.currentTimeMillis();
if (consensus == null || consensus.annotations == null
- || consensus.annotations.length < width)
+ || consensus.annotations.length < endCol)
{
/*
* called with a bad alignment annotation row
return;
}
- final int dp = getPercentageDp(nseq);
-
- for (int i = iStart; i < width; i++)
+ for (int i = startCol; i < endCol; i++)
{
- ProfileI profile;
- if (i >= profiles.length || ((profile = profiles[i]) == null))
+ ProfileI profile = profiles.get(i);
+ if (profile == null)
{
/*
* happens if sequences calculated over were
* shorter than alignment width
*/
consensus.annotations[i] = null;
- continue;
+ return;
}
+ final int dp = getPercentageDp(nseq);
+
float value = profile.getPercentageIdentity(ignoreGaps);
String description = getTooltip(profile, value, showSequenceLogo,
{
modalResidue = "+";
}
- consensus.annotations[i] = new Annotation(modalResidue,
- description, ' ', value);
+ consensus.annotations[i] = new Annotation(modalResidue, description,
+ ' ', value);
}
// long elapsed = System.currentTimeMillis() - now;
// System.out.println(-elapsed);
package jalview.analysis;
import jalview.datamodel.AlignmentI;
+import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
-import jalview.datamodel.Sequence;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+import jalview.util.Comparison;
+import java.util.ArrayList;
+import java.util.List;
import java.util.Vector;
+import com.stevesoft.pat.Regex;
+
public class Finder
{
/**
* Implements the search algorithms for the Find dialog box.
*/
- SearchResults searchResults;
+ SearchResultsI searchResults;
AlignmentI alignment;
- jalview.datamodel.SequenceGroup selection = null;
+ SequenceGroup selection = null;
- Vector idMatch = null;
+ Vector<SequenceI> idMatch = null;
boolean caseSensitive = false;
boolean findAll = false;
- com.stevesoft.pat.Regex regex = null;
+ Regex regex = null;
/**
- * hold's last-searched position between calles to find(false)
+ * holds last-searched position between calls to find(false)
*/
int seqIndex = 0, resIndex = -1;
{
searchString = searchString.toUpperCase();
}
- regex = new com.stevesoft.pat.Regex(searchString);
+ regex = new Regex(searchString);
regex.setIgnoreCase(!caseSensitive);
searchResults = new SearchResults();
- idMatch = new Vector();
- Sequence seq;
+ idMatch = new Vector<SequenceI>();
String item = null;
boolean found = false;
int end = alignment.getHeight();
selection = null;
}
}
+ SearchResultMatchI lastm = null;
while (!found && (seqIndex < end))
{
- seq = (Sequence) alignment.getSequenceAt(seqIndex);
+ SequenceI seq = alignment.getSequenceAt(seqIndex);
if ((selection != null && selection.getSize() > 0)
&& !selection.getSequences(null).contains(seq))
{
}
- if (regex.search(seq.getName()))
+ if (regex.search(seq.getName()) && !idMatch.contains(seq))
{
idMatch.addElement(seq);
hasResults = true;
}
if (isIncludeDescription() && seq.getDescription() != null
- && regex.search(seq.getDescription()))
+ && regex.search(seq.getDescription())
+ && !idMatch.contains(seq))
{
idMatch.addElement(seq);
hasResults = true;
}
// /Shall we ignore gaps???? - JBPNote: Add Flag for forcing this or not
- StringBuffer noGapsSB = new StringBuffer();
+ StringBuilder noGapsSB = new StringBuilder();
int insertCount = 0;
- Vector spaces = new Vector();
+ List<Integer> spaces = new ArrayList<Integer>();
for (int j = 0; j < item.length(); j++)
{
- if (!jalview.util.Comparison.isGap(item.charAt(j)))
+ if (!Comparison.isGap(item.charAt(j)))
{
noGapsSB.append(item.charAt(j));
- spaces.addElement(new Integer(insertCount));
+ spaces.add(Integer.valueOf(insertCount));
}
else
{
}
String noGaps = noGapsSB.toString();
-
for (int r = resIndex; r < noGaps.length(); r++)
{
resIndex = regex.matchedFrom();
if ((selection != null && selection.getSize() > 0)
- && ((resIndex + Integer.parseInt(spaces.elementAt(
- resIndex).toString())) < selection.getStartRes()))
+ && (resIndex + spaces.get(resIndex) < selection
+ .getStartRes()))
{
continue;
}
// if invalid string used, then regex has no matched to/from
- int sres = seq
- .findPosition(resIndex
- + Integer.parseInt(spaces.elementAt(resIndex)
- .toString()));
- int eres = seq.findPosition(regex.matchedTo()
- - 1
- + Integer.parseInt(spaces
- .elementAt(regex.matchedTo() - 1).toString()));
-
- searchResults.addResult(seq, sres, eres);
+ int sres = seq.findPosition(resIndex + spaces.get(resIndex));
+ int eres = seq.findPosition(regex.matchedTo() - 1
+ + (spaces.get(regex.matchedTo() - 1)));
+ // only add result if not contained in previous result
+ if (lastm == null
+ || (lastm.getSequence() != seq || (!(lastm.getStart() <= sres && lastm
+ .getEnd() >= eres))))
+ {
+ lastm = searchResults.addResult(seq, sres, eres);
+ }
hasResults = true;
if (!findAll)
{
}
/**
- * @return the idMatch
+ * Returns the (possibly empty) list of matching sequences (when search
+ * includes searching sequence names)
+ *
+ * @return
*/
- public Vector getIdMatch()
+ public Vector<SequenceI> getIdMatch()
{
return idMatch;
}
/**
* @return the searchResults
*/
- public SearchResults getSearchResults()
+ public SearchResultsI getSearchResults()
{
return searchResults;
}
public boolean parseFeaturesFile(String file, String protocol,
boolean relaxedIdMatching);
+ /**
+ * mark columns containing highlighted regions (e.g. from search, structure
+ * highlight, or a mouse over event in another viewer)
+ *
+ * @param invert
+ * @param extendCurrent
+ * @param toggle
+ * @return
+ */
+ boolean markHighlightedColumns(boolean invert, boolean extendCurrent,
+ boolean toggle);
+
}
import jalview.datamodel.AlignmentView;
import jalview.datamodel.CigarArray;
import jalview.datamodel.ColumnSelection;
-import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
ColumnSelection getColumnSelection();
- ProfileI[] getSequenceConsensusHash();
+ ProfilesI getSequenceConsensusHash();
/**
* Get consensus data table for the cDNA complement of this alignment (if any)
*
* @param hconsensus
*/
- void setSequenceConsensusHash(ProfileI[] hconsensus);
+ void setSequenceConsensusHash(ProfilesI hconsensus);
/**
* Set the cDNA complement consensus for the viewport
* @return true if group is defined on the alignment
*/
boolean isSelectionDefinedGroup();
+
+ /**
+ *
+ * @return true if there are search results on the view
+ */
+ boolean hasSearchResults();
+
+ /**
+ * set the search results for the view
+ *
+ * @param results
+ * - or null to clear current results
+ */
+ void setSearchResults(SearchResultsI results);
+
+ /**
+ * get search results for this view (if any)
+ *
+ * @return search results or null
+ */
+ SearchResultsI getSearchResults();
}
void setGroupVisibility(String group, boolean visible);
/**
- * locate features at a particular position on the given sequence
+ * Returns features at the specified position on the given sequence.
+ * Non-positional features are not included.
*
* @param sequence
* @param res
CutAndPasteTransfer cap = new CutAndPasteTransfer(false, ap.alignFrame);
- StringBuffer contents = new StringBuffer();
+ StringBuilder contents = new StringBuilder(128);
for (SequenceI seq : sequences)
{
contents.append(MessageManager.formatMessage(
seq,
true,
true,
- false,
(ap.seqPanel.seqCanvas.fr != null) ? ap.seqPanel.seqCanvas.fr
.getMinMax() : null);
contents.append("</p>");
import jalview.datamodel.AlignmentI;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
* there is no complement, or it is not following highlights, or no mapping
* is found, the result will be empty.
*/
- SearchResults sr = new SearchResults();
+ SearchResultsI sr = new SearchResults();
int seqOffset = findComplementScrollTarget(sr);
if (!sr.isEmpty())
{
import jalview.api.AlignmentViewPanel;
import jalview.bin.JalviewLite;
import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceI;
import jalview.structure.StructureSelectionManager;
* Highlight the given results on the alignment.
*
*/
- public void highlightSearchResults(SearchResults results)
+ public void highlightSearchResults(SearchResultsI results)
{
scrollToPosition(results);
seqPanel.seqCanvas.highlightSearchResults(results);
* @param results
* @return false if results were not found
*/
- public boolean scrollToPosition(SearchResults results)
+ public boolean scrollToPosition(SearchResultsI results)
{
return scrollToPosition(results, true);
}
* - when set, the overview will be recalculated (takes longer)
* @return false if results were not found
*/
- public boolean scrollToPosition(SearchResults results,
+ public boolean scrollToPosition(SearchResultsI results,
boolean redrawOverview)
{
- return scrollToPosition(results, redrawOverview, false);
+ return scrollToPosition(results, 0, redrawOverview, false);
}
/**
* - when set, the overview will be recalculated (takes longer)
* @return false if results were not found
*/
- public boolean scrollToPosition(SearchResults results,
+ public boolean scrollToPosition(SearchResultsI results,
+ int verticalOffset,
boolean redrawOverview, boolean centre)
{
// do we need to scroll the panel?
{
return false;
}
+ /*
+ * allow for offset of target sequence (actually scroll to one above it)
+ */
+
SequenceI seq = alignment.getSequenceAt(seqIndex);
int[] r = results.getResults(seq, 0, alignment.getWidth());
if (r == null)
{
return false;
}
+
+ /*
+ * allow for offset of target sequence (actually scroll to one above it)
+ */
+ seqIndex = Math.max(0, seqIndex - verticalOffset);
return scrollTo(start, end, seqIndex, false, redrawOverview);
}
return true;
{
start = ostart;
}
+
if (!av.getWrapAlignment())
{
/*
* @param seqOffset
* the number of visible sequences to show above the mapped region
*/
- protected void scrollToCentre(SearchResults sr, int seqOffset)
+ protected void scrollToCentre(SearchResultsI sr, int seqOffset)
{
/*
* To avoid jumpy vertical scrolling (if some sequences are gapped or not
* mapped), we can make the scroll-to location a sequence above the one
* actually mapped.
*/
- SequenceI mappedTo = sr.getResultSequence(0);
+ SequenceI mappedTo = sr.getResults().get(0).getSequence();
List<SequenceI> seqs = av.getAlignment().getSequences();
/*
{
return; // failsafe, shouldn't happen
}
- sequenceIndex = Math.max(0, sequenceIndex - seqOffset);
- sr.getResults().get(0)
- .setSequence(av.getAlignment().getSequenceAt(sequenceIndex));
/*
* Scroll to position but centring the target residue. Also set a state flag
* to prevent adjustmentValueChanged performing this recursively.
*/
setFollowingComplementScroll(true);
- scrollToPosition(sr, true, true);
+ // this should be scrollToPosition(sr,verticalOffset,
+ scrollToPosition(sr, seqOffset, true, true);
}
private void sendViewPosition()
import jalview.api.FeatureColourI;
import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.io.FeaturesFile;
start.setText(features[index].getBegin() + "");
end.setText(features[index].getEnd() + "");
- SearchResults highlight = new SearchResults();
+ SearchResultsI highlight = new SearchResults();
highlight.addResult(sequences[0], features[index].getBegin(),
features[index].getEnd());
*/
package jalview.appletgui;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.util.MessageManager;
Frame frame;
- SearchResults searchResults;
+ SearchResultsI searchResults;
int seqIndex = 0;
frame.repaint();
frame.addWindowListener(new WindowAdapter()
{
+ @Override
public void windowClosing(WindowEvent evt)
{
ap.highlightSearchResults(null);
textfield.requestFocus();
}
+ @Override
public void actionPerformed(ActionEvent evt)
{
if (evt.getSource() == textfield)
SequenceFeature[] features = new SequenceFeature[searchResults
.getSize()];
- for (int i = 0; i < searchResults.getSize(); i++)
+ int i = 0;
+ for (SearchResultMatchI match : searchResults.getResults())
{
- seqs[i] = searchResults.getResultSequence(i);
+ seqs[i] = match.getSequence().getDatasetSequence();
features[i] = new SequenceFeature(textfield.getText().trim(),
- "Search Results", null, searchResults.getResultStart(i),
- searchResults.getResultEnd(i), "Search Results");
+ "Search Results", null, match.getStart(), match.getEnd(),
+ "Search Results");
+ i++;
}
if (ap.seqPanel.seqCanvas.getFeatureRenderer().amendFeatures(seqs,
seqIndex = finder.getSeqIndex();
resIndex = finder.getResIndex();
searchResults = finder.getSearchResults();
- Vector idMatch = finder.getIdMatch();
+ Vector<SequenceI> idMatch = finder.getIdMatch();
boolean haveResults = false;
// set or reset the GUI
if ((idMatch.size() > 0))
textfield.setBounds(new Rectangle(40, 17, 133, 21));
textfield.addKeyListener(new java.awt.event.KeyAdapter()
{
+ @Override
public void keyTyped(KeyEvent e)
{
textfield_keyTyped(e);
package jalview.appletgui;
import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.renderer.ScaleRenderer;
AlignViewport av;
- SearchResults searchResults = null;
-
boolean fastPaint = false;
int cursorX = 0;
// / Highlight search Results once all sequences have been drawn
// ////////////////////////////////////////////////////////
- if (searchResults != null)
+ if (av.hasSearchResults())
{
- int[] visibleResults = searchResults.getResults(nextSeq, startRes,
+ int[] visibleResults = av.getSearchResults().getResults(nextSeq,
+ startRes,
endRes);
if (visibleResults != null)
{
}
}
- public void highlightSearchResults(SearchResults results)
+ public void highlightSearchResults(SearchResultsI results)
{
- searchResults = results;
-
+ av.setSearchResults(results);
repaint();
}
import jalview.commands.EditCommand.Action;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
-import jalview.datamodel.SearchResults.Match;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
* @param results
* @return true if results were matched, false if not
*/
- private boolean setStatusMessage(SearchResults results)
+ private boolean setStatusMessage(SearchResultsI results)
{
AlignmentI al = this.av.getAlignment();
int sequenceIndex = al.findIndex(results);
return false;
}
SequenceI ds = al.getSequenceAt(sequenceIndex).getDatasetSequence();
- for (Match m : results.getResults())
+ for (SearchResultMatchI m : results.getResults())
{
SequenceI seq = m.getSequence();
if (seq.getDatasetSequence() != null)
if (features != null && features.length > 0)
{
- SearchResults highlight = new SearchResults();
+ SearchResultsI highlight = new SearchResults();
highlight.addResult(sequence, features[0].getBegin(),
features[0].getEnd());
seqCanvas.highlightSearchResults(highlight);
}
@Override
- public void highlightSequence(SearchResults results)
+ public void highlightSequence(SearchResultsI results)
{
if (av.isFollowHighlight())
{
return featuresFile;
}
+
+ @Override
+ public boolean markHighlightedColumns(boolean invert,
+ boolean extendCurrent, boolean toggle)
+ {
+ if (!viewport.hasSearchResults())
+ {
+ // do nothing if no selection exists
+ return false;
+ }
+ // JBPNote this routine could also mark rows, not just columns.
+ BitSet bs = new BitSet();
+ SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null || extendCurrent) ? viewport
+ .getAlignment() : viewport.getSelectionGroup();
+
+ // this could be a lambda... - the remains of the method is boilerplate,
+ // except for the different messages for reporting selection.
+ int nseq = viewport.getSearchResults().markColumns(sqcol, bs);
+
+ ColumnSelection cs = viewport.getColumnSelection();
+ if (cs == null)
+ {
+ cs = new ColumnSelection();
+ }
+
+ if (bs.cardinality() > 0 || invert)
+ {
+ boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
+ sqcol.getEndRes(), invert, extendCurrent, toggle);
+ if (changed)
+ {
+ viewport.setColumnSelection(cs);
+ alignPanel.paintAlignment(true);
+ int columnCount = invert ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
+ - bs.cardinality()
+ : bs.cardinality();
+ avcg.setStatus(MessageManager.formatMessage(
+ "label.view_controller_toggled_marked",
+ new String[] {
+ toggle ? MessageManager.getString("label.toggled")
+ : MessageManager.getString("label.marked"),
+ String.valueOf(columnCount),
+ invert ? MessageManager
+ .getString("label.not_containing")
+ : MessageManager.getString("label.containing"),
+ "Highlight", Integer.valueOf(nseq).toString() }));
+ return true;
+ }
+ }
+ else
+ {
+ avcg.setStatus(MessageManager
+ .formatMessage("No highlighted regions marked"));
+ if (!extendCurrent)
+ {
+ cs.clear();
+ alignPanel.paintAlignment(true);
+ }
+ }
+ return false;
+ }
+
}
* where highlighted regions go
*/
public void markMappedRegion(SequenceI seq, int index,
- SearchResults results)
+ SearchResultsI results)
{
int[] codon;
SequenceI ds = seq.getDatasetSequence();
* jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults)
*/
@Override
- public int findIndex(SearchResults results)
+ public int findIndex(SearchResultsI results)
{
int i = 0;
* @param results
* @return -1 or index of sequence in alignment
*/
- int findIndex(SearchResults results);
+ int findIndex(SearchResultsI results);
/**
* append sequences and annotation from another alignment object to this one.
--- /dev/null
+package jalview.datamodel;
+
+public class Profiles implements ProfilesI
+{
+
+ private ProfileI[] profiles;
+
+ public Profiles(ProfileI[] p)
+ {
+ profiles = p;
+ }
+
+ /**
+ * Returns the profile for the given column, or null if none found
+ *
+ * @param col
+ */
+ @Override
+ public ProfileI get(int col)
+ {
+ return profiles != null && col >= 0 && col < profiles.length ? profiles[col]
+ : null;
+ }
+
+ /**
+ * Returns the first column (base 0) covered by the profiles
+ */
+ @Override
+ public int getStartColumn()
+ {
+ return 0;
+ }
+
+ /**
+ * Returns the last column (base 0) covered by the profiles
+ */
+ @Override
+ public int getEndColumn()
+ {
+ return profiles == null ? 0 : profiles.length - 1;
+ }
+
+}
--- /dev/null
+package jalview.datamodel;
+
+public interface ProfilesI
+{
+
+ ProfileI get(int i);
+
+ int getStartColumn();
+
+ int getEndColumn();
+
+}
--- /dev/null
+package jalview.datamodel;
+
+/**
+ * An interface that describes one matched region of an alignment, as one
+ * contiguous portion of a single dataset sequence
+ */
+public interface SearchResultMatchI
+{
+ /**
+ * Returns the matched sequence
+ *
+ * @return
+ */
+ SequenceI getSequence();
+
+ /**
+ * Returns the start position of the match in the sequence (base 1)
+ *
+ * @return
+ */
+ int getStart();
+
+ /**
+ * Returns the end position of the match in the sequence (base 1)
+ *
+ * @return
+ */
+ int getEnd();
+
+}
\ No newline at end of file
package jalview.datamodel;
import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.BitSet;
import java.util.List;
/**
* Holds a list of search result matches, where each match is a contiguous
* stretch of a single sequence.
*
- * @author gmcarstairs
+ * @author gmcarstairs amwaterhouse
*
*/
-public class SearchResults
+public class SearchResults implements SearchResultsI
{
- private List<Match> matches = new ArrayList<Match>();
+ private List<SearchResultMatchI> matches = new ArrayList<SearchResultMatchI>();
/**
* One match consists of a sequence reference, start and end positions.
* Discontiguous ranges in a sequence require two or more Match objects.
*/
- public class Match
+ public class Match implements SearchResultMatchI
{
SequenceI sequence;
int end;
/**
- * Constructor
+ * create a Match on a range of sequence. Match always holds region in
+ * forwards order, even if given in reverse order (such as from a mapping to
+ * a reverse strand); this avoids trouble for routines that highlight search
+ * results etc
*
* @param seq
* a sequence
}
else
{
+ // TODO: JBP could mark match as being specified in reverse direction
+ // for use
+ // by caller ? e.g. visualizing reverse strand highlight
this.start = end;
this.end = start;
}
}
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultMatchI#getSequence()
+ */
+ @Override
public SequenceI getSequence()
{
return sequence;
}
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultMatchI#getStart()
+ */
+ @Override
public int getStart()
{
return start;
}
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultMatchI#getEnd()
+ */
+ @Override
public int getEnd()
{
return end;
}
/**
- * Returns the string of characters in the matched region, prefixed by the
- * start position, e.g. "12CGT" or "208K"
+ * Returns a representation as "seqid/start-end"
*/
@Override
public String toString()
{
- final int from = Math.max(start - 1, 0);
- String startPosition = String.valueOf(from);
- return startPosition + getCharacters();
- }
-
- /**
- * Returns the string of characters in the matched region.
- */
- public String getCharacters()
- {
- char[] chars = sequence.getSequence();
- // convert start/end to base 0 (with bounds check)
- final int from = Math.max(start - 1, 0);
- final int to = Math.min(end, chars.length + 1);
- return String.valueOf(Arrays.copyOfRange(chars, from, to));
+ StringBuilder sb = new StringBuilder();
+ if (sequence != null)
+ {
+ sb.append(sequence.getName()).append("/");
+ }
+ sb.append(start).append("-").append(end);
+ return sb.toString();
}
public void setSequence(SequenceI seq)
@Override
public boolean equals(Object obj)
{
- if (obj == null || !(obj instanceof Match))
+ if (obj == null || !(obj instanceof SearchResultMatchI))
{
return false;
}
- Match m = (Match) obj;
- return (this.sequence == m.sequence && this.start == m.start && this.end == m.end);
+ SearchResultMatchI m = (SearchResultMatchI) obj;
+ return (sequence == m.getSequence() && start == m.getStart() && end == m
+ .getEnd());
}
}
- /**
- * This method replaces the old search results which merely held an alignment
- * index of search matches. This broke when sequences were moved around the
- * alignment
- *
- * @param seq
- * Sequence
- * @param start
- * int
- * @param end
- * int
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultsI#addResult(jalview.datamodel.SequenceI, int, int)
*/
- public void addResult(SequenceI seq, int start, int end)
+ @Override
+ public SearchResultMatchI addResult(SequenceI seq, int start, int end)
{
- matches.add(new Match(seq, start, end));
+ Match m = new Match(seq, start, end);
+ matches.add(m);
+ return m;
}
- /**
- * Quickly check if the given sequence is referred to in the search results
- *
- * @param sequence
- * (specific alignment sequence or a dataset sequence)
- * @return true if the results involve sequence
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultsI#involvesSequence(jalview.datamodel.SequenceI)
*/
+ @Override
public boolean involvesSequence(SequenceI sequence)
{
SequenceI ds = sequence.getDatasetSequence();
- for (Match m : matches)
+ for (SearchResultMatchI _m : matches)
{
- if (m.sequence != null
- && (m.sequence == sequence || m.sequence == ds))
+ SequenceI matched = _m.getSequence();
+ if (matched != null && (matched == sequence || matched == ds))
{
return true;
}
return false;
}
- /**
- * This Method returns the search matches which lie between the start and end
- * points of the sequence in question. It is optimised for returning objects
- * for drawing on SequenceCanvas
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultsI#getResults(jalview.datamodel.SequenceI, int, int)
*/
+ @Override
public int[] getResults(SequenceI sequence, int start, int end)
{
if (matches.isEmpty())
int[] tmp = null;
int resultLength, matchStart = 0, matchEnd = 0;
boolean mfound;
- for (Match m : matches)
+ Match m;
+ for (SearchResultMatchI _m : matches)
{
+ m = (Match) _m;
+
mfound = false;
if (m.sequence == sequence)
{
return result;
}
- public int getSize()
- {
- return matches.size();
- }
-
- public SequenceI getResultSequence(int index)
- {
- return matches.get(index).sequence;
- }
-
- /**
- * Returns the start position of the i'th match in the search results.
- *
- * @param i
- * @return
- */
- public int getResultStart(int i)
+ @Override
+ public int markColumns(SequenceCollectionI sqcol, BitSet bs)
{
- return matches.get(i).start;
+ int count = 0;
+ BitSet mask = new BitSet();
+ for (SequenceI s : sqcol.getSequences())
+ {
+ int[] cols = getResults(s, sqcol.getStartRes(), sqcol.getEndRes());
+ if (cols != null)
+ {
+ for (int pair = 0; pair < cols.length; pair += 2)
+ {
+ mask.set(cols[pair], cols[pair + 1] + 1);
+ }
+ }
+ }
+ // compute columns that were newly selected
+ BitSet original = (BitSet) bs.clone();
+ original.and(mask);
+ count = mask.cardinality() - original.cardinality();
+ // and mark ranges not already marked
+ bs.or(mask);
+ return count;
}
- /**
- * Returns the end position of the i'th match in the search results.
- *
- * @param i
- * @return
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultsI#getSize()
*/
- public int getResultEnd(int i)
+ @Override
+ public int getSize()
{
- return matches.get(i).end;
+ return matches.size();
}
- /**
- * Returns true if no search result matches are held.
- *
- * @return
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultsI#isEmpty()
*/
+ @Override
public boolean isEmpty()
{
return matches.isEmpty();
}
- /**
- * Returns the list of matches.
- *
- * @return
+ /* (non-Javadoc)
+ * @see jalview.datamodel.SearchResultsI#getResults()
*/
- public List<Match> getResults()
+ @Override
+ public List<SearchResultMatchI> getResults()
{
return matches;
}
/**
- * Return the results as a string of characters (bases) prefixed by start
- * position(s). Meant for use when the context ensures that all matches are to
- * regions of the same sequence (otherwise the result is meaningless).
+ * Return the results as a list of matches [seq1/from-to, seq2/from-to, ...]
*
* @return
*/
@Override
public String toString()
{
- StringBuilder result = new StringBuilder(256);
- for (Match m : matches)
- {
- result.append(m.toString());
- }
- return result.toString();
- }
-
- /**
- * Return the results as a string of characters (bases). Meant for use when
- * the context ensures that all matches are to regions of the same sequence
- * (otherwise the result is meaningless).
- *
- * @return
- */
- public String getCharacters()
- {
- StringBuilder result = new StringBuilder(256);
- for (Match m : matches)
- {
- result.append(m.getCharacters());
- }
- return result.toString();
+ return matches == null ? "" : matches.toString();
}
/**
- * Hashcode is has derived from the list of matches. This ensures that when
- * two SearchResults objects satisfy the test for equals(), then they have the
+ * Hashcode is derived from the list of matches. This ensures that when two
+ * SearchResults objects satisfy the test for equals(), then they have the
* same hashcode.
+ *
+ * @see Match#hashCode()
+ * @see java.util.AbstractList#hashCode()
*/
@Override
public int hashCode()
@Override
public boolean equals(Object obj)
{
- if (obj == null || !(obj instanceof SearchResults))
+ if (obj == null || !(obj instanceof SearchResultsI))
{
return false;
}
- SearchResults sr = (SearchResults) obj;
- return ((ArrayList<Match>) this.matches).equals(sr.matches);
+ SearchResultsI sr = (SearchResultsI) obj;
+ return matches.equals(sr.getResults());
}
}
--- /dev/null
+package jalview.datamodel;
+
+import java.util.BitSet;
+import java.util.List;
+
+/**
+ * An interface describing the result of a search or other operation which
+ * highlights matched regions of an alignment
+ */
+public interface SearchResultsI
+{
+
+ /**
+ * Adds one region to the results
+ *
+ * @param seq
+ * Sequence
+ * @param start
+ * int
+ * @param end
+ * int
+ * @return
+ */
+ SearchResultMatchI addResult(SequenceI seq, int start, int end);
+
+ /**
+ * Answers true if the search results include the given sequence (or its
+ * dataset sequence), else false
+ *
+ * @param sequence
+ * @return
+ */
+ boolean involvesSequence(SequenceI sequence);
+
+ /**
+ * Returns an array of [from, to, from, to..] matched columns (base 0) between
+ * the given start and end columns of the given sequence. Returns null if no
+ * matches overlap the specified region.
+ * <p>
+ * Implementations should provide an optimised method to return locations to
+ * highlight on a visible portion of an alignment.
+ *
+ * @param sequence
+ * @param start
+ * first column of range (base 0, inclusive)
+ * @param end
+ * last column of range base 0, inclusive)
+ * @return int[]
+ */
+ int[] getResults(SequenceI sequence, int start, int end);
+
+ /**
+ * Returns the number of matches found
+ *
+ * @return
+ */
+ int getSize();
+
+ /**
+ * Returns true if no search result matches are held.
+ *
+ * @return
+ */
+ boolean isEmpty();
+
+ /**
+ * Returns the list of matches.
+ *
+ * @return
+ */
+ List<SearchResultMatchI> getResults();
+
+ /**
+ * Set bits in a bitfield for all columns in the given sequence collection
+ * that are highlighted
+ *
+ * @param sqcol
+ * the set of sequences to search for highlighted regions
+ * @param bs
+ * bitset to set
+ * @return number of bits set
+ */
+ int markColumns(SequenceCollectionI sqcol, BitSet bs);
+}
\ No newline at end of file
boolean upd = false;
try
{
- ProfileI[] cnsns = AAFrequency.calculate(sequences, startRes,
+ ProfilesI cnsns = AAFrequency.calculate(sequences, startRes,
endRes + 1, showSequenceLogo);
if (consensus != null)
{
c.completeAnnotations(conservation, null, startRes, endRes + 1);
}
- public ProfileI[] consensusData = null;
+ public ProfilesI consensusData = null;
- private void _updateConsensusRow(ProfileI[] cnsns, long nseq)
+ private void _updateConsensusRow(ProfilesI cnsns, long nseq)
{
if (consensus == null)
{
* limitations under the License.
*/
+/*
+ * Copied to Jalview September 2016.
+ * Only the members of this class required for SparseIntArray were copied.
+ * Method binarySearch(short[] array, int size, short value) added to support
+ * SparseShortArray.
+ */
class ContainerHelpers
{
static final boolean[] EMPTY_BOOLEANS = new boolean[0];
while (lo <= hi)
{
final int mid = (lo + hi) >>> 1;
- final int midVal = array[mid];
+ final short midVal = array[mid];
if (midVal < value)
{
lo = mid + 1;
* order in the case of <code>valueAt(int)<code>.
* </p>
*/
+
+/*
+ * Imported into Jalview September 2016
+ * Change log:
+ * Sep 2016 method add(int, int) added for more efficient increment of counts
+ * (a single binary search, rather than one on read and one on write)
+ */
public class SparseIntArray implements Cloneable
{
private int[] mKeys;
* order in the case of <code>valueAt(int)<code>.
* </p>
*/
-/**
- * A copy of SparseShortArray designed to store short values (to minimise space
- * usage).
+
+/*
+ * Added to Jalview September 2016. A copy of SparseIntArray designed to store
+ * short values (to minimise space usage).
* <p>
- * Note that operations append, put, add throw ArithmeticException if the
- * resulting value overflows the range of a short.
+ * Note that operations append, put, add throw ArithmeticException if either the
+ * key or the resulting value overflows the range of a short. Calling code
+ * should trap and handle this, for example by switching to using a
+ * SparseIntArray instead.
*/
public class SparseShortArray implements Cloneable
{
import jalview.datamodel.AlignmentI;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.PDBEntry;
+import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
-import jalview.datamodel.SearchResults.Match;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.httpserver.AbstractRequestHandler;
* expect one matched alignment position, or none
* (if the structure position is not mapped)
*/
- for (Match m : sr.getResults())
+ for (SearchResultMatchI m : sr.getResults())
{
SequenceI seq = m.getSequence();
int start = m.getStart();
toggleHiddenRegions(toggleSeqs, toggleCols);
break;
}
+ case KeyEvent.VK_B:
+ {
+ boolean toggleSel = evt.isControlDown() || evt.isMetaDown();
+ boolean modifyExisting = true; // always modify, don't clear
+ // evt.isShiftDown();
+ boolean invertHighlighted = evt.isAltDown();
+ avc.markHighlightedColumns(invertHighlighted, modifyExisting,
+ toggleSel);
+ break;
+ }
case KeyEvent.VK_PAGE_UP:
if (viewport.getWrapAlignment())
{
viewport.setFollowHighlight(state);
if (state)
{
- alignPanel.scrollToPosition(
- alignPanel.getSeqPanel().seqCanvas.searchResults, false);
+ alignPanel.scrollToPosition(viewport.getSearchResults(), false);
}
}
}
return false;
}
+
+ @Override
+ protected void selectHighlightedColumns_actionPerformed(
+ ActionEvent actionEvent)
+ {
+ // include key modifier check in case user selects from menu
+ avc.markHighlightedColumns(
+ (actionEvent.getModifiers() & ActionEvent.ALT_MASK) != 0,
+ true,
+ (actionEvent.getModifiers() & (ActionEvent.META_MASK | ActionEvent.CTRL_MASK)) != 0);
+ }
}
class PrintThread extends Thread
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.PDBEntry;
import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
* there is no complement, or it is not following highlights, or no mapping
* is found, the result will be empty.
*/
- SearchResults sr = new SearchResults();
+ SearchResultsI sr = new SearchResults();
int verticalOffset = findComplementScrollTarget(sr);
if (!sr.isEmpty())
{
import jalview.api.AlignmentViewPanel;
import jalview.bin.Cache;
import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
* Highlight the given results on the alignment.
*
*/
- public void highlightSearchResults(SearchResults results)
+ public void highlightSearchResults(SearchResultsI results)
{
scrollToPosition(results);
getSeqPanel().seqCanvas.highlightSearchResults(results);
*
* @param results
*/
- public boolean scrollToPosition(SearchResults results)
+ public boolean scrollToPosition(SearchResultsI results)
{
return scrollToPosition(results, 0, true, false);
}
* @param redrawOverview
* @return
*/
- public boolean scrollToPosition(SearchResults searchResults,
+ public boolean scrollToPosition(SearchResultsI searchResults,
boolean redrawOverview)
{
return scrollToPosition(searchResults, 0, redrawOverview, false);
* if true, try to centre the search results horizontally in the view
* @return false if results were not found
*/
- public boolean scrollToPosition(SearchResults results,
+ public boolean scrollToPosition(SearchResultsI results,
int verticalOffset, boolean redrawOverview, boolean centre)
{
int startv, endv, starts, ends;
}
else
{
- return printUnwrapped(pwidth, pheight, pi, pg);
+ return printUnwrapped(pwidth, pheight, pi, pg, pg);
}
}
* @throws PrinterException
* DOCUMENT ME!
*/
- public int printUnwrapped(int pwidth, int pheight, int pi,
- Graphics... pg)
+ /**
+ * Draws the alignment image, including sequence ids, sequences, and
+ * annotation labels and annotations if shown, on either one or two Graphics
+ * context.
+ *
+ * @param pageWidth
+ * @param pageHeight
+ * @param pi
+ * @param idGraphics
+ * the graphics context for sequence ids and annotation labels
+ * @param alignmentGraphics
+ * the graphics context for sequences and annotations (may or may not
+ * be the same context as idGraphics)
+ * @return
+ * @throws PrinterException
+ */
+ public int printUnwrapped(int pageWidth, int pageHeight, int pi,
+ Graphics idGraphics, Graphics alignmentGraphics)
throws PrinterException
{
- boolean isMultiGraphics = pg.length > 1;
- int G0 = 0; // Graphic index of idPanel graphics in multi-graphics mode or
- // entire graphics for non mulit-graphics mode
- int G1 = 0; // Graphic index of alignmentPanel graphics for multi-graphics
- // mode
- if (isMultiGraphics)
- {
- G0 = 0;
- G1 = 1;
- }
-
- int idWidth = getVisibleIdWidth(false);
- FontMetrics fm = getFontMetrics(av.getFont());
- int scaleHeight = av.getCharHeight() + fm.getDescent();
-
- pg[G0].setColor(Color.white);
- pg[G0].fillRect(0, 0, pwidth, pheight);
- pg[G0].setFont(av.getFont());
+ final int idWidth = getVisibleIdWidth(false);
- // //////////////////////////////////
- // / How many sequences and residues can we fit on a printable page?
- int totalRes = (pwidth - idWidth) / av.getCharWidth();
+ /*
+ * Get the horizontal offset to where we draw the sequences.
+ * This is idWidth if using a single Graphics context, else zero.
+ */
+ final int alignmentGraphicsOffset = idGraphics != alignmentGraphics ? 0 : idWidth;
- int totalSeq = (pheight - scaleHeight) / av.getCharHeight() - 1;
+ FontMetrics fm = getFontMetrics(av.getFont());
+ int charHeight = av.getCharHeight();
+ int scaleHeight = charHeight + fm.getDescent();
- int pagesWide = (av.getAlignment().getWidth() / totalRes) + 1;
+ idGraphics.setColor(Color.white);
+ idGraphics.fillRect(0, 0, pageWidth, pageHeight);
+ idGraphics.setFont(av.getFont());
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int startRes;
+ /*
+ * How many sequences and residues can we fit on a printable page?
+ */
+ int totalRes = (pageWidth - idWidth) / av.getCharWidth();
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int endRes;
+ int totalSeq = (pageHeight - scaleHeight) / charHeight - 1;
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int startSeq;
+ int alignmentWidth = av.getAlignment().getWidth();
+ int pagesWide = (alignmentWidth / totalRes) + 1;
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int endSeq;
- startRes = (pi % pagesWide) * totalRes;
- endRes = (startRes + totalRes) - 1;
+ final int startRes = (pi % pagesWide) * totalRes;
+ int endRes = (startRes + totalRes) - 1;
- if (endRes > (av.getAlignment().getWidth() - 1))
+ if (endRes > (alignmentWidth - 1))
{
- endRes = av.getAlignment().getWidth() - 1;
+ endRes = alignmentWidth - 1;
}
- startSeq = (pi / pagesWide) * totalSeq;
- endSeq = startSeq + totalSeq;
+ final int startSeq = (pi / pagesWide) * totalSeq;
+ int endSeq = startSeq + totalSeq;
- if (endSeq > av.getAlignment().getHeight())
+ int alignmentHeight = av.getAlignment().getHeight();
+ if (endSeq > alignmentHeight)
{
- endSeq = av.getAlignment().getHeight();
+ endSeq = alignmentHeight;
}
- int pagesHigh = ((av.getAlignment().getHeight() / totalSeq) + 1)
- * pheight;
+ int pagesHigh = ((alignmentHeight / totalSeq) + 1)
+ * pageHeight;
if (av.isShowAnnotation())
{
pagesHigh += getAnnotationPanel().adjustPanelHeight() + 3;
}
- pagesHigh /= pheight;
+ pagesHigh /= pageHeight;
if (pi >= (pagesWide * pagesHigh))
{
return Printable.NO_SUCH_PAGE;
}
+ final int alignmentDrawnHeight = (endSeq - startSeq) * charHeight
+ + 3;
- // draw Scale
- if (isMultiGraphics)
- {
- pg[G1].translate(0, 0);
- getScalePanel().drawScale(pg[G1], startRes, endRes,
- pwidth - idWidth, scaleHeight);
- pg[G1].translate(-idWidth, scaleHeight);
- }
- else
- {
- pg[G0].translate(idWidth, 0);
- getScalePanel().drawScale(pg[G0], startRes, endRes, pwidth - idWidth,
- scaleHeight);
- pg[G0].translate(-idWidth, scaleHeight);
- }
+ /*
+ * draw the Scale at horizontal offset, then reset to top left (0, 0)
+ */
+ alignmentGraphics.translate(alignmentGraphicsOffset, 0);
+ getScalePanel().drawScale(alignmentGraphics, startRes, endRes,
+ pageWidth - idWidth, scaleHeight);
+ alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
- // //////////////
- // Draw the ids
+ /*
+ * Draw the sequence ids, offset for scale height,
+ * then reset to top left (0, 0)
+ */
+ idGraphics.translate(0, scaleHeight);
+ idGraphics.setFont(getIdPanel().getIdCanvas().getIdfont());
Color currentColor = null;
Color currentTextColor = null;
- if (isMultiGraphics)
- {
- pg[G0].translate(0, scaleHeight);
- }
- pg[G0].setFont(getIdPanel().getIdCanvas().getIdfont());
-
SequenceI seq;
for (int i = startSeq; i < endSeq; i++)
{
if ((av.getSelectionGroup() != null)
&& av.getSelectionGroup().getSequences(null).contains(seq))
{
+ /*
+ * gray out ids of sequences in selection group (if any)
+ */
currentColor = Color.gray;
currentTextColor = Color.black;
}
currentTextColor = Color.black;
}
- pg[G0].setColor(currentColor);
- pg[G0].fillRect(0, (i - startSeq) * av.getCharHeight(), idWidth,
- av.getCharHeight());
+ idGraphics.setColor(currentColor);
+ idGraphics.fillRect(0, (i - startSeq) * charHeight, idWidth,
+ charHeight);
- pg[G0].setColor(currentTextColor);
+ idGraphics.setColor(currentTextColor);
int xPos = 0;
+ String displayId = seq.getDisplayId(av.getShowJVSuffix());
if (av.isRightAlignIds())
{
- fm = pg[G0].getFontMetrics();
+ fm = idGraphics.getFontMetrics();
xPos = idWidth
- - fm.stringWidth(seq.getDisplayId(av.getShowJVSuffix()))
+ - fm.stringWidth(displayId)
- 4;
}
- pg[G0].drawString(seq.getDisplayId(av.getShowJVSuffix()), xPos,
- (((i - startSeq) * av.getCharHeight()) + av.getCharHeight())
- - (av.getCharHeight() / 5));
+ idGraphics.drawString(displayId, xPos,
+ (((i - startSeq) * charHeight) + charHeight)
+ - (charHeight / 5));
}
+ idGraphics.setFont(av.getFont());
+ idGraphics.translate(0, -scaleHeight);
- pg[G0].setFont(av.getFont());
-
+ /*
+ * draw the sequences, offset for scale height, and id width (if using a
+ * single graphics context), then reset to (0, scale height)
+ */
+ alignmentGraphics.translate(alignmentGraphicsOffset, scaleHeight);
+ getSeqPanel().seqCanvas.drawPanel(alignmentGraphics, startRes, endRes,
+ startSeq, endSeq, 0);
+ alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
- // draw main sequence panel
- pg[G0].translate(idWidth, 0);
- if (isMultiGraphics)
+ if (av.isShowAnnotation() && (endSeq == alignmentHeight))
{
- pg[G1].translate(idWidth, 0);
- getSeqPanel().seqCanvas.drawPanel(pg[G1], startRes, endRes,
- startSeq, endSeq, 0);
- }
- else
- {
- getSeqPanel().seqCanvas.drawPanel(pg[G0], startRes, endRes, startSeq,
- endSeq, 0);
- }
+ /*
+ * draw annotation labels; drawComponent() translates by
+ * getScrollOffset(), so compensate for that first;
+ * then reset to (0, scale height)
+ */
+ int offset = getAlabels().getScrollOffset();
+ idGraphics.translate(0, -offset);
+ idGraphics.translate(0, alignmentDrawnHeight);
+ getAlabels().drawComponent(idGraphics, idWidth);
+ idGraphics.translate(0, -alignmentDrawnHeight);
- if (av.isShowAnnotation() && (endSeq == av.getAlignment().getHeight()))
- {
- // draw annotation label - need to offset for current scroll position
- int offset = -getAlabels().getScrollOffset();
- pg[G0].translate(0, offset);
- pg[G0].translate(-idWidth - 3,
- (endSeq - startSeq) * av.getCharHeight() + 3);
- getAlabels().drawComponent(pg[G0], idWidth);
- pg[G0].translate(idWidth + 3, 0);
- pg[G0].translate(0, -offset);
- if (isMultiGraphics)
- {
- // draw annotation - need to offset for current scroll position
- pg[G1].translate(0, offset);
- pg[G1].translate(-idWidth - 3,
- (endSeq - startSeq) * av.getCharHeight() + 3);
- pg[G1].translate(idWidth + 3, 0);
- getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(),
- av, pg[G1], -1, startRes, endRes + 1);
- pg[G1].translate(0, -offset);
- }
- else
- {
- getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(),
- av, pg[G0], -1, startRes, endRes + 1);
- pg[G0].translate(0, -offset);
- }
+ /*
+ * draw the annotations starting at
+ * (idOffset, alignmentHeight) from (0, scaleHeight)
+ */
+ alignmentGraphics.translate(alignmentGraphicsOffset, alignmentDrawnHeight);
+ getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(), av,
+ alignmentGraphics, -1, startRes, endRes + 1);
}
return Printable.PAGE_EXISTS;
aDimension.getWidth(), aDimension.getHeight()
+ boarderBottomOffset, file, imageTitle,
alignFrame, pSessionId, headless);
+ Graphics graphics = im.getGraphics();
if (av.getWrapAlignment())
{
- if (im.getGraphics() != null)
+ if (graphics != null)
{
printWrappedAlignment(aDimension.getWidth(),
aDimension.getHeight() + boarderBottomOffset, 0,
- im.getGraphics());
+ graphics);
im.writeImage();
}
}
else
{
- if (im.getGraphics() != null)
+ if (graphics != null)
{
printUnwrapped(aDimension.getWidth(), aDimension.getHeight(),
- 0, im.getGraphics());
+ 0, graphics, graphics);
im.writeImage();
}
}
* @param verticalOffset
* the number of visible sequences to show above the mapped region
*/
- public void scrollToCentre(SearchResults sr, int verticalOffset)
+ public void scrollToCentre(SearchResultsI sr, int verticalOffset)
{
/*
* To avoid jumpy vertical scrolling (if some sequences are gapped or not
* mapped), we can make the scroll-to location a sequence above the one
* actually mapped.
*/
- SequenceI mappedTo = sr.getResultSequence(0);
+ SequenceI mappedTo = sr.getResults().get(0).getSequence();
List<SequenceI> seqs = av.getAlignment().getSequences();
/*
import jalview.api.FeatureColourI;
import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.schemes.FeatureColour;
start.setValue(new Integer(features[index].getBegin()));
end.setValue(new Integer(features[index].getEnd()));
- SearchResults highlight = new SearchResults();
+ SearchResultsI highlight = new SearchResults();
highlight.addResult(sequences[0], features[index].getBegin(),
features[index].getEnd());
*/
package jalview.gui;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.jbgui.GFinder;
int resIndex = -1;
- SearchResults searchResults;
+ SearchResultsI searchResults;
/**
* Creates a new Finder object with no associated viewport or panel.
KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "Cancel");
getRootPane().getActionMap().put("Cancel", new AbstractAction()
{
+ @Override
public void actionPerformed(ActionEvent e)
{
escapeActionPerformed();
*
* @param e
*/
+ @Override
public void findNext_actionPerformed(ActionEvent e)
{
if (getFocusedViewport())
*
* @param e
*/
+ @Override
public void findAll_actionPerformed(ActionEvent e)
{
if (getFocusedViewport())
* @param e
* DOCUMENT ME!
*/
+ @Override
public void createNewGroup_actionPerformed(ActionEvent e)
{
SequenceI[] seqs = new SequenceI[searchResults.getSize()];
SequenceFeature[] features = new SequenceFeature[searchResults
.getSize()];
- for (int i = 0; i < searchResults.getSize(); i++)
+ int i = 0;
+ for (SearchResultMatchI match : searchResults.getResults())
{
- seqs[i] = searchResults.getResultSequence(i).getDatasetSequence();
+ seqs[i] = match.getSequence().getDatasetSequence();
features[i] = new SequenceFeature(textfield.getText().trim(),
- "Search Results", null, searchResults.getResultStart(i),
- searchResults.getResultEnd(i), "Search Results");
+ "Search Results", null, match.getStart(), match.getEnd(),
+ "Search Results");
+ i++;
}
if (ap.getSeqPanel().seqCanvas.getFeatureRenderer().amendFeatures(seqs,
searchResults = finder.getSearchResults(); // find(regex,
// caseSensitive.isSelected(), )
- Vector idMatch = finder.getIdMatch();
+ Vector<SequenceI> idMatch = finder.getIdMatch();
boolean haveResults = false;
// set or reset the GUI
if ((idMatch.size() > 0))
if (seq > -1 && seq < av.getAlignment().getHeight())
{
SequenceI sequence = av.getAlignment().getSequenceAt(seq);
- StringBuffer tip = new StringBuffer(64);
- seqAnnotReport.createSequenceAnnotationReport(tip, sequence,
+ StringBuilder tip = new StringBuilder(64);
+ seqAnnotReport.createTooltipAnnotationReport(tip, sequence,
av.isShowDBRefs(), av.isShowNPFeats(),
sp.seqCanvas.fr.getMinMax());
setToolTipText(JvSwingUtils.wrapTooltip(true,
public void createSequenceDetailsReport(SequenceI[] sequences)
{
CutAndPasteHtmlTransfer cap = new CutAndPasteHtmlTransfer();
- StringBuffer contents = new StringBuffer();
+ StringBuilder contents = new StringBuilder(128);
for (SequenceI seq : sequences)
{
contents.append("<p><h2>"
seq,
true,
true,
- false,
(ap.getSeqPanel().seqCanvas.fr != null) ? ap
.getSeqPanel().seqCanvas.fr.getMinMax()
: null);
package jalview.gui;
import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.renderer.ScaleRenderer;
AlignViewport av;
- SearchResults searchResults = null;
-
boolean fastPaint = false;
int LABEL_WEST;
// / Highlight search Results once all sequences have been drawn
// ////////////////////////////////////////////////////////
- if (searchResults != null)
+ if (av.hasSearchResults())
{
- int[] visibleResults = searchResults.getResults(nextSeq, startRes,
- endRes);
+ int[] visibleResults = av.getSearchResults().getResults(nextSeq,
+ startRes, endRes);
if (visibleResults != null)
{
for (int r = 0; r < visibleResults.length; r += 2)
* @param results
* DOCUMENT ME!
*/
- public void highlightSearchResults(SearchResults results)
+ public void highlightSearchResults(SearchResultsI results)
{
img = null;
- searchResults = results;
+ av.setSearchResults(results);
repaint();
}
import jalview.commands.EditCommand.Edit;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
-import jalview.datamodel.SearchResults.Match;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
private final SequenceAnnotationReport seqARep;
- StringBuffer tooltipText = new StringBuffer();
+ StringBuilder tooltipText = new StringBuilder();
String tmpString;
StructureSelectionManager ssm;
- SearchResults lastSearchResults;
+ SearchResultsI lastSearchResults;
/**
* Creates a new SeqPanel object.
* the start of the highlighted region.
*/
@Override
- public void highlightSequence(SearchResults results)
+ public void highlightSequence(SearchResultsI results)
{
if (results == null || results.equals(lastSearchResults))
{
seqARep.appendFeatures(tooltipText, rpos, features,
this.ap.getSeqPanel().seqCanvas.fr.getMinMax());
}
- if (tooltipText.length() == 6) // <html></html>
+ if (tooltipText.length() == 6) // <html>
{
setToolTipText(null);
lastTooltip = null;
*
* @param results
*/
- private void setStatusMessage(SearchResults results)
+ private void setStatusMessage(SearchResultsI results)
{
AlignmentI al = this.av.getAlignment();
int sequenceIndex = al.findIndex(results);
return;
}
SequenceI ds = al.getSequenceAt(sequenceIndex).getDatasetSequence();
- for (Match m : results.getResults())
+ for (SearchResultMatchI m : results.getResults())
{
SequenceI seq = m.getSequence();
if (seq.getDatasetSequence() != null)
if (features != null && features.size() > 0)
{
- SearchResults highlight = new SearchResults();
+ SearchResultsI highlight = new SearchResults();
highlight.addResult(sequence, features.get(0).getBegin(), features
.get(0).getEnd());
seqCanvas.highlightSearchResults(highlight);
private boolean cachedPDBExists;
+ private static int MAX_QLENGHT = 7820;
+
public StructureChooser(SequenceI[] selectedSeqs, SequenceI selectedSeq,
AlignmentPanel ap)
{
StringBuilder queryBuilder = new StringBuilder();
Set<String> seqRefs = new LinkedHashSet<String>();
- if (seq.getAllPDBEntries() != null)
+ if (seq.getAllPDBEntries() != null
+ && queryBuilder.length() < MAX_QLENGHT)
{
for (PDBEntry entry : seq.getAllPDBEntries())
{
queryBuilder.append("pdb_id:")
.append(entry.getId().toLowerCase()).append(" OR ");
isPDBRefsFound = true;
- // seqRefs.add(entry.getId());
}
}
}
{
for (DBRefEntry dbRef : seq.getDBRefs())
{
- if (isValidSeqName(getDBRefId(dbRef)))
+ if (isValidSeqName(getDBRefId(dbRef))
+ && queryBuilder.length() < MAX_QLENGHT)
{
if (dbRef.getSource().equalsIgnoreCase(DBRefSource.UNIPROT))
{
exportStarted();
try
{
-
if (outputFile == null)
{
outputFile = getOutputFile();
}
generatedFile = new File(outputFile);
-
- String bioJSON = getBioJSONData();
- String bioJSTemplateString = HTMLOutput.readFileAsString(getCurrentBJSTemplateFile());
- String generatedBioJsWithJalviewAlignmentAsJson = bioJSTemplateString
- .replaceAll("#sequenceData#", bioJSON).toString();
-
- PrintWriter out = new java.io.PrintWriter(new java.io.FileWriter(
- generatedFile));
- out.print(generatedBioJsWithJalviewAlignmentAsJson);
- out.flush();
- out.close();
- exportCompleted();
- setProgressMessage(MessageManager.formatMessage(
- "status.export_complete", "BioJS"));
-
- } catch (NoFileSelectedException ex)
- {
- // do noting if no file was selected
- } catch (OutOfMemoryError err)
+ } catch (NoFileSelectedException e)
{
- System.out.println("########################\n" + "OUT OF MEMORY "
- + outputFile + "\n" + "########################");
- new OOMWarning("Creating Image for " + outputFile, err);
+ setProgressMessage(MessageManager.formatMessage(
+ "status.cancelled_image_export_operation", "BioJS MSA"));
+ return;
} catch (Exception e)
{
setProgressMessage(MessageManager.formatMessage(
- "info.error_creating_file", "HTML"));
+ "info.error_creating_file", "BioJS MSA"));
e.printStackTrace();
+ return;
}
+ new Thread(this).start();
+
}
return generatedFile;
}
+ @Override
+ public void run()
+ {
+ try
+ {
+ String bioJSON = getBioJSONData();
+ String bioJSTemplateString = HTMLOutput
+ .readFileAsString(getCurrentBJSTemplateFile());
+ String generatedBioJsWithJalviewAlignmentAsJson = bioJSTemplateString
+ .replaceAll("#sequenceData#", bioJSON).toString();
+
+ PrintWriter out = new java.io.PrintWriter(new java.io.FileWriter(
+ generatedFile));
+ out.print(generatedBioJsWithJalviewAlignmentAsJson);
+ out.flush();
+ out.close();
+ setProgressMessage(MessageManager.formatMessage(
+ "status.export_complete", "BioJS"));
+ exportCompleted();
+
+ } catch (OutOfMemoryError err)
+ {
+ System.out.println("########################\n" + "OUT OF MEMORY "
+ + generatedFile + "\n" + "########################");
+ new OOMWarning("Creating Image for " + generatedFile, err);
+ } catch (Exception e)
+ {
+ setProgressMessage(MessageManager.formatMessage(
+ "info.error_creating_file", "HTML"));
+ e.printStackTrace();
+ }
+
+ }
+
}
import java.util.Objects;
-public abstract class HTMLOutput
+public abstract class HTMLOutput implements Runnable
{
protected AlignmentPanel ap;
protected IProgressIndicator pIndicator;
- private boolean headless;
-
protected File generatedFile;
public HTMLOutput(AlignmentPanel ap)
}
}
-
public String getBioJSONData()
{
+ return getBioJSONData(null);
+ }
+
+ public String getBioJSONData(AlignExportSettingI exportSettings)
+ {
if (!isEmbedData())
{
return null;
}
- AlignExportSettingI exportSettings = new AlignExportSettingI()
+ if (exportSettings == null)
{
- @Override
- public boolean isExportHiddenSequences()
- {
- return true;
- }
-
- @Override
- public boolean isExportHiddenColumns()
+ exportSettings = new AlignExportSettingI()
{
- return true;
- }
+ @Override
+ public boolean isExportHiddenSequences()
+ {
+ return true;
+ }
- @Override
- public boolean isExportAnnotations()
- {
- return true;
- }
+ @Override
+ public boolean isExportHiddenColumns()
+ {
+ return true;
+ }
- @Override
- public boolean isExportFeatures()
- {
- return true;
- }
+ @Override
+ public boolean isExportAnnotations()
+ {
+ return true;
+ }
- @Override
- public boolean isExportGroups()
- {
- return true;
- }
+ @Override
+ public boolean isExportFeatures()
+ {
+ return true;
+ }
- @Override
- public boolean isCancelled()
- {
- return false;
- }
+ @Override
+ public boolean isExportGroups()
+ {
+ return true;
+ }
- };
+ @Override
+ public boolean isCancelled()
+ {
+ return false;
+ }
+ };
+ }
AlignmentExportData exportData = jalview.gui.AlignFrame
.getAlignmentForExport(JSONFile.FILE_DESC,
ap.getAlignViewport(), exportSettings);
public String getOutputFile() throws NoFileSelectedException
{
String selectedFile = null;
- if (pIndicator != null && !headless)
+ if (pIndicator != null && !isHeadless())
{
pIndicator.setProgressBar(MessageManager.formatMessage(
"status.waiting_for_user_to_select_output_file", "HTML"),
jvFileChooser.setFileView(new JalviewFileView());
jvFileChooser.setDialogTitle(MessageManager
- .getString("label.save_as_biojs_html"));
+ .getString("label.save_as_html"));
jvFileChooser.setToolTipText(MessageManager.getString("action.save"));
int fileChooserOpt = jvFileChooser.showSaveDialog(null);
}
else
{
- pIndicator.setProgressBar(MessageManager.formatMessage(
- "status.cancelled_image_export_operation", "BioJS"),
- pSessionId);
throw new NoFileSelectedException("No file was selected.");
}
return selectedFile;
protected void setProgressMessage(String message)
{
- if (pIndicator != null && !headless)
+ if (pIndicator != null && !isHeadless())
{
pIndicator.setProgressBar(message, pSessionId);
}
*/
package jalview.io;
+import jalview.exceptions.NoFileSelectedException;
import jalview.gui.AlignmentPanel;
import jalview.gui.HTMLOptions;
import jalview.gui.OOMWarning;
public class HtmlSvgOutput extends HTMLOutput
{
- private File generatedFile;
public HtmlSvgOutput(AlignmentPanel ap)
{
}
@Override
- public void exportHTML(String file)
+ public void exportHTML(String outputFile)
{
exportStarted();
try
{
- if (file == null)
+ if (outputFile == null)
{
- file = getOutputFile();
+ outputFile = getOutputFile();
}
- generatedFile = new File(file);
+ generatedFile = new File(outputFile);
+ } catch (NoFileSelectedException e)
+ {
+ setProgressMessage(MessageManager.formatMessage(
+ "status.cancelled_image_export_operation", "HTML"));
+ return;
} catch (Exception e)
{
setProgressMessage(MessageManager.formatMessage(
e.printStackTrace();
return;
}
- new Thread()
- {
- @Override
- public void run()
- {
- try
- {
- setProgressMessage(null);
- setProgressMessage(MessageManager.formatMessage(
- "status.exporting_alignment_as_x_file", "HTML"));
- AlignmentDimension aDimension = ap.getAlignmentDimension();
- SVGGraphics2D idPanelGraphics = new SVGGraphics2D(
- aDimension.getWidth(),
- aDimension.getHeight());
- SVGGraphics2D alignPanelGraphics = new SVGGraphics2D(
- aDimension.getWidth(),
- aDimension.getHeight());
-
- String renderStyle = jalview.bin.Cache.getDefault(
- "HTML_RENDERING", "Prompt each time");
-
- // If we need to prompt, and if the GUI is visible then
- // Prompt for rendering style
- if (renderStyle.equalsIgnoreCase("Prompt each time")
- && !isHeadless())
- {
- HTMLOptions svgOption = new HTMLOptions();
- renderStyle = svgOption.getValue();
-
- if (renderStyle == null || svgOption.cancelled)
- {
- setProgressMessage(MessageManager.formatMessage(
- "status.cancelled_image_export_operation", "HTML"));
- return;
- }
- }
-
- if (renderStyle.equalsIgnoreCase("Lineart"))
- {
- idPanelGraphics.setRenderingHint(SVGHints.KEY_DRAW_STRING_TYPE,
- SVGHints.VALUE_DRAW_STRING_TYPE_VECTOR);
- alignPanelGraphics.setRenderingHint(
- SVGHints.KEY_DRAW_STRING_TYPE,
- SVGHints.VALUE_DRAW_STRING_TYPE_VECTOR);
- }
- if (ap.av.getWrapAlignment())
- {
- printWrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
- alignPanelGraphics);
- }
- else
- {
- printUnwrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
- idPanelGraphics, alignPanelGraphics);
- }
-
- String idPanelSvgData = idPanelGraphics.getSVGDocument();
- String alignPanelSvgData = alignPanelGraphics.getSVGDocument();
- String jsonData = getBioJSONData();
- String htmlData = getHtml(idPanelSvgData, alignPanelSvgData, jsonData,
- ap.av.getWrapAlignment());
- FileOutputStream out = new FileOutputStream(generatedFile);
- out.write(htmlData.getBytes());
- out.flush();
- out.close();
- exportCompleted();
- } catch (OutOfMemoryError err)
- {
- System.out.println("########################\n"
- + "OUT OF MEMORY " + generatedFile + "\n"
- + "########################");
- new OOMWarning("Creating Image for " + generatedFile, err);
- } catch (Exception e)
- {
- e.printStackTrace();
- setProgressMessage(MessageManager.formatMessage(
- "info.error_creating_file", "HTML"));
- }
- setProgressMessage(MessageManager.formatMessage(
- "status.export_complete", "HTML"));
- }
- }.start();
-
+ new Thread(this).start();
}
"Hypertext Markup Language");
}
- public int printUnwrapped(int pwidth, int pheight, int pi, Graphics... pg)
+ public int printUnwrapped(int pwidth, int pheight, int pi,
+ Graphics idGraphics, Graphics alignmentGraphics)
throws PrinterException
{
- return ap.printUnwrapped(pwidth, pheight, pi, pg);
+ return ap.printUnwrapped(pwidth, pheight, pi, idGraphics,
+ alignmentGraphics);
}
public int printWrapped(int pwidth, int pheight, int pi, Graphics... pg)
.append(alignmentSvg).append("</div>");
htmlSvg.append("<script language=\"JavaScript\" type=\"text/javascript\" src=\"http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js\"></script>\n"
+ "<script language=\"JavaScript\" type=\"text/javascript\" src=\"http://ajax.googleapis.com/ajax/libs/jqueryui/1.11.2/jquery-ui.min.js\"></script>\n");
-
}
// javascript for launching file in Jalview
-
htmlSvg.append("<script language=\"JavaScript\">\n");
htmlSvg.append("function openJalviewUsingCurrentUrl(){\n");
htmlSvg.append(" var json = JSON.parse(document.getElementById(\"seqData\").innerHTML);\n");
htmlSvg.append(" document.body.removeChild(myForm);\n");
htmlSvg.append("}\n");
- // jquery facebox for displaying raw BioJSON data");
if (jsonData != null)
{
+ // JQuery FaceBox for displaying raw BioJSON data");
File faceBoxJsFile = new File("examples/javascript/facebox-1.3.js");
try
{
{
return generatedFile;
}
+
+ @Override
+ public void run()
+ {
+ try
+ {
+ setProgressMessage(null);
+ setProgressMessage(MessageManager.formatMessage(
+ "status.exporting_alignment_as_x_file", "HTML"));
+ AlignmentDimension aDimension = ap.getAlignmentDimension();
+ SVGGraphics2D idPanelGraphics = new SVGGraphics2D(
+ aDimension.getWidth(), aDimension.getHeight());
+ SVGGraphics2D alignPanelGraphics = new SVGGraphics2D(
+ aDimension.getWidth(), aDimension.getHeight());
+
+ String renderStyle = jalview.bin.Cache.getDefault("HTML_RENDERING",
+ "Prompt each time");
+
+ // If we need to prompt, and if the GUI is visible then
+ // Prompt for rendering style
+ if (renderStyle.equalsIgnoreCase("Prompt each time") && !isHeadless())
+ {
+ HTMLOptions svgOption = new HTMLOptions();
+ renderStyle = svgOption.getValue();
+
+ if (renderStyle == null || svgOption.cancelled)
+ {
+ setProgressMessage(MessageManager.formatMessage(
+ "status.cancelled_image_export_operation", "HTML"));
+ return;
+ }
+ }
+
+ if (renderStyle.equalsIgnoreCase("Lineart"))
+ {
+ idPanelGraphics.setRenderingHint(SVGHints.KEY_DRAW_STRING_TYPE,
+ SVGHints.VALUE_DRAW_STRING_TYPE_VECTOR);
+ alignPanelGraphics.setRenderingHint(SVGHints.KEY_DRAW_STRING_TYPE,
+ SVGHints.VALUE_DRAW_STRING_TYPE_VECTOR);
+ }
+ if (ap.av.getWrapAlignment())
+ {
+ printWrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
+ alignPanelGraphics);
+ }
+ else
+ {
+ printUnwrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
+ idPanelGraphics, alignPanelGraphics);
+ }
+
+ String idPanelSvgData = idPanelGraphics.getSVGDocument();
+ String alignPanelSvgData = alignPanelGraphics.getSVGDocument();
+ String jsonData = getBioJSONData();
+ String htmlData = getHtml(idPanelSvgData, alignPanelSvgData,
+ jsonData, ap.av.getWrapAlignment());
+ FileOutputStream out = new FileOutputStream(generatedFile);
+ out.write(htmlData.getBytes());
+ out.flush();
+ out.close();
+ setProgressMessage(MessageManager.formatMessage(
+ "status.export_complete", "HTML"));
+ exportCompleted();
+ } catch (OutOfMemoryError err)
+ {
+ System.out.println("########################\n" + "OUT OF MEMORY "
+ + generatedFile + "\n" + "########################");
+ new OOMWarning("Creating Image for " + generatedFile, err);
+ } catch (Exception e)
+ {
+ e.printStackTrace();
+ setProgressMessage(MessageManager.formatMessage(
+ "info.error_creating_file", "HTML"));
+ }
+ }
}
package jalview.io;
import jalview.datamodel.DBRefEntry;
+import jalview.datamodel.DBRefSource;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.io.gff.GffConstants;
+import jalview.util.MessageManager;
import jalview.util.UrlLink;
-import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
*/
public class SequenceAnnotationReport
{
+ private static final String COMMA = ",";
+
+ private static final String ELLIPSIS = "...";
+
+ private static final int MAX_REFS_PER_SOURCE = 4;
+
+ private static final int MAX_SOURCES = 40;
+
+ private static final String[][] PRIMARY_SOURCES = new String[][] {
+ DBRefSource.CODINGDBS, DBRefSource.DNACODINGDBS,
+ DBRefSource.PROTEINDBS };
+
final String linkImageURL;
+ /*
+ * Comparator to order DBRefEntry by Source + accession id (case-insensitive)
+ */
+ private static Comparator<DBRefEntry> comparator = new Comparator<DBRefEntry>()
+ {
+
+ @Override
+ public int compare(DBRefEntry ref1, DBRefEntry ref2)
+ {
+ String s1 = ref1.getSource();
+ String s2 = ref2.getSource();
+ boolean s1Primary = isPrimarySource(s1);
+ boolean s2Primary = isPrimarySource(s2);
+ if (s1Primary && !s2Primary)
+ {
+ return -1;
+ }
+ if (!s1Primary && s2Primary)
+ {
+ return 1;
+ }
+ int comp = s1 == null ? -1 : (s2 == null ? 1 : s1
+ .compareToIgnoreCase(s2));
+ if (comp == 0)
+ {
+ String a1 = ref1.getAccessionId();
+ String a2 = ref2.getAccessionId();
+ comp = a1 == null ? -1 : (a2 == null ? 1 : a1
+ .compareToIgnoreCase(a2));
+ }
+ return comp;
+ }
+
+ private boolean isPrimarySource(String source)
+ {
+ for (String[] primary : PRIMARY_SOURCES)
+ {
+ for (String s : primary)
+ {
+ if (source.equals(s))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ };
+
public SequenceAnnotationReport(String linkImageURL)
{
this.linkImageURL = linkImageURL;
/**
* Append text for the list of features to the tooltip
*
- * @param tooltipText2
+ * @param sb
* @param rpos
* @param features
* @param minmax
*/
- public void appendFeatures(final StringBuffer tooltipText2, int rpos,
+ public void appendFeatures(final StringBuilder sb, int rpos,
List<SequenceFeature> features, Map<String, float[][]> minmax)
{
if (features != null)
{
for (SequenceFeature feature : features)
{
- appendFeature(tooltipText2, rpos, minmax, feature);
+ appendFeature(sb, rpos, minmax, feature);
}
}
}
/**
- * Appends text for one sequence feature to the string buffer
+ * Appends the feature at rpos to the given buffer
*
* @param sb
* @param rpos
* @param minmax
- * {{min, max}, {min, max}} positional and non-positional feature
- * scores for this type
* @param feature
*/
- void appendFeature(final StringBuffer sb, int rpos,
+ void appendFeature(final StringBuilder sb, int rpos,
Map<String, float[][]> minmax, SequenceFeature feature)
{
- if ("disulfide bond".equals(feature.getType()))
+ String tmpString;
+ if (feature.getType().equals("disulfide bond"))
{
if (feature.getBegin() == rpos || feature.getEnd() == rpos)
{
}
if (feature.begin != feature.end)
{
- sb.append(" " + feature.end);
+ sb.append(" ").append(feature.end);
}
if (feature.getDescription() != null
&& !feature.description.equals(feature.getType()))
{
- String tmpString = feature.getDescription();
+ tmpString = feature.getDescription();
String tmp2up = tmpString.toUpperCase();
- final int startTag = tmp2up.indexOf("<HTML>");
+ int startTag = tmp2up.indexOf("<HTML>");
if (startTag > -1)
{
tmpString = tmpString.substring(startTag + 6);
tmp2up = tmp2up.substring(startTag + 6);
}
- // TODO strips off </body> but not <body> - is that intended?
int endTag = tmp2up.indexOf("</BODY>");
if (endTag > -1)
{
// be used, so we must remove < > symbols
tmpString = tmpString.replaceAll("<", "<");
tmpString = tmpString.replaceAll(">", ">");
- sb.append("; ").append(tmpString);
+
+ sb.append("; ");
+ sb.append(tmpString);
}
else
{
}
}
}
-
- /*
- * score should be shown if there is one, and min != max
- * for this feature type (e.g. not all 0)
- */
+ // check score should be shown
if (!Float.isNaN(feature.getScore()))
{
- float[][] rng = (minmax == null) ? null : minmax.get(feature
- .getType());
+ float[][] rng = (minmax == null) ? null : ((float[][]) minmax
+ .get(feature.getType()));
if (rng != null && rng[0] != null && rng[0][0] != rng[0][1])
{
- sb.append(" Score=").append(String.valueOf(feature.getScore()));
+ sb.append(" Score=" + feature.getScore());
}
}
String status = (String) feature.getValue("status");
}
}
}
- appendLinks(sb, feature);
}
/**
return urlSets.values();
}
- public void createSequenceAnnotationReport(final StringBuffer tip,
+ public void createSequenceAnnotationReport(final StringBuilder tip,
SequenceI sequence, boolean showDbRefs, boolean showNpFeats,
Map<String, float[][]> minmax)
{
createSequenceAnnotationReport(tip, sequence, showDbRefs, showNpFeats,
- true, minmax);
+ minmax, false);
}
- public void createSequenceAnnotationReport(final StringBuffer tip,
+ /**
+ * Builds an html formatted report of sequence details and appends it to the
+ * provided buffer.
+ *
+ * @param sb
+ * buffer to append report to
+ * @param sequence
+ * the sequence the report is for
+ * @param showDbRefs
+ * whether to include database references for the sequence
+ * @param showNpFeats
+ * whether to include non-positional sequence features
+ * @param minmax
+ * @param summary
+ * @return
+ */
+ int createSequenceAnnotationReport(final StringBuilder sb,
SequenceI sequence, boolean showDbRefs, boolean showNpFeats,
- boolean tableWrap, Map<String, float[][]> minmax)
+ Map<String, float[][]> minmax, boolean summary)
{
String tmp;
- tip.append("<i>");
+ sb.append("<i>");
int maxWidth = 0;
if (sequence.getDescription() != null)
{
tmp = sequence.getDescription();
- tip.append("<br>" + tmp);
+ sb.append("<br>").append(tmp);
maxWidth = Math.max(maxWidth, tmp.length());
}
SequenceI ds = sequence;
DBRefEntry[] dbrefs = ds.getDBRefs();
if (showDbRefs && dbrefs != null)
{
- for (int i = 0; i < dbrefs.length; i++)
+ // note this sorts the refs held on the sequence!
+ Arrays.sort(dbrefs, comparator);
+ boolean ellipsis = false;
+ String source = null;
+ String lastSource = null;
+ int countForSource = 0;
+ int sourceCount = 0;
+ boolean moreSources = false;
+ int lineLength = 0;
+
+ for (DBRefEntry ref : dbrefs)
+ {
+ source = ref.getSource();
+ if (source == null)
+ {
+ // shouldn't happen
+ continue;
+ }
+ boolean sourceChanged = !source.equals(lastSource);
+ if (sourceChanged)
+ {
+ lineLength = 0;
+ countForSource = 0;
+ sourceCount++;
+ }
+ if (sourceCount > MAX_SOURCES && summary)
+ {
+ ellipsis = true;
+ moreSources = true;
+ break;
+ }
+ lastSource = source;
+ countForSource++;
+ if (countForSource == 1 || !summary)
+ {
+ sb.append("<br>");
+ }
+ if (countForSource <= MAX_REFS_PER_SOURCE || !summary)
+ {
+ String accessionId = ref.getAccessionId();
+ lineLength += accessionId.length() + 1;
+ if (countForSource > 1 && summary)
+ {
+ sb.append(", ").append(accessionId);
+ lineLength++;
+ }
+ else
+ {
+ sb.append(source).append(" ").append(accessionId);
+ lineLength += source.length();
+ }
+ maxWidth = Math.max(maxWidth, lineLength);
+ }
+ if (countForSource == MAX_REFS_PER_SOURCE && summary)
+ {
+ sb.append(COMMA).append(ELLIPSIS);
+ ellipsis = true;
+ }
+ }
+ if (moreSources)
{
- tip.append("<br>");
- tmp = dbrefs[i].getSource() + " " + dbrefs[i].getAccessionId();
- tip.append(tmp);
- maxWidth = Math.max(maxWidth, tmp.length());
+ sb.append("<br>").append(ELLIPSIS).append(COMMA).append(source)
+ .append(COMMA).append(ELLIPSIS);
+ }
+ if (ellipsis)
+ {
+ sb.append("<br>(");
+ sb.append(MessageManager.getString("label.output_seq_details"));
+ sb.append(")");
}
}
- // ADD NON POSITIONAL SEQUENCE INFO
+ /*
+ * add non-positional features if wanted
+ */
SequenceFeature[] features = sequence.getSequenceFeatures();
if (showNpFeats && features != null)
{
{
if (features[i].begin == 0 && features[i].end == 0)
{
- int sz = -tip.length();
- List<SequenceFeature> tfeat = new ArrayList<SequenceFeature>();
- tfeat.add(features[i]);
- appendFeatures(tip, 0, tfeat, minmax);
- sz += tip.length();
+ int sz = -sb.length();
+ appendFeature(sb, 0, minmax, features[i]);
+ sz += sb.length();
maxWidth = Math.max(maxWidth, sz);
}
}
}
+ sb.append("</i>");
+ return maxWidth;
+ }
+
+ public void createTooltipAnnotationReport(final StringBuilder tip,
+ SequenceI sequence, boolean showDbRefs, boolean showNpFeats,
+ Map<String, float[][]> minmax)
+ {
+ int maxWidth = createSequenceAnnotationReport(tip, sequence,
+ showDbRefs, showNpFeats, minmax, true);
- if (tableWrap && maxWidth > 60)
+ if (maxWidth > 60)
{
- tip.insert(0, "<table width=350 border=0><tr><td><i>");
- tip.append("</i></td></tr></table>");
+ // ? not sure this serves any useful purpose
+ // tip.insert(0, "<table width=350 border=0><tr><td>");
+ // tip.append("</td></tr></table>");
}
-
}
}
alignmentProperties();
}
});
+ JMenuItem selectHighlighted = new JMenuItem(
+ MessageManager.getString("action.select_highlighted_columns"));
+ selectHighlighted.setToolTipText(MessageManager
+ .getString("tooltip.select_highlighted_columns"));
+ al = new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent actionEvent)
+ {
+ selectHighlightedColumns_actionPerformed(actionEvent);
+ }
+ };
+ selectHighlighted.addActionListener(al);
JMenu tooltipSettingsMenu = new JMenu(
MessageManager.getString("label.sequence_id_tooltip"));
JMenu autoAnnMenu = new JMenu(
selectMenu.add(grpsFromSelection);
selectMenu.add(deleteGroups);
selectMenu.add(annotationColumn);
+ selectMenu.add(selectHighlighted);
// TODO - determine if the listenToViewSelections button is needed : see bug
// JAL-574
// selectMenu.addSeparator();
// selectMenu.add(listenToViewSelections);
}
+ protected void selectHighlightedColumns_actionPerformed(
+ ActionEvent actionEvent)
+ {
+ // TODO Auto-generated method stub
+
+ }
+
/**
* Generate the reverse sequence (or reverse complement if the flag is true)
* and add it to the alignment
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
-import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ResidueProperties;
import jalview.util.Platform;
private ColumnSelection columnSelection;
- private ProfileI[] hconsensus;
+ private ProfilesI hconsensus;
private Hashtable[] complementConsensus;
{
// TODO? group consensus for cDNA complement
return AAFrequency.extractProfile(
- aa.groupRef.consensusData[column],
+ aa.groupRef.consensusData.get(column),
aa.groupRef.getIgnoreGapsConsensus());
}
// TODO extend annotation row to enable dynamic and static profile data to
}
else
{
- return AAFrequency.extractProfile(hconsensus[column],
+ return AAFrequency.extractProfile(
+hconsensus.get(column),
av_ignoreGapsConsensus);
}
}
res -= ('a' - 'A');
}
- if (consensus == null || j >= consensus.length || consensus[j] == null
+ if (consensus == null || consensus.get(j) == null
|| (threshold != 0 && !aboveThreshold(res, j)))
{
return Color.white;
/*
* test if this is the consensus (or joint consensus) residue
*/
- String max = consensus[j].getModalResidue();
+ String max = consensus.get(j).getModalResidue();
if (max.indexOf(res) > -1)
{
package jalview.schemes;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
/**
* assign the given consensus profile for the colourscheme
*/
- public void setConsensus(ProfileI[] hconsensus);
+ public void setConsensus(ProfilesI hconsensus);
/**
* assign the given conservation to the colourscheme
package jalview.schemes;
import jalview.analysis.Conservation;
-import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
/**
* Colourscheme that takes its colours from some other colourscheme
}
@Override
- public void setConsensus(ProfileI[] consensus)
+ public void setConsensus(ProfilesI consensus)
{
if (colourScheme != null)
{
*/
package jalview.schemes;
+import jalview.datamodel.ProfileI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.util.Comparison;
c -= ('a' - 'A');
}
- if (consensus == null || j >= consensus.length || consensus[j] == null)
+ if (consensus == null || consensus.get(j) == null)
{
return Color.white;
}
double sc = 0;
- if (consensus.length <= j)
- {
- return Color.white;
- }
/*
* test whether this is the consensus (or joint consensus) residue
*/
- boolean matchesConsensus = consensus[j].getModalResidue().contains(
+ ProfileI profile = consensus.get(j);
+ boolean matchesConsensus = profile.getModalResidue().contains(
String.valueOf(c));
if (matchesConsensus)
{
- sc = consensus[j].getPercentageIdentity(ignoreGaps);
+ sc = profile.getPercentageIdentity(ignoreGaps);
if (!Comparison.isGap(c))
{
import jalview.analysis.Conservation;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import jalview.util.ColorUtils;
/*
* Consensus data indexed by column
*/
- ProfileI[] consensus;
+ ProfilesI consensus;
/*
* Conservation string as a char array
residue -= ('a' - 'A');
}
- if (consensus == null || consensus.length < column
- || consensus[column] == null)
+ if (consensus == null)
{
return false;
}
+ ProfileI profile = consensus.get(column);
+
/*
* test whether this is the consensus (or joint consensus) residue
*/
- if (consensus[column].getModalResidue().contains(
- String.valueOf(residue)))
+ if (profile != null
+ && profile.getModalResidue().contains(String.valueOf(residue)))
{
- if (consensus[column].getPercentageIdentity(ignoreGaps) >= threshold)
+ if (profile.getPercentageIdentity(ignoreGaps) >= threshold)
{
return true;
}
* DOCUMENT ME!
*/
@Override
- public void setConsensus(ProfileI[] consensus)
+ public void setConsensus(ProfilesI consensus)
{
if (consensus == null)
{
*/
package jalview.structure;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceI;
public interface SequenceListener
// TODO remove this? never called on SequenceListener type
public void mouseOverSequence(SequenceI sequence, int index, int pos);
- public void highlightSequence(jalview.datamodel.SearchResults results);
+ public void highlightSequence(SearchResultsI results);
// TODO remove this? never called
public void updateColours(SequenceI sequence, int index);
import jalview.datamodel.Annotation;
import jalview.datamodel.PDBEntry;
import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceI;
import jalview.ext.jmol.JmolParser;
import jalview.gui.IProgressIndicator;
return;
}
- SearchResults results = findAlignmentPositionsForStructurePositions(atoms);
+ SearchResultsI results = findAlignmentPositionsForStructurePositions(atoms);
for (Object li : listeners)
{
if (li instanceof SequenceListener)
{
boolean hasSequenceListeners = handlingVamsasMo
|| !seqmappings.isEmpty();
- SearchResults results = null;
+ SearchResultsI results = null;
if (seqPos == -1)
{
seqPos = seq.findPosition(indexpos);
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentOrder;
import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
-import jalview.datamodel.SearchResults.Match;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
/*
* Determine all mappings from this position to mapped sequences.
*/
- SearchResults sr = buildSearchResults(seq, seqpos, mappings);
+ SearchResultsI sr = buildSearchResults(seq, seqpos, mappings);
if (!sr.isEmpty())
{
* @param seqmappings
* @return
*/
- public static SearchResults buildSearchResults(SequenceI seq, int index,
+ public static SearchResultsI buildSearchResults(SequenceI seq, int index,
List<AlignedCodonFrame> seqmappings)
{
- SearchResults results = new SearchResults();
+ SearchResultsI results = new SearchResults();
addSearchResults(results, seq, index, seqmappings);
return results;
}
* @param index
* @param seqmappings
*/
- public static void addSearchResults(SearchResults results, SequenceI seq,
+ public static void addSearchResults(SearchResultsI results, SequenceI seq,
int index, List<AlignedCodonFrame> seqmappings)
{
if (index >= seq.getStart() && index <= seq.getEnd())
*/
List<AlignedCodonFrame> mapping = Arrays
.asList(new AlignedCodonFrame[] { acf });
- SearchResults sr = buildSearchResults(selected,
+ SearchResultsI sr = buildSearchResults(selected,
startResiduePos, mapping);
- for (Match m : sr.getResults())
+ for (SearchResultMatchI m : sr.getResults())
{
mappedStartResidue = m.getStart();
mappedEndResidue = m.getEnd();
}
sr = buildSearchResults(selected, endResiduePos, mapping);
- for (Match m : sr.getResults())
+ for (SearchResultMatchI m : sr.getResults())
{
mappedStartResidue = Math.min(mappedStartResidue,
m.getStart());
* Get the residue position and find the mapped position.
*/
int residuePos = fromSeq.findPosition(col);
- SearchResults sr = buildSearchResults(fromSeq, residuePos, mappings);
- for (Match m : sr.getResults())
+ SearchResultsI sr = buildSearchResults(fromSeq, residuePos, mappings);
+ for (SearchResultMatchI m : sr.getResults())
{
int mappedStartResidue = m.getStart();
int mappedEndResidue = m.getEnd();
import jalview.datamodel.CigarArray;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenSequences;
-import jalview.datamodel.ProfileI;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.ProfilesI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceGroup;
/**
* results of alignment consensus analysis for visible portion of view
*/
- protected ProfileI[] hconsensus = null;
+ protected ProfilesI hconsensus = null;
/**
* results of cDNA complement consensus visible portion of view
}
@Override
- public void setSequenceConsensusHash(ProfileI[] hconsensus)
+ public void setSequenceConsensusHash(ProfilesI hconsensus)
{
this.hconsensus = hconsensus;
}
}
@Override
- public ProfileI[] getSequenceConsensusHash()
+ public ProfilesI getSequenceConsensusHash()
{
return hconsensus;
}
* the SearchResults to add to
* @return the offset (below top of visible region) of the matched sequence
*/
- protected int findComplementScrollTarget(SearchResults sr)
+ protected int findComplementScrollTarget(SearchResultsI sr)
{
final AlignViewportI complement = getCodingComplement();
if (complement == null || !complement.isFollowHighlight())
*/
private boolean selectionIsDefinedGroup = false;
+
@Override
public boolean isSelectionDefinedGroup()
{
return selectionGroup.getContext() == alignment
|| selectionIsDefinedGroup;
}
+
+ /**
+ * null, or currently highlighted results on this view
+ */
+ private SearchResultsI searchResults = null;
+
+ @Override
+ public boolean hasSearchResults()
+ {
+ return searchResults != null;
+ }
+
+ @Override
+ public void setSearchResults(SearchResultsI results)
+ {
+ searchResults = results;
+ }
+
+ @Override
+ public SearchResultsI getSearchResults()
+ {
+ return searchResults;
+ }
}
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.Annotation;
-import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
import jalview.datamodel.SequenceI;
import jalview.schemes.ColourSchemeI;
*/
protected void computeConsensus(AlignmentI alignment)
{
- ProfileI[] hconsensus = new ProfileI[alignment.getWidth()];
SequenceI[] aseqs = getSequences();
- AAFrequency.calculate(aseqs, 0, alignment.getWidth(), hconsensus, true);
+ int width = alignment.getWidth();
+ ProfilesI hconsensus = AAFrequency.calculate(aseqs, width, 0,
+ width, true);
alignViewport.setSequenceConsensusHash(hconsensus);
setColourSchemeConsensus(hconsensus);
/**
* @param hconsensus
*/
- protected void setColourSchemeConsensus(ProfileI[] hconsensus)
+ protected void setColourSchemeConsensus(ProfilesI hconsensus)
{
ColourSchemeI globalColourScheme = alignViewport
.getGlobalColourScheme();
public void updateResultAnnotation(boolean immediate)
{
AlignmentAnnotation consensus = getConsensusAnnotation();
- ProfileI[] hconsensus = (ProfileI[]) getViewportConsensus();
+ ProfilesI hconsensus = (ProfilesI) getViewportConsensus();
if (immediate || !calcMan.isWorking(this) && consensus != null
&& hconsensus != null)
{
* the computed consensus data
*/
protected void deriveConsensus(AlignmentAnnotation consensusAnnotation,
- ProfileI[] hconsensus)
+ ProfilesI hconsensus)
{
+
long nseq = getSequences().length;
- AAFrequency.completeConsensus(consensusAnnotation, hconsensus, 0,
- hconsensus.length, alignViewport.isIgnoreGapsConsensus(),
+ AAFrequency.completeConsensus(consensusAnnotation, hconsensus,
+ hconsensus.getStartColumn(),
+ hconsensus.getEndColumn() + 1,
+ alignViewport.isIgnoreGapsConsensus(),
alignViewport.isShowSequenceLogo(), nseq);
}
*
* @return
*/
- protected Object[] getViewportConsensus()
+ protected Object getViewportConsensus()
{
// TODO convert ComplementConsensusThread to use Profile
return alignViewport.getSequenceConsensusHash();
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Annotation;
import jalview.datamodel.ProfileI;
+import jalview.datamodel.ProfilesI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceI;
SequenceI seq3 = new Sequence("Seq3", "C---G");
SequenceI seq4 = new Sequence("Seq4", "CA--t");
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };
- ProfileI[] result = new ProfileI[seq1.getLength()];
-
- AAFrequency.calculate(seqs, 0, seq1.getLength(), result, false);
+ int width = seq1.getLength();
+ ProfilesI result = AAFrequency.calculate(seqs, width, 0, width,
+ false);
// col 0 is 100% C
- ProfileI col = result[0];
+ ProfileI col = result.get(0);
assertEquals(100f, col.getPercentageIdentity(false));
assertEquals(100f, col.getPercentageIdentity(true));
assertEquals(4, col.getMaxCount());
assertNull(col.getCounts());
// col 1 is 75% A
- col = result[1];
+ col = result.get(1);
assertEquals(75f, col.getPercentageIdentity(false));
assertEquals(100f, col.getPercentageIdentity(true));
assertEquals(3, col.getMaxCount());
assertEquals("A", col.getModalResidue());
// col 2 is 50% G 50% C or 25/25 counting gaps
- col = result[2];
+ col = result.get(2);
assertEquals(25f, col.getPercentageIdentity(false));
assertEquals(50f, col.getPercentageIdentity(true));
assertEquals(1, col.getMaxCount());
assertEquals("CG", col.getModalResidue());
// col 3 is all gaps
- col = result[3];
+ col = result.get(3);
assertEquals(0f, col.getPercentageIdentity(false));
assertEquals(0f, col.getPercentageIdentity(true));
assertEquals(0, col.getMaxCount());
assertEquals("", col.getModalResidue());
// col 4 is 75% T 25% G
- col = result[4];
+ col = result.get(4);
assertEquals(75f, col.getPercentageIdentity(false));
assertEquals(75f, col.getPercentageIdentity(true));
assertEquals(3, col.getMaxCount());
SequenceI seq3 = new Sequence("Seq3", "C--G");
SequenceI seq4 = new Sequence("Seq4", "CA-t");
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };
- ProfileI[] result = new ProfileI[seq1.getLength()];
+ int width = seq1.getLength();
+ ProfilesI result = AAFrequency.calculate(seqs, width, 0, width,
+ true);
- AAFrequency.calculate(seqs, 0, seq1.getLength(), result, true);
- ProfileI profile = result[0];
+ ProfileI profile = result.get(0);
assertEquals(4, profile.getCounts().getCount('C'));
assertEquals(4, profile.getHeight());
assertEquals(4, profile.getNonGapped());
- profile = result[1];
+ profile = result.get(1);
assertEquals(3, profile.getCounts().getCount('A'));
assertEquals(4, profile.getHeight());
assertEquals(3, profile.getNonGapped());
- profile = result[2];
+ profile = result.get(2);
assertEquals(1, profile.getCounts().getCount('C'));
assertEquals(1, profile.getCounts().getCount('G'));
assertEquals(4, profile.getHeight());
assertEquals(2, profile.getNonGapped());
- profile = result[3];
+ profile = result.get(3);
assertEquals(3, profile.getCounts().getCount('T'));
assertEquals(1, profile.getCounts().getCount('G'));
assertEquals(4, profile.getHeight());
SequenceI seq3 = new Sequence("Seq3", "C--G");
SequenceI seq4 = new Sequence("Seq4", "CA-t");
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };
- ProfileI[] result = new ProfileI[seq1.getLength()];
- // ensure class loaded and initialized
- AAFrequency.calculate(seqs, 0, seq1.getLength(), result, true);
+ // ensure class loaded and initialised
+ int width = seq1.getLength();
+ AAFrequency.calculate(seqs, width, 0, width, true);
+
int reps = 100000;
long start = System.currentTimeMillis();
for (int i = 0; i < reps; i++)
{
- AAFrequency.calculate(seqs, 0, seq1.getLength(), result, true);
+ AAFrequency.calculate(seqs, width, 0, width, true);
}
System.out.println(System.currentTimeMillis() - start);
}
SequenceI seq3 = new Sequence("Seq3", "C---G");
SequenceI seq4 = new Sequence("Seq4", "CA--t");
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };
- ProfileI[] profiles = new ProfileI[seq1.getLength()];
- AAFrequency.calculate(seqs, 0, seq1.getLength(), profiles, true);
+ int width = seq1.getLength();
+ ProfilesI profiles = AAFrequency.calculate(seqs, width, 0, width, true);
AlignmentAnnotation consensus = new AlignmentAnnotation("Consensus",
- "PID", new Annotation[seq1.getLength()]);
+ "PID", new Annotation[width]);
AAFrequency
.completeConsensus(consensus, profiles, 0, 5, false, true, 4);
SequenceI seq3 = new Sequence("Seq3", "C---G");
SequenceI seq4 = new Sequence("Seq4", "CA--t");
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };
- ProfileI[] profiles = new ProfileI[seq1.getLength()];
- AAFrequency.calculate(seqs, 0, seq1.getLength(), profiles, true);
+ int width = seq1.getLength();
+ ProfilesI profiles = AAFrequency.calculate(seqs, width, 0, width, true);
AlignmentAnnotation consensus = new AlignmentAnnotation("Consensus",
- "PID", new Annotation[seq1.getLength()]);
+ "PID", new Annotation[width]);
AAFrequency
.completeConsensus(consensus, profiles, 0, 5, true, false, 4);
import jalview.datamodel.Annotation;
import jalview.datamodel.DBRefEntry;
import jalview.datamodel.Mapping;
-import jalview.datamodel.SearchResults;
-import jalview.datamodel.SearchResults.Match;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
assertEquals(1, mappings.size());
// map G to GGG
- SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, mappings);
+ SearchResultsI sr = MappingUtils.buildSearchResults(pep1, 1, mappings);
assertEquals(1, sr.getResults().size());
- Match m = sr.getResults().get(0);
+ SearchResultMatchI m = sr.getResults().get(0);
assertSame(cds1Dss, m.getSequence());
assertEquals(1, m.getStart());
assertEquals(3, m.getEnd());
List<AlignedCodonFrame> pep1CdsMappings = MappingUtils
.findMappingsForSequence(cds.getSequenceAt(0), pep1Mappings);
assertEquals(1, pep1CdsMappings.size());
- SearchResults sr = MappingUtils.buildSearchResults(pep1, 1,
+ SearchResultsI sr = MappingUtils.buildSearchResults(pep1, 1,
pep1CdsMappings);
assertEquals(1, sr.getResults().size());
- Match m = sr.getResults().get(0);
+ SearchResultMatchI m = sr.getResults().get(0);
assertEquals(cds.getSequenceAt(0).getDatasetSequence(), m.getSequence());
assertEquals(1, m.getStart());
assertEquals(3, m.getEnd());
assertEquals(1, mappings.size());
// map G to GGG
- SearchResults sr = MappingUtils.buildSearchResults(pep3, 1, mappings);
+ SearchResultsI sr = MappingUtils.buildSearchResults(pep3, 1, mappings);
assertEquals(1, sr.getResults().size());
- Match m = sr.getResults().get(0);
+ SearchResultMatchI m = sr.getResults().get(0);
assertSame(cds.getSequenceAt(0).getDatasetSequence(), m.getSequence());
assertEquals(1, m.getStart());
assertEquals(3, m.getEnd());
--- /dev/null
+package jalview.analysis;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertSame;
+import static org.testng.Assert.assertTrue;
+
+import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResultsI;
+import jalview.datamodel.Sequence;
+import jalview.gui.AlignFrame;
+import jalview.io.FileLoader;
+import jalview.io.FormatAdapter;
+
+import java.util.List;
+
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+public class FinderTest
+{
+ private AlignFrame af;
+
+ private AlignmentI al;
+
+ @BeforeClass(groups = "Functional")
+ public void setUp()
+ {
+ String seqData = "seq1 ABCD--EF-GHI\n" + "seq2 A--BCDefHI\n"
+ + "seq3 --bcdEFH\n" + "seq4 aa---aMMMMMaaa\n";
+ af = new FileLoader().LoadFileWaitTillLoaded(seqData,
+ FormatAdapter.PASTE);
+ al = af.getViewport().getAlignment();
+ }
+
+ /**
+ * Test for find all matches of a regular expression
+ */
+ @Test(groups = "Functional")
+ public void testFindAll_regex()
+ {
+ Finder f = new Finder(al, null);
+ f.setFindAll(true);
+ f.find("E.H"); // 'E, any character, H'
+
+ // should match seq2 efH and seq3 EFH
+ SearchResultsI sr = f.getSearchResults();
+ assertEquals(sr.getSize(), 2);
+ List<SearchResultMatchI> matches = sr.getResults();
+ assertSame(al.getSequenceAt(1), matches.get(0).getSequence());
+ assertSame(al.getSequenceAt(2), matches.get(1).getSequence());
+ assertEquals(matches.get(0).getStart(), 5);
+ assertEquals(matches.get(0).getEnd(), 7);
+ assertEquals(matches.get(1).getStart(), 4);
+ assertEquals(matches.get(1).getEnd(), 6);
+ }
+
+ /**
+ * Test for (undocumented) find residue by position
+ */
+ @Test(groups = "Functional")
+ public void testFind_residueNumber()
+ {
+ Finder f = new Finder(al, null);
+ f.setFindAll(true);
+ f.find("9");
+
+ // seq1 and seq4 have 9 residues; no match in other sequences
+ SearchResultsI sr = f.getSearchResults();
+ assertEquals(sr.getSize(), 2);
+ List<SearchResultMatchI> matches = sr.getResults();
+ assertSame(al.getSequenceAt(0), matches.get(0).getSequence());
+ assertSame(al.getSequenceAt(3), matches.get(1).getSequence());
+ assertEquals(matches.get(0).getStart(), 9);
+ assertEquals(matches.get(0).getEnd(), 9);
+ assertEquals(matches.get(1).getStart(), 9);
+ assertEquals(matches.get(1).getEnd(), 9);
+ }
+
+ /**
+ * Test for find next action
+ */
+ @Test(groups = "Functional")
+ public void testFindNext()
+ {
+ /*
+ * start at second sequence; resIndex of -1
+ * means sequence id / description is searched
+ */
+ Finder f = new Finder(al, null, 1, -1);
+ f.find("e"); // matches id
+
+ assertTrue(f.getSearchResults().isEmpty());
+ assertEquals(f.getIdMatch().size(), 1);
+ assertSame(f.getIdMatch().get(0), al.getSequenceAt(1));
+
+ // resIndex is now 0 - for use in next find next
+ assertEquals(f.getResIndex(), 0);
+ f = new Finder(al, null, 1, 0);
+ f.find("e"); // matches in sequence
+ assertTrue(f.getIdMatch().isEmpty());
+ assertEquals(f.getSearchResults().getSize(), 1);
+ List<SearchResultMatchI> matches = f.getSearchResults().getResults();
+ assertEquals(matches.get(0).getStart(), 5);
+ assertEquals(matches.get(0).getEnd(), 5);
+ assertSame(matches.get(0).getSequence(), al.getSequenceAt(1));
+ // still in the second sequence
+ assertEquals(f.getSeqIndex(), 1);
+ // next residue position to search from is 5
+ // (used as base 0 by RegEx so the same as 6 if base 1)
+ assertEquals(f.getResIndex(), 5);
+
+ // find next from end of sequence - finds next sequence id
+ f = new Finder(al, null, 1, 5);
+ f.find("e");
+ assertEquals(f.getIdMatch().size(), 1);
+ assertSame(f.getIdMatch().get(0), al.getSequenceAt(2));
+ }
+
+ /**
+ * Test for matching within sequence descriptions
+ */
+ @Test(groups = "Functional")
+ public void testFindAll_inDescription()
+ {
+ AlignmentI al2 = new Alignment(al);
+ al2.getSequenceAt(0).setDescription("BRAF");
+ al2.getSequenceAt(1).setDescription("braf");
+ Finder f = new Finder(al2, null);
+ f.setFindAll(true);
+ f.setIncludeDescription(true);
+
+ f.find("rAF");
+ assertEquals(f.getIdMatch().size(), 2);
+ assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
+ assertSame(f.getIdMatch().get(1), al2.getSequenceAt(1));
+ assertTrue(f.getSearchResults().isEmpty());
+
+ /*
+ * case sensitive
+ */
+ f = new Finder(al2, null);
+ f.setFindAll(true);
+ f.setCaseSensitive(true);
+ f.setIncludeDescription(true);
+
+ f.find("RAF");
+ assertEquals(f.getIdMatch().size(), 1);
+ assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
+ assertTrue(f.getSearchResults().isEmpty());
+
+ /*
+ * match sequence id, description and sequence!
+ */
+ al2.getSequenceAt(0).setDescription("the efh sequence");
+ al2.getSequenceAt(0).setName("mouseEFHkinase");
+ al2.getSequenceAt(1).setName("humanEFHkinase");
+ f = new Finder(al2, null);
+ f.setFindAll(true);
+ f.setIncludeDescription(true);
+
+ /*
+ * sequence matches should have no duplicates
+ */
+ f.find("EFH");
+ assertEquals(f.getIdMatch().size(), 2);
+ assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
+ assertSame(f.getIdMatch().get(1), al2.getSequenceAt(1));
+
+ assertEquals(f.getSearchResults().getSize(), 2);
+ SearchResultMatchI match = f.getSearchResults().getResults().get(0);
+ assertSame(al2.getSequenceAt(1), match.getSequence());
+ assertEquals(5, match.getStart());
+ assertEquals(7, match.getEnd());
+ match = f.getSearchResults().getResults().get(1);
+ assertSame(al2.getSequenceAt(2), match.getSequence());
+ assertEquals(4, match.getStart());
+ assertEquals(6, match.getEnd());
+ }
+
+ /**
+ * Test for matching within sequence ids
+ */
+ @Test(groups = "Functional")
+ public void testFindAll_sequenceIds()
+ {
+ Finder f = new Finder(al, null);
+ f.setFindAll(true);
+
+ /*
+ * case insensitive
+ */
+ f.find("SEQ1");
+ assertEquals(f.getIdMatch().size(), 1);
+ assertSame(f.getIdMatch().get(0), al.getSequenceAt(0));
+ assertTrue(f.getSearchResults().isEmpty());
+
+ /*
+ * case sensitive
+ */
+ f = new Finder(al, null);
+ f.setFindAll(true);
+ f.setCaseSensitive(true);
+ f.find("SEQ1");
+ assertTrue(f.getSearchResults().isEmpty());
+
+ /*
+ * match both sequence id and sequence
+ */
+ AlignmentI al2 = new Alignment(al);
+ al2.addSequence(new Sequence("aBz", "xyzabZpqrAbZ"));
+ f = new Finder(al2, null);
+ f.setFindAll(true);
+ f.find("ABZ");
+ assertEquals(f.getIdMatch().size(), 1);
+ assertSame(f.getIdMatch().get(0), al2.getSequenceAt(4));
+ assertEquals(f.getSearchResults().getSize(), 2);
+ SearchResultMatchI match = f.getSearchResults().getResults().get(0);
+ assertSame(al2.getSequenceAt(4), match.getSequence());
+ assertEquals(4, match.getStart());
+ assertEquals(6, match.getEnd());
+ match = f.getSearchResults().getResults().get(1);
+ assertSame(al2.getSequenceAt(4), match.getSequence());
+ assertEquals(10, match.getStart());
+ assertEquals(12, match.getEnd());
+ }
+
+ /**
+ * Test finding all matches of a sequence pattern in an alignment
+ */
+ @Test(groups = "Functional")
+ public void testFindAll_simpleMatch()
+ {
+ Finder f = new Finder(al, null);
+ f.setFindAll(true);
+
+ /*
+ * case insensitive first
+ */
+ f.find("EfH");
+ SearchResultsI searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 2);
+ SearchResultMatchI match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(1), match.getSequence());
+ assertEquals(5, match.getStart());
+ assertEquals(7, match.getEnd());
+ match = searchResults.getResults().get(1);
+ assertSame(al.getSequenceAt(2), match.getSequence());
+ assertEquals(4, match.getStart());
+ assertEquals(6, match.getEnd());
+
+ /*
+ * case sensitive
+ */
+ f = new Finder(al, null);
+ f.setFindAll(true);
+ f.setCaseSensitive(true);
+ f.find("BC");
+ searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 2);
+ match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(0), match.getSequence());
+ assertEquals(2, match.getStart());
+ assertEquals(3, match.getEnd());
+ match = searchResults.getResults().get(1);
+ assertSame(al.getSequenceAt(1), match.getSequence());
+ assertEquals(2, match.getStart());
+ assertEquals(3, match.getEnd());
+ }
+
+ /**
+ * Test for JAL-2302 to verify that sub-matches are not included in a find all
+ * result
+ */
+ @Test(groups = "Functional")
+ public void testFind_maximalResultOnly()
+ {
+ Finder f = new Finder(al, null);
+ f.setFindAll(true);
+ f.find("M+");
+ SearchResultsI searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 1);
+ SearchResultMatchI match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(3), match.getSequence());
+ assertEquals(4, match.getStart()); // dataset sequence positions
+ assertEquals(8, match.getEnd()); // base 1
+ }
+}
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
+import jalview.analysis.Finder;
+import jalview.api.AlignViewControllerI;
+import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.gui.AlignFrame;
+import jalview.io.FileLoader;
+import jalview.io.FormatAdapter;
+import java.util.Arrays;
import java.util.BitSet;
import org.testng.annotations.Test;
assertEquals(0, seqCount);
assertEquals(0, bs.cardinality());
}
+
+ /**
+ * shameless copy of test data from findFeature for testing mark columns from
+ * highlight
+ */
+ @Test(groups = "Functional")
+ public void testSelectColumnsWithHighlight()
+ {
+ AlignFrame af = new FileLoader().LoadFileWaitTillLoaded(
+ "seq1 aMMMaaaaaaaaaaaaaaaa\n" + "seq2 aaaMMMMMMMaaaaaaaaaa\n"
+ + "seq3 aaaaaaaaaaMMMMMaaaaa\n"
+ + "seq4 aaaaaaaaaaaaaaaaaaaa\n", FormatAdapter.PASTE);
+
+ SearchResultsI sr = new SearchResults();
+ SequenceI[] sqs = af.getViewport().getAlignment().getSequencesArray();
+ SequenceI seq1 = sqs[0];
+ SequenceI seq2 = sqs[1];
+ SequenceI seq3 = sqs[2];
+ SequenceI seq4 = sqs[3];
+
+ /*
+ * features start/end are base 1
+ */
+ sr.addResult(seq1, 2, 4);
+ sr.addResult(seq2, 4, 10);
+ sr.addResult(seq3, 11, 15);
+
+ /*
+ * test Match/Find works first
+ */
+ Finder f = new Finder(af.getViewport().getAlignment(), null);
+ f.setFindAll(true);
+ f.setCaseSensitive(true);
+ f.find("M+");
+ assertEquals(
+ "Finder found different set of results to manually created SearchResults",
+ sr, f.getSearchResults());
+
+ /*
+ * now check simple mark columns from find operation
+ */
+ af.getViewport().setSearchResults(sr);
+ AlignViewControllerI avc = af.avc;
+
+ avc.markHighlightedColumns(false, false, false);
+ assertTrue("Didn't select highlighted columns", Arrays.deepEquals(af
+ .getViewport().getColumnSelection().getSelectedRanges()
+ .toArray(), new int[][] { { 1, 14 } }));
+ }
}
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
-import jalview.datamodel.SearchResults.Match;
-
import org.testng.annotations.Test;
public class MatchTest
@Test(groups = { "Functional" })
public void testToString()
{
- SequenceI seq = new Sequence("", "abcdefghijklm");
- Match m = new SearchResults().new Match(seq, 3, 5);
- assertEquals("2cde", m.toString());
- }
-
- @Test(groups = { "Functional" })
- public void testGetCharacters()
- {
- SequenceI seq = new Sequence("", "abcdefghijklm");
- Match m = new SearchResults().new Match(seq, 3, 5);
- assertEquals("cde", m.getCharacters());
+ SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
+ SearchResultMatchI m = new SearchResults().new Match(seq, 3, 5);
+ assertEquals("Seq1/3-5", m.toString());
}
@Test(groups = { "Functional" })
{
SequenceI seq1 = new Sequence("", "abcdefghijklm");
SequenceI seq2 = new Sequence("", "abcdefghijklm");
- SearchResults sr1 = new SearchResults();
- SearchResults sr2 = new SearchResults();
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
assertFalse(sr1.equals(null));
assertFalse(sr1.equals(seq1));
/*
* same match but on different sequences - not equal
*/
- SearchResults sr3 = new SearchResults();
+ SearchResultsI sr3 = new SearchResults();
sr3.addResult(seq2, 1, 1);
assertFalse(sr1.equals(sr3));
assertFalse(sr3.equals(sr1));
import static org.testng.AssertJUnit.assertSame;
import static org.testng.AssertJUnit.assertTrue;
-import jalview.datamodel.SearchResults.Match;
+import java.util.BitSet;
+import org.junit.Assert;
import org.testng.annotations.Test;
public class SearchResultsTest
@Test(groups = { "Functional" })
public void testToString()
{
- SequenceI seq = new Sequence("", "abcdefghijklm");
- SearchResults sr = new SearchResults();
+ SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
+ SearchResultsI sr = new SearchResults();
sr.addResult(seq, 1, 1);
- assertEquals("0a", sr.toString());
+ assertEquals("[Seq1/1-1]", sr.toString());
sr.addResult(seq, 3, 5);
- assertEquals("0a2cde", sr.toString());
+ assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
- seq = new Sequence("", "pqrstuvwxy");
+ seq = new Sequence("Seq2", "pqrstuvwxy");
sr.addResult(seq, 6, 7);
- assertEquals("0a2cde5uv", sr.toString());
- }
-
- @Test(groups = { "Functional" })
- public void testGetCharacters()
- {
- SequenceI seq = new Sequence("", "abcdefghijklm");
- SearchResults sr = new SearchResults();
- sr.addResult(seq, 1, 1);
- assertEquals("a", sr.getCharacters());
- sr.addResult(seq, 3, 5);
- assertEquals("acde", sr.getCharacters());
-
- seq = new Sequence("", "pqrstuvwxy");
- sr.addResult(seq, 6, 7);
- assertEquals("acdeuv", sr.getCharacters());
+ assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
}
@Test(groups = { "Functional" })
public void testEquals()
{
SequenceI seq1 = new Sequence("", "abcdefghijklm");
- SearchResults sr1 = new SearchResults();
- SearchResults sr2 = new SearchResults();
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
assertFalse(sr1.equals(null)); // null object
assertFalse(sr1.equals(seq1)); // wrong type
assertTrue(sr2.equals(sr1)); // reflexive
/*
- * only one result is not empty
+ * if only one result is not empty
*/
sr1.addResult(seq1, 1, 1);
assertTrue(sr1.equals(sr1));
{
SequenceI seq1 = new Sequence("", "abcdefghijklm");
SequenceI seq2 = new Sequence("", "abcdefghijklm");
- SearchResults sr1 = new SearchResults();
- SearchResults sr2 = new SearchResults();
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
sr1.addResult(seq1, 1, 1);
sr2.addResult(seq2, 1, 1);
public void testEquals_orderDiffers()
{
SequenceI seq1 = new Sequence("", "abcdefghijklm");
- SearchResults sr1 = new SearchResults();
- SearchResults sr2 = new SearchResults();
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
sr1.addResult(seq1, 1, 1);
sr1.addResult(seq1, 2, 2);
public void testHashcode()
{
SequenceI seq1 = new Sequence("", "abcdefghijklm");
- SearchResults sr1 = new SearchResults();
- SearchResults sr2 = new SearchResults();
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
/*
* both empty
public void testMatchConstructor()
{
SequenceI seq1 = new Sequence("", "abcdefghijklm");
- Match m = new SearchResults().new Match(seq1, 2, 5);
+ SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
assertSame(seq1, m.getSequence());
assertEquals(2, m.getStart());
assertEquals(5, m.getEnd());
assertEquals(2, m.getStart());
assertEquals(5, m.getEnd());
}
+
+ /**
+ * test markColumns for creating column selections
+ */
+ @Test(groups = { "Functional" })
+ public void testMarkColumns()
+ {
+ int marked = 0;
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SequenceI seq2 = new Sequence("", "abcdefghijklm");
+ SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
+ s1g.addSequence(seq1, false);
+ s2g.addSequence(seq2, false);
+ sallg.addSequence(seq1, false);
+ sallg.addSequence(seq2, false);
+
+ SearchResultsI sr = new SearchResults();
+ BitSet bs = new BitSet();
+
+ SearchResultMatchI srm = null;
+ srm = sr.addResult(seq1, 1, 1);
+ Assert.assertNotNull("addResult didn't return Match", srm);
+ srm = sr.addResult(seq2, 1, 2);
+ assertEquals("Sequence reference not set", seq2, srm.getSequence());
+ assertEquals("match start incorrect", 1, srm.getStart());
+ assertEquals("match end incorrect", 2, srm.getEnd());
+
+ // set start/end range for groups to cover matches
+
+ s1g.setStartRes(0);
+ s1g.setEndRes(5);
+ s2g.setStartRes(0);
+ s2g.setEndRes(5);
+ sallg.setStartRes(0);
+ sallg.setEndRes(5);
+
+ /*
+ * just seq1
+ */
+ marked = sr.markColumns(s1g, bs);
+ // check the bitset cardinality before checking the return value
+ assertEquals("Didn't mark expected number", 1, bs.cardinality());
+ assertEquals("Didn't return count of number of bits marked", 1, marked);
+ assertTrue("Didn't mark expected position", bs.get(0));
+ // now check return value for marking the same again
+ assertEquals(
+ "Didn't count number of bits marked for existing marked set",
+ 0,
+ sr.markColumns(s1g, bs));
+ bs.clear();
+
+ /*
+ * just seq2
+ */
+ marked = sr.markColumns(s2g, bs);
+ assertEquals("Didn't mark expected number", 2, bs.cardinality());
+ assertEquals("Didn't return count of number of bits marked", 2, marked);
+ assertTrue("Didn't mark expected position (1)", bs.get(0));
+ assertTrue("Didn't mark expected position (2)", bs.get(1));
+
+ /*
+ * both seq1 and seq2
+ * should be same as seq2
+ */
+ BitSet allbs = new BitSet();
+ assertEquals(2, sr.markColumns(sallg, allbs));
+ assertEquals(bs, allbs);
+
+ // now check range selection
+
+ /*
+ * limit s2g to just the second column, sallg to the first column
+ */
+ s2g.setStartRes(1);
+ s2g.setEndRes(1);
+ sallg.setEndRes(0);
+ BitSet tbs = new BitSet();
+ assertEquals("Group start/end didn't select columns to mark",1, sr.markColumns(s2g, tbs));
+ assertEquals("Group start/end didn't select columns to mark", 1, sr.markColumns(sallg, tbs));
+ assertEquals(
+ "Didn't set expected number of columns in total for two successive marks",
+ 2, tbs.cardinality());
+ }
}
import jalview.datamodel.Annotation;
import jalview.datamodel.PDBEntry;
import jalview.datamodel.PDBEntry.Type;
+import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceI;
import jalview.io.FileLoader;
af.getViewport().setGlobalColourScheme(cs);
assertFalse(cs.conservationApplied());
}
+
+ @Test(groups = { "Functional" })
+ public void testSetGetHasSearchResults()
+ {
+ AlignFrame af = new FileLoader().LoadFileWaitTillLoaded(
+ "examples/uniref50.fa", FormatAdapter.FILE);
+ SearchResultsI sr = new SearchResults();
+ SequenceI s1 = af.getViewport().getAlignment().getSequenceAt(0);
+
+ // create arbitrary range on first sequence
+ sr.addResult(s1, s1.getStart() + 10, s1.getStart() + 15);
+
+ // test set
+ af.getViewport().setSearchResults(sr);
+ // has -> true
+ assertTrue(af.getViewport().hasSearchResults());
+ // get == original
+ assertEquals(sr, af.getViewport().getSearchResults());
+
+ // set(null) results in has -> false
+
+ af.getViewport().setSearchResults(null);
+ assertFalse(af.getViewport().hasSearchResults());
+ }
}
public void testAppendFeature_disulfideBond()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
sb.append("123456");
SequenceFeature sf = new SequenceFeature("disulfide bond", "desc", 1,
3, 1.2f, "group");
public void testAppendFeature_status()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL", "Fe2-S", 1, 3,
Float.NaN, "group");
sf.setStatus("Confirmed");
public void testAppendFeature_withScore()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL", "Fe2-S", 1, 3, 1.3f,
"group");
public void testAppendFeature_noScore()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL", "Fe2-S", 1, 3,
Float.NaN, "group");
public void testAppendFeature_clinicalSignificance()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL", "Fe2-S", 1, 3,
Float.NaN, "group");
sf.setValue("clinical_significance", "Benign");
public void testAppendFeature_withScoreStatusClinicalSignificance()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL", "Fe2-S", 1, 3, 1.3f,
"group");
sf.setStatus("Confirmed");
public void testAppendFeature_DescEqualsType()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL", "METAL", 1, 3,
Float.NaN, "group");
public void testAppendFeature_stripHtml()
{
SequenceAnnotationReport sar = new SequenceAnnotationReport(null);
- StringBuffer sb = new StringBuffer();
+ StringBuilder sb = new StringBuilder();
SequenceFeature sf = new SequenceFeature("METAL",
"<html><body>hello<em>world</em></body></html>", 1, 3,
Float.NaN, "group");
import jalview.datamodel.Profile;
import jalview.datamodel.ProfileI;
+import jalview.datamodel.Profiles;
import java.awt.Color;
* SR-T
* SR-T
*/
- ProfileI[] profiles = new ProfileI[4];
+ ProfileI[] profiles = new ProfileI[4];
profiles[0] = new Profile(4, 0, 2, "AS");
profiles[1] = new Profile(4, 0, 4, "R");
profiles[2] = new Profile(4, 4, 0, "");
profiles[3] = new Profile(4, 1, 2, "T");
ResidueColourScheme rcs = new ResidueColourScheme();
- rcs.setConsensus(profiles);
+ rcs.setConsensus(new Profiles(profiles));
/*
* no threshold
import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.ColumnSelection;
-import jalview.datamodel.SearchResults;
-import jalview.datamodel.SearchResults.Match;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
/*
* Check protein residue 12 maps to codon 5-7, 13 to codon 8-10
*/
- SearchResults sr = MappingUtils.buildSearchResults(aseq1, 12, acfList);
+ SearchResultsI sr = MappingUtils.buildSearchResults(aseq1, 12, acfList);
assertEquals(1, sr.getResults().size());
- Match m = sr.getResults().get(0);
+ SearchResultMatchI m = sr.getResults().get(0);
assertEquals(seq1.getDatasetSequence(), m.getSequence());
assertEquals(5, m.getStart());
assertEquals(7, m.getEnd());
/*
* Check protein residue 8 maps to [6, 8, 9]
*/
- SearchResults sr = MappingUtils.buildSearchResults(aseq1, 8, acfList);
+ SearchResultsI sr = MappingUtils.buildSearchResults(aseq1, 8, acfList);
assertEquals(2, sr.getResults().size());
- Match m = sr.getResults().get(0);
+ SearchResultMatchI m = sr.getResults().get(0);
assertEquals(seq1.getDatasetSequence(), m.getSequence());
assertEquals(6, m.getStart());
assertEquals(6, m.getEnd());