X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fviewmodel%2Fseqfeatures%2FFeatureRendererModel.java;h=81d1b7ed34569490789c9bc3578c0b94e33bc69f;hb=3d0101179759ef157b088ea135423cd909512d9f;hp=a53004d6aab18f6378f44e801aacbc45d46c0d68;hpb=1f491c8c9e66b3accb8bb9eae78c7d9caa63c1ac;p=jalview.git
diff --git a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java
index a53004d..81d1b7e 100644
--- a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java
+++ b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java
@@ -1,30 +1,51 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
+ *
+ * This file is part of Jalview.
+ *
+ * Jalview is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * Jalview is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview. If not, see .
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
package jalview.viewmodel.seqfeatures;
import jalview.api.AlignViewportI;
+import jalview.api.FeatureColourI;
import jalview.api.FeaturesDisplayedI;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.renderer.seqfeatures.FeatureRenderer;
-import jalview.schemes.GraduatedColor;
-import jalview.viewmodel.AlignmentViewport;
+import jalview.schemes.FeatureColour;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
-public abstract class FeatureRendererModel implements
- jalview.api.FeatureRenderer
+public abstract class FeatureRendererModel
+ implements jalview.api.FeatureRenderer
{
/**
@@ -32,19 +53,20 @@ public abstract class FeatureRendererModel implements
*/
protected float transparency = 1.0f;
- protected Map featureColours = new ConcurrentHashMap();
+ protected Map featureColours = new ConcurrentHashMap();
protected Map featureGroups = new ConcurrentHashMap();
- protected Object currentColour;
-
protected String[] renderOrder;
+ Map featureOrder = null;
+
protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
this);
- protected AlignmentViewport av;
+ protected AlignViewportI av;
+ @Override
public AlignViewportI getViewport()
{
return av;
@@ -121,8 +143,7 @@ public abstract class FeatureRendererModel implements
}
if (!fdi.isRegistered(featureType))
{
- pushFeatureType(Arrays.asList(new String[]
- { featureType }));
+ pushFeatureType(Arrays.asList(new String[] { featureType }));
}
fdi.setVisible(featureType);
}
@@ -165,15 +186,15 @@ public abstract class FeatureRendererModel implements
types.toArray(neworder);
if (renderOrder != null)
{
- System.arraycopy(neworder,0,neworder,renderOrder.length,ts);
+ System.arraycopy(neworder, 0, neworder, renderOrder.length, ts);
System.arraycopy(renderOrder, 0, neworder, 0, renderOrder.length);
}
renderOrder = neworder;
}
- protected Hashtable minmax = new Hashtable();
+ protected Map minmax = new Hashtable();
- public Hashtable getMinMax()
+ public Map getMinMax()
{
return minmax;
}
@@ -187,15 +208,15 @@ public abstract class FeatureRendererModel implements
*/
protected final byte[] normaliseScore(SequenceFeature sequenceFeature)
{
- float[] mm = ((float[][]) minmax.get(sequenceFeature.type))[0];
- final byte[] r = new byte[]
- { 0, (byte) 255 };
+ float[] mm = minmax.get(sequenceFeature.type)[0];
+ final byte[] r = new byte[] { 0, (byte) 255 };
if (mm != null)
{
if (r[0] != 0 || mm[0] < 0.0)
{
r[0] = 1;
- r[1] = (byte) ((int) 128.0 + 127.0 * (sequenceFeature.score / mm[1]));
+ r[1] = (byte) ((int) 128.0
+ + 127.0 * (sequenceFeature.score / mm[1]));
}
else
{
@@ -244,30 +265,36 @@ public abstract class FeatureRendererModel implements
}
@Override
- public List findFeaturesAtRes(SequenceI sequence, int res)
+ public List findFeaturesAtRes(SequenceI sequence,
+ int res)
{
ArrayList tmp = new ArrayList();
SequenceFeature[] features = sequence.getSequenceFeatures();
+
if (features != null)
{
for (int i = 0; i < features.length; i++)
{
- if (av.areFeaturesDisplayed()
- || !av.getFeaturesDisplayed().isVisible(
- features[i].getType()))
+ if (!av.areFeaturesDisplayed() || !av.getFeaturesDisplayed()
+ .isVisible(features[i].getType()))
{
continue;
}
- if (features[i].featureGroup != null
- && featureGroups != null
+ if (features[i].featureGroup != null && featureGroups != null
&& featureGroups.containsKey(features[i].featureGroup)
- && !((Boolean) featureGroups.get(features[i].featureGroup))
+ && !featureGroups.get(features[i].featureGroup)
.booleanValue())
+ {
continue;
+ }
- if ((features[i].getBegin() <= res)
- && (features[i].getEnd() >= res))
+ // check if start/end are at res, and if not a contact feature, that res
+ // lies between start and end
+ if ((features[i].getBegin() == res || features[i].getEnd() == res)
+ || (!features[i].isContactFeature()
+ && (features[i].getBegin() < res)
+ && (features[i].getEnd() >= res)))
{
tmp.add(features[i]);
}
@@ -316,15 +343,15 @@ public abstract class FeatureRendererModel implements
}
if (minmax == null)
{
- minmax = new Hashtable();
+ minmax = new Hashtable();
}
+
+ Set oldGroups = new HashSet(featureGroups.keySet());
AlignmentI alignment = av.getAlignment();
for (int i = 0; i < alignment.getHeight(); i++)
{
SequenceI asq = alignment.getSequenceAt(i);
- SequenceI dasq = asq.getDatasetSequence();
- SequenceFeature[] features = dasq != null ? dasq
- .getSequenceFeatures() : asq.getSequenceFeatures();
+ SequenceFeature[] features = asq.getSequenceFeatures();
if (features == null)
{
@@ -334,9 +361,10 @@ public abstract class FeatureRendererModel implements
int index = 0;
while (index < features.length)
{
+ String fgrp = features[index].getFeatureGroup();
+ oldGroups.remove(fgrp);
if (!featuresDisplayed.isRegistered(features[index].getType()))
{
- String fgrp = features[index].getFeatureGroup();
if (fgrp != null)
{
Boolean groupDisplayed = featureGroups.get(fgrp);
@@ -345,7 +373,7 @@ public abstract class FeatureRendererModel implements
groupDisplayed = Boolean.valueOf(newMadeVisible);
featureGroups.put(fgrp, groupDisplayed);
}
- if (!((Boolean) groupDisplayed).booleanValue())
+ if (!groupDisplayed.booleanValue())
{
index++;
continue;
@@ -370,20 +398,19 @@ public abstract class FeatureRendererModel implements
{
allfeatures.add(features[index].getType());
}
- if (features[index].score != Float.NaN)
+ if (!Float.isNaN(features[index].score))
{
int nonpos = features[index].getBegin() >= 1 ? 0 : 1;
- float[][] mm = (float[][]) minmax.get(features[index].getType());
+ float[][] mm = minmax.get(features[index].getType());
if (mm == null)
{
- mm = new float[][]
- { null, null };
+ mm = new float[][] { null, null };
minmax.put(features[index].getType(), mm);
}
if (mm[nonpos] == null)
{
- mm[nonpos] = new float[]
- { features[index].score, features[index].score };
+ mm[nonpos] = new float[] { features[index].score,
+ features[index].score };
}
else
@@ -401,6 +428,16 @@ public abstract class FeatureRendererModel implements
index++;
}
}
+
+ /*
+ * oldGroups now consists of groups that no longer
+ * have any feature in them - remove these
+ */
+ for (String grp : oldGroups)
+ {
+ featureGroups.remove(grp);
+ }
+
updateRenderOrder(allfeatures);
findingFeatures = false;
}
@@ -423,7 +460,6 @@ public abstract class FeatureRendererModel implements
List allfeatures = new ArrayList(allFeatures);
String[] oldRender = renderOrder;
renderOrder = new String[allfeatures.size()];
- Object mmrange, fc = null;
boolean initOrders = (featureOrder == null);
int opos = 0;
if (oldRender != null && oldRender.length > 0)
@@ -434,8 +470,8 @@ public abstract class FeatureRendererModel implements
{
if (initOrders)
{
- setOrder(oldRender[j], (1 - (1 + (float) j)
- / (float) oldRender.length));
+ setOrder(oldRender[j],
+ (1 - (1 + (float) j) / oldRender.length));
}
if (allfeatures.contains(oldRender[j]))
{
@@ -444,16 +480,13 @@ public abstract class FeatureRendererModel implements
allfeatures.remove(oldRender[j]);
if (minmax != null)
{
- mmrange = minmax.get(oldRender[j]);
+ float[][] mmrange = minmax.get(oldRender[j]);
if (mmrange != null)
{
- fc = featureColours.get(oldRender[j]);
- if (fc != null && fc instanceof GraduatedColor
- && ((GraduatedColor) fc).isAutoScale())
+ FeatureColourI fc = featureColours.get(oldRender[j]);
+ if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
{
- ((GraduatedColor) fc).updateBounds(
- ((float[][]) mmrange)[0][0],
- ((float[][]) mmrange)[0][1]);
+ fc.updateBounds(mmrange[0][0], mmrange[0][1]);
}
}
}
@@ -477,15 +510,13 @@ public abstract class FeatureRendererModel implements
if (minmax != null)
{
// update from new features minmax if necessary
- mmrange = minmax.get(newf[i]);
+ float[][] mmrange = minmax.get(newf[i]);
if (mmrange != null)
{
- fc = featureColours.get(newf[i]);
- if (fc != null && fc instanceof GraduatedColor
- && ((GraduatedColor) fc).isAutoScale())
+ FeatureColourI fc = featureColours.get(newf[i]);
+ if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
{
- ((GraduatedColor) fc).updateBounds(((float[][]) mmrange)[0][0],
- ((float[][]) mmrange)[0][1]);
+ fc.updateBounds(mmrange[0][0], mmrange[0][1]);
}
}
}
@@ -497,7 +528,7 @@ public abstract class FeatureRendererModel implements
setOrder(newf[i], i / (float) denom);
}
// set order from newly found feature from persisted ordering.
- sortOrder[i] = 2 - ((Float) featureOrder.get(newf[i])).floatValue();
+ sortOrder[i] = 2 - featureOrder.get(newf[i]).floatValue();
if (i < iSize)
{
// only sort if we need to
@@ -515,118 +546,83 @@ public abstract class FeatureRendererModel implements
/**
* get a feature style object for the given type string. Creates a
- * java.awt.Color for a featureType with no existing colourscheme. TODO:
- * replace return type with object implementing standard abstract colour/style
- * interface
+ * java.awt.Color for a featureType with no existing colourscheme.
*
* @param featureType
- * @return java.awt.Color or GraduatedColor
+ * @return
*/
- public Object getFeatureStyle(String featureType)
+ @Override
+ public FeatureColourI getFeatureStyle(String featureType)
{
- Object fc = featureColours.get(featureType);
+ FeatureColourI fc = featureColours.get(featureType);
if (fc == null)
{
- jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme();
- Color col = ucs.createColourFromName(featureType);
- featureColours.put(featureType, fc = col);
+ Color col = ColorUtils.createColourFromName(featureType);
+ fc = new FeatureColour(col);
+ featureColours.put(featureType, fc);
}
return fc;
}
/**
- * return a nominal colour for this feature
+ * Returns the configured colour for a particular feature instance. This
+ * includes calculation of 'colour by label', or of a graduated score colour,
+ * if applicable. It does not take into account feature visibility or colour
+ * transparency.
*
- * @param featureType
- * @return standard color, or maximum colour for graduated colourscheme
+ * @param feature
+ * @return
*/
- public Color getColour(String featureType)
+ public Color getColour(SequenceFeature feature)
{
- Object fc = getFeatureStyle(featureType);
-
- if (fc instanceof Color)
- {
- return (Color) fc;
- }
- else
- {
- if (fc instanceof GraduatedColor)
- {
- return ((GraduatedColor) fc).getMaxColor();
- }
- }
- throw new Error("Implementation Error: Unrecognised render object "
- + fc.getClass() + " for features of type " + featureType);
+ FeatureColourI fc = getFeatureStyle(feature.getType());
+ return fc.isColored(feature) ? fc.getColor(feature) : null;
}
/**
- * calculate the render colour for a specific feature using current feature
- * settings.
+ * Answers true unless the feature has a score value which lies outside a
+ * minimum or maximum threshold configured for colouring. This method does not
+ * check feature type or group visibility.
*
- * @param feature
- * @return render colour for the given feature
+ * @param sequenceFeature
+ * @return
*/
- public Color getColour(SequenceFeature feature)
- {
- Object fc = getFeatureStyle(feature.getType());
- if (fc instanceof Color)
- {
- return (Color) fc;
- }
- else
- {
- if (fc instanceof GraduatedColor)
- {
- return ((GraduatedColor) fc).findColor(feature);
- }
- }
- throw new Error("Implementation Error: Unrecognised render object "
- + fc.getClass() + " for features of type " + feature.getType());
- }
-
protected boolean showFeature(SequenceFeature sequenceFeature)
{
- Object fc = getFeatureStyle(sequenceFeature.type);
- if (fc instanceof GraduatedColor)
- {
- return ((GraduatedColor) fc).isColored(sequenceFeature);
- }
- else
- {
- return true;
- }
+ FeatureColourI fc = getFeatureStyle(sequenceFeature.type);
+ return fc.isColored(sequenceFeature);
}
+ /**
+ * Answers true if the feature type is currently selected to be displayed,
+ * else false
+ *
+ * @param type
+ * @return
+ */
protected boolean showFeatureOfType(String type)
{
- return av.getFeaturesDisplayed().isVisible(type);
+ return type == null ? false : av.getFeaturesDisplayed().isVisible(type);
}
- public void setColour(String featureType, Object col)
+ @Override
+ public void setColour(String featureType, FeatureColourI col)
{
- // overwrite
- // Color _col = (col instanceof Color) ? ((Color) col) : (col instanceof
- // GraduatedColor) ? ((GraduatedColor) col).getMaxColor() : null;
- // Object c = featureColours.get(featureType);
- // if (c == null || c instanceof Color || (c instanceof GraduatedColor &&
- // !((GraduatedColor)c).getMaxColor().equals(_col)))
- {
- featureColours.put(featureType, col);
- }
+ featureColours.put(featureType, col);
}
+ @Override
public void setTransparency(float value)
{
transparency = value;
}
+ @Override
public float getTransparency()
{
return transparency;
}
- Map featureOrder = null;
-
/**
* analogous to colour - store a normalized ordering for all feature types in
* this rendering context.
@@ -641,7 +637,7 @@ public abstract class FeatureRendererModel implements
{
if (featureOrder == null)
{
- featureOrder = new Hashtable();
+ featureOrder = new Hashtable();
}
featureOrder.put(type, new Float(position));
return position;
@@ -659,16 +655,16 @@ public abstract class FeatureRendererModel implements
{
if (featureOrder.containsKey(type))
{
- return ((Float) featureOrder.get(type)).floatValue();
+ return featureOrder.get(type).floatValue();
}
}
return -1;
}
@Override
- public Map getFeatureColours()
+ public Map getFeatureColours()
{
- return new ConcurrentHashMap<>(featureColours);
+ return featureColours;
}
/**
@@ -676,21 +672,32 @@ public abstract class FeatureRendererModel implements
*
* @param data
* { String(Type), Colour(Type), Boolean(Displayed) }
+ * @return true if any visible features have been reordered, else false
*/
- public void setFeaturePriority(Object[][] data)
+ public boolean setFeaturePriority(Object[][] data)
{
- setFeaturePriority(data, true);
+ return setFeaturePriority(data, true);
}
/**
+ * Sets the priority order for features
*
* @param data
* { String(Type), Colour(Type), Boolean(Displayed) }
* @param visibleNew
* when true current featureDisplay list will be cleared
+ * @return true if any visible features have been reordered or recoloured,
+ * else false (i.e. no need to repaint)
*/
- public void setFeaturePriority(Object[][] data, boolean visibleNew)
+ public boolean setFeaturePriority(Object[][] data, boolean visibleNew)
{
+ /*
+ * note visible feature ordering and colours before update
+ */
+ List visibleFeatures = getDisplayedFeatureTypes();
+ Map visibleColours = new HashMap(
+ getFeatureColours());
+
FeaturesDisplayedI av_featuresdisplayed = null;
if (visibleNew)
{
@@ -700,7 +707,8 @@ public abstract class FeatureRendererModel implements
}
else
{
- av.setFeaturesDisplayed(av_featuresdisplayed = new FeaturesDisplayed());
+ av.setFeaturesDisplayed(
+ av_featuresdisplayed = new FeaturesDisplayed());
}
}
else
@@ -709,10 +717,10 @@ public abstract class FeatureRendererModel implements
}
if (data == null)
{
- return;
+ return false;
}
// The feature table will display high priority
- // features at the top, but theses are the ones
+ // features at the top, but these are the ones
// we need to render last, so invert the data
renderOrder = new String[data.length];
@@ -721,8 +729,7 @@ public abstract class FeatureRendererModel implements
for (int i = 0; i < data.length; i++)
{
String type = data[i][0].toString();
- setColour(type, data[i][1]); // todo : typesafety - feature color
- // interface object
+ setColour(type, (FeatureColourI) data[i][1]);
if (((Boolean) data[i][2]).booleanValue())
{
av_featuresdisplayed.setVisible(type);
@@ -732,6 +739,30 @@ public abstract class FeatureRendererModel implements
}
}
+ /*
+ * get the new visible ordering and return true if it has changed
+ * order or any colour has changed
+ */
+ List reorderedVisibleFeatures = getDisplayedFeatureTypes();
+ if (!visibleFeatures.equals(reorderedVisibleFeatures))
+ {
+ /*
+ * the list of ordered visible features has changed
+ */
+ return true;
+ }
+
+ /*
+ * return true if any feature colour has changed
+ */
+ for (String feature : visibleFeatures)
+ {
+ if (visibleColours.get(feature) != getFeatureStyle(feature))
+ {
+ return true;
+ }
+ }
+ return false;
}
/**
@@ -752,7 +783,7 @@ public abstract class FeatureRendererModel implements
changeSupport.removePropertyChangeListener(listener);
}
- public Set getAllFeatureColours()
+ public Set getAllFeatureColours()
{
return featureColours.keySet();
}
@@ -767,12 +798,14 @@ public abstract class FeatureRendererModel implements
return renderOrder != null;
}
+ /**
+ * Returns feature types in ordering of rendering, where last means on top
+ */
public List getRenderOrder()
{
if (renderOrder == null)
{
- return Arrays.asList(new String[]
- {});
+ return Arrays.asList(new String[] {});
}
return Arrays.asList(renderOrder);
}
@@ -787,11 +820,12 @@ public abstract class FeatureRendererModel implements
{
// conflict between applet and desktop - featureGroups returns the map in
// the desktop featureRenderer
- return (featureGroups == null) ? Arrays.asList(new String[0]) : Arrays
- .asList(featureGroups.keySet().toArray(new String[0]));
+ return (featureGroups == null) ? Arrays.asList(new String[0])
+ : Arrays.asList(featureGroups.keySet().toArray(new String[0]));
}
- public boolean checkGroupVisibility(String group, boolean newGroupsVisible)
+ public boolean checkGroupVisibility(String group,
+ boolean newGroupsVisible)
{
if (featureGroups == null)
{
@@ -799,7 +833,7 @@ public abstract class FeatureRendererModel implements
}
if (featureGroups.containsKey(group))
{
- return ((Boolean) featureGroups.get(group)).booleanValue();
+ return featureGroups.get(group).booleanValue();
}
if (newGroupsVisible)
{
@@ -817,15 +851,15 @@ public abstract class FeatureRendererModel implements
* @return list of groups
*/
@Override
- public List getGroups(boolean visible)
+ public List getGroups(boolean visible)
{
if (featureGroups != null)
{
- ArrayList gp = new ArrayList();
+ List gp = new ArrayList();
- for (Object grp : featureGroups.keySet())
+ for (String grp : featureGroups.keySet())
{
- Boolean state = (Boolean) featureGroups.get(grp);
+ Boolean state = featureGroups.get(grp);
if (state.booleanValue() == visible)
{
gp.add(grp);
@@ -854,7 +888,7 @@ public abstract class FeatureRendererModel implements
featureGroups.put(gst, new Boolean(visible));
if (st != null)
{
- rdrw = rdrw || (visible != ((Boolean) st).booleanValue());
+ rdrw = rdrw || (visible != st.booleanValue());
}
}
if (rdrw)
@@ -865,19 +899,19 @@ public abstract class FeatureRendererModel implements
}
@Override
- public Hashtable getDisplayedFeatureCols()
+ public Map getDisplayedFeatureCols()
{
- Hashtable fcols = new Hashtable();
+ Map fcols = new Hashtable();
if (getViewport().getFeaturesDisplayed() == null)
{
return fcols;
}
- Iterator en = getViewport().getFeaturesDisplayed()
+ Iterator features = getViewport().getFeaturesDisplayed()
.getVisibleFeatures();
- while (en.hasNext())
+ while (features.hasNext())
{
- String col = en.next();
- fcols.put(col, getColour(col));
+ String feature = features.next();
+ fcols.put(feature, getFeatureStyle(feature));
}
return fcols;
}
@@ -888,39 +922,39 @@ public abstract class FeatureRendererModel implements
return av.getFeaturesDisplayed();
}
+ /**
+ * Returns a (possibly empty) list of visible feature types, in render order
+ * (last is on top)
+ */
@Override
- public String[] getDisplayedFeatureTypes()
+ public List getDisplayedFeatureTypes()
{
- String[] typ = null;
- typ = getRenderOrder().toArray(new String[0]);
+ List typ = getRenderOrder();
+ List displayed = new ArrayList();
FeaturesDisplayedI feature_disp = av.getFeaturesDisplayed();
if (feature_disp != null)
{
synchronized (feature_disp)
{
- for (int i = 0; i < typ.length; i++)
+ for (String type : typ)
{
- if (feature_disp.isVisible(typ[i]))
+ if (feature_disp.isVisible(type))
{
- typ[i] = null;
+ displayed.add(type);
}
}
}
}
- return typ;
+ return displayed;
}
@Override
- public String[] getDisplayedFeatureGroups()
+ public List getDisplayedFeatureGroups()
{
- String[] gps = null;
- ArrayList _gps = new ArrayList();
- Iterator en = getFeatureGroups().iterator();
- int g = 0;
+ List _gps = new ArrayList();
boolean valid = false;
- while (en.hasNext())
+ for (String gp : getFeatureGroups())
{
- String gp = (String) en.next();
if (checkGroupVisibility(gp, false))
{
valid = true;
@@ -932,11 +966,11 @@ public abstract class FeatureRendererModel implements
}
else
{
- gps = new String[_gps.size()];
- _gps.toArray(gps);
+ // gps = new String[_gps.size()];
+ // _gps.toArray(gps);
}
}
- return gps;
+ return _gps;
}
}