--- /dev/null
+package jalview.ws.jws1;
+
+import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.AlignmentView;
+import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.SequenceI;
+import jalview.io.FileParse;
+import jalview.io.FormatAdapter;
+import jalview.util.MessageManager;
+
+import java.util.Hashtable;
+import java.util.List;
+
+
+/**
+ * extraction of processing routines to allow mocking
+ *
+ * @author jprocter
+ *
+ */
+public class JPredWSUtils
+{
+ /**
+ * Process data extracted from service result set to generate a JPred result
+ * view.
+ *
+ * @param currentView
+ *
+ * @param input
+ * - original input alignment
+ * @param gapChar
+ * - character to use for reconstructing alignment used for
+ * prediction
+ * @param SequenceInfo
+ * - from SeqHash
+ * @param msaPred
+ * - true if a prediction based on existing MSA
+ * @param predMap
+ * - position
+ * @param result_PredFile
+ * @param result_Aligfile
+ * @param full_alignment
+ * @return { Alignment, ColumnSelection }
+ * @throws Exception
+ */
+ public static Object[] processJnetResult(AlignmentI currentView,
+ AlignmentView input,
+ char gapChar, Hashtable SequenceInfo,
+ boolean msaPred, int[] predMap, String result_PredFile,
+ String result_Aligfile, FileParse full_alignment)
+ throws Exception
+ {
+
+ AlignmentI al = null;
+ ColumnSelection alcsel = null;
+
+ // the position of the query sequence in Alignment al
+ int FirstSeq = -1;
+
+ // the position of the original sequence in the array of
+ // Sequences in the input object that this job holds a
+ // prediction for
+ int msaIndex = 0;
+
+ // JPredFile prediction = new JPredFile("C:/JalviewX/files/jpred.txt",
+ // "File");
+ jalview.io.JPredFile prediction = new jalview.io.JPredFile(
+ result_PredFile, "Paste");
+ SequenceI[] preds = prediction.getSeqsAsArray();
+ jalview.bin.Cache.log.debug("Got prediction profile.");
+
+ if (msaPred && (result_Aligfile != null))
+ {
+ jalview.bin.Cache.log.debug("Getting associated alignment.");
+ // we ignore the returned alignment if we only predicted on a single
+ // sequence
+ String format = new jalview.io.IdentifyFile().identify(
+ result_Aligfile, "Paste");
+
+ if (jalview.io.FormatAdapter.isValidFormat(format))
+ {
+ SequenceI sqs[];
+ if (predMap != null)
+ {
+ Object[] alandcolsel = input
+ .getAlignmentAndColumnSelection(gapChar);
+ sqs = (SequenceI[]) alandcolsel[0];
+ al = new Alignment(sqs);
+ alcsel = (ColumnSelection) alandcolsel[1];
+ }
+ else
+ {
+ al = new FormatAdapter().readFile(result_Aligfile, "Paste",
+ format);
+ sqs = new SequenceI[al.getHeight()];
+
+ for (int i = 0, j = al.getHeight(); i < j; i++)
+ {
+ sqs[i] = al.getSequenceAt(i);
+ }
+ if (!jalview.analysis.SeqsetUtils.deuniquify(SequenceInfo, sqs))
+ {
+ throw (new Exception(
+ MessageManager
+ .getString("exception.couldnt_recover_sequence_properties_for_alignment")));
+ }
+ }
+ FirstSeq = 0;
+ if (currentView.getDataset() != null)
+ {
+ al.setDataset(currentView.getDataset());
+
+ }
+ else
+ {
+ al.setDataset(null);
+ }
+ jalview.io.JnetAnnotationMaker.add_annotation(prediction, al,
+ FirstSeq, false, predMap);
+
+ }
+ else
+ {
+ throw (new Exception(MessageManager.formatMessage(
+ "exception.unknown_format_for_file", new String[] { format,
+ result_Aligfile })));
+ }
+ }
+ else
+ {
+ AlignmentI fullAlignment = null;
+ try
+ {
+ // read full alignment if present.
+ if (full_alignment != null)
+ {
+ fullAlignment = new FormatAdapter().readFromFile(full_alignment,
+ "FASTA");
+ }
+ } catch (Exception q)
+ {
+
+ } finally
+ {
+ if (fullAlignment != null)
+ {
+ al = fullAlignment;
+ FirstSeq = 0;
+ }
+ else
+ {
+ al = new Alignment(preds);
+ FirstSeq = prediction.getQuerySeqPosition();
+ }
+ }
+
+ if (predMap != null)
+ {
+ // map the prediction onto the query sequence, excluding positions
+ // corresponding to hidden regions in the original input.
+ char gc = gapChar;
+ SequenceI[] sqs = (SequenceI[]) input
+ .getAlignmentAndColumnSelection(gc)[0];
+ if (msaIndex >= sqs.length)
+ {
+ throw new Error(
+ MessageManager
+ .getString("error.implementation_error_invalid_msa_index_for_job"));
+ }
+ if (fullAlignment == null)
+ {
+ // //
+ // Uses RemoveGapsCommand
+ // //
+ new jalview.commands.RemoveGapsCommand(
+ MessageManager.getString("label.remove_gaps"),
+ new SequenceI[] { sqs[msaIndex] }, currentView);
+
+ SequenceI profileseq = al.getSequenceAt(FirstSeq);
+ profileseq.setSequence(sqs[msaIndex].getSequenceAsString());
+ }
+ }
+
+ if (!jalview.analysis.SeqsetUtils.SeqCharacterUnhash(
+ al.getSequenceAt(FirstSeq), SequenceInfo))
+ {
+ throw (new Exception(
+ MessageManager
+ .getString("exception.couldnt_recover_sequence_props_for_jnet_query")));
+ }
+ else
+ {
+ if (currentView.getDataset() != null)
+ {
+ al.setDataset(currentView.getDataset());
+
+ }
+ else
+ {
+ al.setDataset(null);
+ }
+ jalview.io.JnetAnnotationMaker.add_annotation(prediction, al,
+ FirstSeq, true, predMap);
+ SequenceI profileseq = al.getSequenceAt(0); // this includes any gaps.
+ if (fullAlignment == null)
+ {
+ alignToProfileSeq(al, profileseq);
+ }
+ if (fullAlignment == null && predMap != null)
+ {
+ // Adjust input view for gaps
+ // propagate insertions into profile
+ alcsel = ColumnSelection.propagateInsertions(profileseq, al,
+ input);
+ }
+ }
+ }
+
+ // transfer to dataset
+ for (AlignmentAnnotation alant : al.getAlignmentAnnotation())
+ {
+ if (alant.sequenceRef != null)
+ {
+ replaceAnnotationOnAlignmentWith(alant, alant.label,
+ "jalview.jws1.Jpred" + (msaPred ? "MSA" : ""),
+ alant.sequenceRef);
+ }
+ }
+
+ return new Object[] { al, alcsel }; // , FirstSeq, noMsa};
+ }
+
+ /**
+ * copied from JabawsCalcWorker
+ *
+ * @param newAnnot
+ * @param typeName
+ * @param calcId
+ * @param aSeq
+ */
+ public static void replaceAnnotationOnAlignmentWith(
+ AlignmentAnnotation newAnnot, String typeName, String calcId,
+ SequenceI aSeq)
+ {
+ SequenceI dsseq = aSeq.getDatasetSequence();
+ while (dsseq.getDatasetSequence() != null)
+ {
+ dsseq = dsseq.getDatasetSequence();
+ }
+ // look for same annotation on dataset and lift this one over
+ List<AlignmentAnnotation> dsan = dsseq.getAlignmentAnnotations(calcId,
+ typeName);
+ if (dsan != null && dsan.size() > 0)
+ {
+ for (AlignmentAnnotation dssan : dsan)
+ {
+ dsseq.removeAlignmentAnnotation(dssan);
+ }
+ }
+ AlignmentAnnotation dssan = new AlignmentAnnotation(newAnnot);
+ dsseq.addAlignmentAnnotation(dssan);
+ dssan.adjustForAlignment();
+ }
+
+ /**
+ * Given an alignment where all other sequences except profileseq are aligned
+ * to the ungapped profileseq, insert gaps in the other sequences to realign
+ * them with the residues in profileseq
+ *
+ * @param al
+ * @param profileseq
+ */
+ public static void alignToProfileSeq(AlignmentI al, SequenceI profileseq)
+ {
+ char gc = al.getGapCharacter();
+ int[] gapMap = profileseq.gapMap();
+ // insert gaps into profile
+ for (int lp = 0, r = 0; r < gapMap.length; r++)
+ {
+ if (gapMap[r] - lp > 1)
+ {
+ StringBuffer sb = new StringBuffer();
+ for (int s = 0, ns = gapMap[r] - lp; s < ns; s++)
+ {
+ sb.append(gc);
+ }
+ for (int s = 1, ns = al.getHeight(); s < ns; s++)
+ {
+ String sq = al.getSequenceAt(s).getSequenceAsString();
+ int diff = gapMap[r] - sq.length();
+ if (diff > 0)
+ {
+ // pad gaps
+ sq = sq + sb;
+ while ((diff = gapMap[r] - sq.length()) > 0)
+ {
+ sq = sq
+ + ((diff >= sb.length()) ? sb.toString() : sb
+ .substring(0, diff));
+ }
+ al.getSequenceAt(s).setSequence(sq);
+ }
+ else
+ {
+ al.getSequenceAt(s).setSequence(
+ sq.substring(0, gapMap[r]) + sb.toString()
+ + sq.substring(gapMap[r]));
+ }
+ }
+ }
+ lp = gapMap[r];
+ }
+ }
+
+}
git://source.jalview.org / jalview.git / blobdiff