--- /dev/null
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
+ * Copyright (C) 2014 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 <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
+package jalview.ws.jws2;
+
+import jalview.api.AlignCalcWorkerI;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.Annotation;
+import jalview.gui.AlignFrame;
+import jalview.ws.jws2.jabaws2.Jws2Instance;
+import jalview.ws.params.ArgumentI;
+import jalview.ws.params.OptionI;
+import jalview.ws.params.WsParamSetI;
+import jalview.ws.uimodel.AlignAnalysisUIText;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import compbio.data.sequence.FastaSequence;
+import compbio.data.sequence.JpredAlignment;
+import compbio.metadata.Argument;
+
+public class JPred301Client extends JabawsMsaInterfaceAlignCalcWorker
+ implements AlignCalcWorkerI
+{
+
+ /**
+ *
+ * @return default args for this service when run as dynamic web service
+ */
+ public List<Argument> selectDefaultArgs()
+ {
+ List<ArgumentI> rgs = new ArrayList<ArgumentI>();
+ for (ArgumentI argi: service.getParamStore().getServiceParameters())
+ {
+ if (argi instanceof OptionI)
+ {
+ List<String> o = ((OptionI) argi).getPossibleValues();
+ if (o.contains("-pred-nohits"))
+ {
+ OptionI cpy = ((OptionI)argi).copy();
+ cpy.setValue("-pred-nohits");
+ rgs.add(cpy);
+ }
+ }
+ }
+ return JabaParamStore.getJabafromJwsArgs(rgs);
+ }
+
+ public JPred301Client(Jws2Instance service, AlignFrame alignFrame,
+ WsParamSetI preset, List<Argument> paramset)
+ {
+ super(service, alignFrame, preset, paramset);
+ submitGaps = true;
+ alignedSeqs = true;
+ nucleotidesAllowed = false;
+ proteinAllowed = true;
+ gapMap = new boolean[0];
+ updateParameters(null, selectDefaultArgs());
+ }
+
+ @Override
+ boolean checkValidInputSeqs(boolean dynamic, List<FastaSequence> seqs)
+ {
+ return (seqs.size() > 1);
+ }
+
+ public String getServiceActionText()
+ {
+ return "calculating consensus secondary structure prediction using JPred service";
+ }
+ private static HashMap<String, String[]> jpredRowLabels = new HashMap<String,String[]>();
+ private static HashSet<String>jpredRes_graph,jpredRes_ssonly;
+ {
+ jpredRes_ssonly=new HashSet();
+ jpredRes_ssonly.add("jnetpred".toLowerCase());
+ jpredRes_graph=new HashSet();
+ jpredRes_graph.add("jnetconf".toLowerCase());
+
+ }
+ /**
+ * update the consensus annotation from the sequence profile data using
+ * current visualization settings.
+ */
+ public void updateResultAnnotation(boolean immediate)
+ {
+ if (immediate || !calcMan.isWorking(this) && msascoreset != null)
+ {
+ if (msascoreset instanceof compbio.data.sequence.JpredAlignment)
+ {
+ JpredAlignment jpres = (JpredAlignment) msascoreset;
+ int alWidth = alignViewport.getAlignment().getWidth();
+ ArrayList<AlignmentAnnotation> ourAnnot = new ArrayList<AlignmentAnnotation>();
+ for (FastaSequence fsq:jpres.getJpredSequences())
+ {
+ String[] k = jpredRowLabels.get(fsq.getId());
+ if (k==null)
+ {
+ k = new String[] { fsq.getId(), "JNet Output"};
+ }
+ createAnnotationRowFromString(ourAnnot, getCalcId(), alWidth,
+ k[0],k[1],
+ jpredRes_graph.contains(fsq.getId()) ? AlignmentAnnotation.BAR_GRAPH : AlignmentAnnotation.NO_GRAPH, 0f, 0f,
+ fsq.getSequence());
+
+ }
+ for (FastaSequence fsq: jpres.getSequences())
+ {
+ if (fsq.getId().equalsIgnoreCase("QUERY"))
+ {
+ createAnnotationRowFromString(ourAnnot, getCalcId(), alWidth,
+ "Query", "JPred Reference Sequence",
+ AlignmentAnnotation.NO_GRAPH, 0f, 0f,
+ fsq.getSequence());
+ }
+ }
+ if (ourAnnot.size() > 0)
+ {
+ updateOurAnnots(ourAnnot);
+ }
+ }
+ }
+ }
+
+ private void createAnnotationRowFromString(
+ ArrayList<AlignmentAnnotation> ourAnnot, String calcId,
+ int alWidth, String label, String descr, int rowType, float min,
+ float max, String jpredPrediction)
+ {
+ // simple annotation row
+ AlignmentAnnotation annotation = alignViewport.getAlignment()
+ .findOrCreateAnnotation(label, calcId, true, null, null);
+ if (alWidth == gapMap.length) // scr.getScores().size())
+ {
+ annotation.label = new String(label);
+ annotation.description = new String(descr);
+ annotation.graph = rowType;
+ annotation.graphMin = min;
+ annotation.graphMax = max;
+ if (constructAnnotationFromString(annotation, jpredPrediction,
+ alWidth, rowType))
+ {
+ // created a valid annotation from the data
+ ourAnnot.add(annotation);
+ }
+ }
+ }
+
+ private boolean constructAnnotationFromString(
+ AlignmentAnnotation annotation, String sourceData, int alWidth,
+ int rowType)
+ {
+ if (sourceData.length()==0 && alWidth>0)
+ {
+ return false;
+ }
+ Annotation[] elm = new Annotation[alWidth];
+
+ for (int i = 0, iSize = sourceData.length(); i < iSize; i++)
+ {
+ char annot = sourceData.charAt(i);
+ // if we're at a gapped column then skip to next ungapped position
+ if (gapMap != null && gapMap.length > 0)
+ {
+ while (!gapMap[i])
+ {
+ elm[i++] = new Annotation("", "", ' ', Float.NaN);
+ }
+ }
+ switch (rowType)
+ {
+ case AlignmentAnnotation.NO_GRAPH:
+ elm[i] = new Annotation("" + annot, "" + annot, annot, Float.NaN);
+ break;
+ default:
+ try
+ {
+ elm[i] = new Annotation("" + annot, "" + annot, annot,
+ Integer.valueOf(annot));
+ } catch (Exception x)
+ {
+ System.err.println("Expected numeric value in character '"
+ + annot + "'");
+ }
+ }
+ }
+
+ annotation.annotations = elm;
+ annotation.belowAlignment = true;
+ annotation.validateRangeAndDisplay();
+ return true;
+ }
+
+ @Override
+ public String getCalcId()
+ {
+ return CALC_ID;
+ }
+
+ private static String CALC_ID = "jabaws21.JPred3Cons";
+
+ public static AlignAnalysisUIText getAlignAnalysisUITest()
+ {
+ return new AlignAnalysisUIText(
+ compbio.ws.client.Services.JpredWS.toString(),
+ jalview.ws.jws2.JPred301Client.class, CALC_ID, false, true,
+ true, "JPred Consensus",
+ "When checked, JPred consensus is updated automatically.",
+ "Change JPred Settings...",
+ "Modify settings for JPred calculations.");
+ }
+}
--- /dev/null
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
+ * Copyright (C) 2014 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 <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
+package jalview.ws.jws2;
+
+import java.util.Iterator;
+import java.util.List;
+
+import compbio.data.msa.MsaWS;
+import compbio.data.msa.SequenceAnnotation;
+import compbio.data.sequence.Alignment;
+import compbio.data.sequence.Score;
+import compbio.data.sequence.ScoreManager;
+import compbio.metadata.Argument;
+import compbio.metadata.ChunkHolder;
+import compbio.metadata.JobStatus;
+import compbio.metadata.JobSubmissionException;
+import compbio.metadata.ResultNotAvailableException;
+import compbio.metadata.WrongParameterException;
+import jalview.api.AlignViewportI;
+import jalview.api.AlignmentViewPanel;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.Annotation;
+import jalview.datamodel.SequenceI;
+import jalview.gui.AlignFrame;
+import jalview.workers.AlignCalcWorker;
+import jalview.ws.jws2.jabaws2.Jws2Instance;
+import jalview.ws.params.WsParamSetI;
+
+public abstract class JabawsMsaInterfaceAlignCalcWorker extends AbstractJabaCalcWorker
+{
+
+ @SuppressWarnings("unchecked")
+ protected MsaWS msaservice;
+
+ protected Alignment msascoreset;
+
+ public JabawsMsaInterfaceAlignCalcWorker(AlignViewportI alignViewport,
+ AlignmentViewPanel alignPanel)
+ {
+ super(alignViewport, alignPanel);
+ }
+
+ public JabawsMsaInterfaceAlignCalcWorker(Jws2Instance service, AlignFrame alignFrame,
+ WsParamSetI preset, List<Argument> paramset)
+ {
+ this(alignFrame.getCurrentView(), alignFrame.alignPanel);
+ this.guiProgress = alignFrame;
+ this.preset = preset;
+ this.arguments = paramset;
+ this.service = service;
+ msaservice = (MsaWS) service.service;
+
+ }
+
+ @Override
+ ChunkHolder pullExecStatistics(String rslt, long rpos)
+ {
+ return msaservice.pullExecStatistics(rslt, rpos);
+ }
+
+ @Override
+ boolean collectAnnotationResultsFor(String rslt)
+ throws ResultNotAvailableException
+ {
+ msascoreset = msaservice.getResult(rslt);
+ if (msascoreset != null)
+ {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ boolean cancelJob(String rslt) throws Exception
+ {
+ return msaservice.cancelJob(rslt);
+ }
+
+ @Override
+ protected JobStatus getJobStatus(String rslt) throws Exception
+ {
+ return msaservice.getJobStatus(rslt);
+ }
+
+ @Override
+ boolean hasService()
+ {
+ return msaservice != null;
+ }
+
+ @Override
+ protected boolean isInteractiveUpdate()
+ {
+ return false; // this instanceof AAConClient;
+ }
+
+ @Override
+ protected String submitToService(
+ List<compbio.data.sequence.FastaSequence> seqs)
+ throws JobSubmissionException
+ {
+ String rslt;
+ if (preset == null && arguments == null)
+ {
+ rslt = msaservice.align(seqs);
+ }
+ else
+ {
+ try
+ {
+ rslt = msaservice.customAlign(seqs, getJabaArguments());
+ } catch (WrongParameterException x)
+ {
+ throw new JobSubmissionException(
+ "Invalid parameter set. Check Jalview implementation.", x);
+
+ }
+ }
+ return rslt;
+ }
+
+ protected void createAnnotationRowsForScores(
+ List<AlignmentAnnotation> ourAnnot, String calcId, int alWidth,
+ Score scr)
+ {
+ // simple annotation row
+ AlignmentAnnotation annotation = alignViewport.getAlignment()
+ .findOrCreateAnnotation(scr.getMethod(), calcId, true, null,
+ null);
+ if (alWidth == gapMap.length) // scr.getScores().size())
+ {
+ constructAnnotationFromScore(annotation, 0, alWidth, scr);
+ ourAnnot.add(annotation);
+ }
+ }
+
+ protected AlignmentAnnotation createAnnotationRowsForScores(
+ List<AlignmentAnnotation> ourAnnot, String typeName,
+ String calcId, SequenceI dseq, int base, Score scr)
+ {
+ System.out.println("Creating annotation on dseq:" + dseq.getStart()
+ + " base is " + base + " and length=" + dseq.getLength()
+ + " == " + scr.getScores().size());
+ // AlignmentAnnotation annotation = new AlignmentAnnotation(
+ // scr.getMethod(), typeName, new Annotation[]
+ // {}, 0, -1, AlignmentAnnotation.LINE_GRAPH);
+ // annotation.setCalcId(calcId);
+ AlignmentAnnotation annotation = alignViewport.getAlignment()
+ .findOrCreateAnnotation(typeName, calcId, false, dseq, null);
+ constructAnnotationFromScore(annotation, 0, dseq.getLength(), scr);
+ annotation.createSequenceMapping(dseq, base, false);
+ annotation.adjustForAlignment();
+ dseq.addAlignmentAnnotation(annotation);
+ ourAnnot.add(annotation);
+ return annotation;
+ }
+
+ private void constructAnnotationFromScore(AlignmentAnnotation annotation,
+ int base, int alWidth, Score scr)
+ {
+ Annotation[] elm = new Annotation[alWidth];
+ Iterator<Float> vals = scr.getScores().iterator();
+ float m = 0f, x = 0f;
+ for (int i = 0; vals.hasNext(); i++)
+ {
+ float val = vals.next().floatValue();
+ if (i == 0)
+ {
+ m = val;
+ x = val;
+ }
+ else
+ {
+ if (m > val)
+ {
+ m = val;
+ }
+ ;
+ if (x < val)
+ {
+ x = val;
+ }
+ }
+ // if we're at a gapped column then skip to next ungapped position
+ if (gapMap != null && gapMap.length > 0)
+ {
+ while (!gapMap[i])
+ {
+ elm[i++] = new Annotation("", "", ' ', Float.NaN);
+ }
+ }
+ elm[i] = new Annotation("", "" + val, ' ', val);
+ }
+
+ annotation.annotations = elm;
+ annotation.belowAlignment = true;
+ if (x < 0)
+ {
+ x = 0;
+ }
+ x += (x - m) * 0.1;
+ annotation.graphMax = x;
+ annotation.graphMin = m;
+ annotation.validateRangeAndDisplay();
+ }
+
+}
git://source.jalview.org / jalview.git / commitdiff