src/jalview/io/JSONFile.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21
  22 package jalview.io;
  23
  24 import jalview.api.AlignExportSettingsI;
  25 import jalview.api.AlignViewportI;
  26 import jalview.api.AlignmentViewPanel;
  27 import jalview.api.ComplexAlignFile;
  28 import jalview.api.FeatureRenderer;
  29 import jalview.api.FeatureSettingsModelI;
  30 import jalview.api.FeaturesDisplayedI;
  31 import jalview.bin.BuildDetails;
  32 import jalview.datamodel.AlignExportSettingsAdapter;
  33 import jalview.datamodel.AlignmentAnnotation;
  34 import jalview.datamodel.AlignmentI;
  35 import jalview.datamodel.Annotation;
  36 import jalview.datamodel.HiddenColumns;
  37 import jalview.datamodel.HiddenSequences;
  38 import jalview.datamodel.Sequence;
  39 import jalview.datamodel.SequenceFeature;
  40 import jalview.datamodel.SequenceGroup;
  41 import jalview.datamodel.SequenceI;
  42 import jalview.json.binding.biojson.v1.AlignmentAnnotationPojo;
  43 import jalview.json.binding.biojson.v1.AlignmentPojo;
  44 import jalview.json.binding.biojson.v1.AnnotationDisplaySettingPojo;
  45 import jalview.json.binding.biojson.v1.AnnotationPojo;
  46 import jalview.json.binding.biojson.v1.ColourSchemeMapper;
  47 import jalview.json.binding.biojson.v1.SequenceFeaturesPojo;
  48 import jalview.json.binding.biojson.v1.SequenceGrpPojo;
  49 import jalview.json.binding.biojson.v1.SequencePojo;
  50 import jalview.renderer.seqfeatures.FeatureColourFinder;
  51 import jalview.schemes.ColourSchemeProperty;
  52 import jalview.schemes.JalviewColourScheme;
  53 import jalview.schemes.ResidueColourScheme;
  54 import jalview.util.ColorUtils;
  55 import jalview.util.Format;
  56 import jalview.util.JSONUtils;
  57 import jalview.viewmodel.seqfeatures.FeaturesDisplayed;
  58
  59 import java.awt.Color;
  60 import java.io.IOException;
  61 import java.io.Reader;
  62 import java.util.ArrayList;
  63 import java.util.Hashtable;
  64 import java.util.Iterator;
  65 import java.util.List;
  66 import java.util.Map;
  67 import java.util.Vector;
  68
  69 public class JSONFile extends AlignFile implements ComplexAlignFile
  70 {
  71   private static String version = new BuildDetails().getVersion();
  72
  73   private String webstartUrl = "https://www.jalview.org/services/launchApp";
  74
  75   private String application = "Jalview";
  76
  77   private String globalColourScheme;
  78
  79   private boolean showSeqFeatures;
  80
  81   private Hashtable<String, Sequence> seqMap;
  82
  83   private FeaturesDisplayedI displayedFeatures;
  84
  85   private FeatureRenderer fr;
  86
  87   private HiddenColumns hiddenColumns;
  88
  89   private List<String> hiddenSeqRefs;
  90
  91   private ArrayList<SequenceI> hiddenSequences;
  92
  93   private final static String TCOFFEE_SCORE = "TCoffeeScore";
  94
  95   public JSONFile()
  96   {
  97     super();
  98   }
  99
 100   public JSONFile(FileParse source) throws IOException
 101   {
 102     super(source);
 103   }
 104
 105   public JSONFile(String inFile, DataSourceType sourceType)
 106           throws IOException
 107   {
 108     super(inFile, sourceType);
 109   }
 110
 111   @Override
 112   public void parse() throws IOException
 113   {
 114     parse(getReader());
 115
 116   }
 117
 118   @Override
 119   public String print(SequenceI[] sqs, boolean jvsuffix)
 120   {
 121     String jsonOutput = null;
 122     try
 123     {
 124       AlignmentPojo jsonAlignmentPojo = new AlignmentPojo();
 125       AlignExportSettingsI exportSettings = getExportSettings();
 126
 127       /*
 128        * if no export settings were supplied, provide an 'export all' setting
 129        */
 130       if (exportSettings == null)
 131       {
 132         exportSettings = new AlignExportSettingsAdapter(true);
 133       }
 134
 135       int count = 0;
 136       for (SequenceI seq : sqs)
 137       {
 138         StringBuilder name = new StringBuilder();
 139         name.append(seq.getName()).append("/").append(seq.getStart())
 140                 .append("-").append(seq.getEnd());
 141         SequencePojo jsonSeqPojo = new SequencePojo();
 142         jsonSeqPojo.setId(String.valueOf(seq.hashCode()));
 143         jsonSeqPojo.setOrder(++count);
 144         jsonSeqPojo.setEnd(seq.getEnd());
 145         jsonSeqPojo.setStart(seq.getStart());
 146         jsonSeqPojo.setName(name.toString());
 147         jsonSeqPojo.setSeq(seq.getSequenceAsString());
 148         jsonAlignmentPojo.getSeqs().add(jsonSeqPojo);
 149       }
 150       jsonAlignmentPojo.setGlobalColorScheme(globalColourScheme);
 151       jsonAlignmentPojo.getAppSettings().put("application", application);
 152       jsonAlignmentPojo.getAppSettings().put("version", version);
 153       jsonAlignmentPojo.getAppSettings().put("webStartUrl", webstartUrl);
 154       jsonAlignmentPojo.getAppSettings().put("showSeqFeatures",
 155               String.valueOf(showSeqFeatures));
 156
 157       String[] hiddenSections = getHiddenSections();
 158       if (hiddenSections != null)
 159       {
 160         if (hiddenSections[0] != null
 161                 && exportSettings.isExportHiddenColumns())
 162         {
 163           jsonAlignmentPojo.getAppSettings().put("hiddenCols",
 164                   String.valueOf(hiddenSections[0]));
 165         }
 166         if (hiddenSections[1] != null
 167                 && exportSettings.isExportHiddenSequences())
 168         {
 169           jsonAlignmentPojo.getAppSettings().put("hiddenSeqs",
 170                   String.valueOf(hiddenSections[1]));
 171         }
 172       }
 173
 174       if (exportSettings.isExportAnnotations())
 175       {
 176         jsonAlignmentPojo
 177                 .setAlignAnnotation(annotationToJsonPojo(annotations));
 178       }
 179       else
 180       {
 181         // These color schemes require annotation, disable them if annotations
 182         // are not exported
 183         if (globalColourScheme
 184                 .equalsIgnoreCase(JalviewColourScheme.RNAHelices.toString())
 185                 || globalColourScheme.equalsIgnoreCase(
 186                         JalviewColourScheme.TCoffee.toString()))
 187         {
 188           jsonAlignmentPojo.setGlobalColorScheme(ResidueColourScheme.NONE);
 189         }
 190       }
 191
 192       if (exportSettings.isExportFeatures())
 193       {
 194         jsonAlignmentPojo.setSeqFeatures(sequenceFeatureToJsonPojo(sqs));
 195       }
 196
 197       if (exportSettings.isExportGroups() && seqGroups != null
 198               && seqGroups.size() > 0)
 199       {
 200         for (SequenceGroup seqGrp : seqGroups)
 201         {
 202           SequenceGrpPojo seqGrpPojo = new SequenceGrpPojo();
 203           seqGrpPojo.setGroupName(seqGrp.getName());
 204           seqGrpPojo.setColourScheme(ColourSchemeProperty
 205                   .getColourName(seqGrp.getColourScheme()));
 206           seqGrpPojo.setColourText(seqGrp.getColourText());
 207           seqGrpPojo.setDescription(seqGrp.getDescription());
 208           seqGrpPojo.setDisplayBoxes(seqGrp.getDisplayBoxes());
 209           seqGrpPojo.setDisplayText(seqGrp.getDisplayText());
 210           seqGrpPojo.setEndRes(seqGrp.getEndRes());
 211           seqGrpPojo.setStartRes(seqGrp.getStartRes());
 212           seqGrpPojo.setShowNonconserved(seqGrp.getShowNonconserved());
 213           for (SequenceI seq : seqGrp.getSequences())
 214           {
 215             seqGrpPojo.getSequenceRefs()
 216                     .add(String.valueOf(seq.hashCode()));
 217           }
 218           jsonAlignmentPojo.getSeqGroups().add(seqGrpPojo);
 219         }
 220       }
 221
 222       jsonOutput = JSONUtils.stringify(jsonAlignmentPojo);
 223       return jsonOutput.replaceAll("xstart", "xStart").replaceAll("xend",
 224               "xEnd");
 225     } catch (Exception e)
 226     {
 227       e.printStackTrace();
 228     }
 229     return jsonOutput;
 230   }
 231
 232   public String[] getHiddenSections()
 233   {
 234     String[] hiddenSections = new String[2];
 235     if (getViewport() == null)
 236     {
 237       return null;
 238     }
 239
 240     // hidden column business
 241     if (getViewport().hasHiddenColumns())
 242     {
 243       hiddenSections[0] = getViewport().getAlignment().getHiddenColumns()
 244               .regionsToString(";", "-");
 245     }
 246
 247     // hidden rows/seqs business
 248     HiddenSequences hiddenSeqsObj = getViewport().getAlignment()
 249             .getHiddenSequences();
 250     if (hiddenSeqsObj == null || hiddenSeqsObj.hiddenSequences == null)
 251     {
 252       return hiddenSections;
 253     }
 254
 255     SequenceI[] hiddenSeqs = hiddenSeqsObj.hiddenSequences;
 256     StringBuilder hiddenSeqsBuilder = new StringBuilder();
 257     for (SequenceI hiddenSeq : hiddenSeqs)
 258     {
 259       if (hiddenSeq != null)
 260       {
 261         hiddenSeqsBuilder.append(";").append(hiddenSeq.hashCode());
 262       }
 263     }
 264     if (hiddenSeqsBuilder.length() > 0)
 265     {
 266       hiddenSeqsBuilder.deleteCharAt(0);
 267     }
 268     hiddenSections[1] = hiddenSeqsBuilder.toString();
 269
 270     return hiddenSections;
 271   }
 272
 273   protected List<SequenceFeaturesPojo> sequenceFeatureToJsonPojo(
 274           SequenceI[] sqs)
 275   {
 276     displayedFeatures = (fr == null) ? null : fr.getFeaturesDisplayed();
 277     List<SequenceFeaturesPojo> sequenceFeaturesPojo = new ArrayList<>();
 278     if (sqs == null)
 279     {
 280       return sequenceFeaturesPojo;
 281     }
 282
 283     FeatureColourFinder finder = new FeatureColourFinder(fr);
 284
 285     String[] visibleFeatureTypes = displayedFeatures == null ? null
 286             : displayedFeatures.getVisibleFeatures().toArray(
 287                     new String[displayedFeatures.getVisibleFeatureCount()]);
 288
 289     for (SequenceI seq : sqs)
 290     {
 291       /*
 292        * get all features currently visible (and any non-positional features)
 293        */
 294       List<SequenceFeature> seqFeatures = seq.getFeatures()
 295               .getAllFeatures(visibleFeatureTypes);
 296       for (SequenceFeature sf : seqFeatures)
 297       {
 298         SequenceFeaturesPojo jsonFeature = new SequenceFeaturesPojo(
 299                 String.valueOf(seq.hashCode()));
 300
 301         String featureColour = (fr == null) ? null
 302                 : Format.getHexString(finder.findFeatureColour(Color.white,
 303                         seq, seq.findIndex(sf.getBegin())));
 304         int xStart = sf.getBegin() == 0 ? 0
 305                 : seq.findIndex(sf.getBegin()) - 1;
 306         int xEnd = sf.getEnd() == 0 ? 0 : seq.findIndex(sf.getEnd());
 307         jsonFeature.setXstart(xStart);
 308         jsonFeature.setXend(xEnd);
 309         jsonFeature.setType(sf.getType());
 310         jsonFeature.setDescription(sf.getDescription());
 311         jsonFeature.setLinks(sf.links);
 312         jsonFeature.setOtherDetails(sf.otherDetails);
 313         jsonFeature.setScore(sf.getScore());
 314         jsonFeature.setFillColor(featureColour);
 315         jsonFeature.setFeatureGroup(sf.getFeatureGroup());
 316         sequenceFeaturesPojo.add(jsonFeature);
 317       }
 318     }
 319     return sequenceFeaturesPojo;
 320   }
 321
 322   public static List<AlignmentAnnotationPojo> annotationToJsonPojo(
 323           Vector<AlignmentAnnotation> annotations)
 324   {
 325     List<AlignmentAnnotationPojo> jsonAnnotations = new ArrayList<>();
 326     if (annotations == null)
 327     {
 328       return jsonAnnotations;
 329     }
 330     for (AlignmentAnnotation annot : annotations)
 331     {
 332       AlignmentAnnotationPojo alignAnnotPojo = new AlignmentAnnotationPojo();
 333       alignAnnotPojo.setDescription(annot.description);
 334       alignAnnotPojo.setLabel(annot.label);
 335       if (!Double.isNaN(annot.score))
 336       {
 337         alignAnnotPojo.setScore(annot.score);
 338       }
 339       alignAnnotPojo.setCalcId(annot.getCalcId());
 340       alignAnnotPojo.setGraphType(annot.graph);
 341
 342       AnnotationDisplaySettingPojo annotSetting = new AnnotationDisplaySettingPojo();
 343       annotSetting.setBelowAlignment(annot.belowAlignment);
 344       annotSetting.setCentreColLabels(annot.centreColLabels);
 345       annotSetting.setScaleColLabel(annot.scaleColLabel);
 346       annotSetting.setShowAllColLabels(annot.showAllColLabels);
 347       annotSetting.setVisible(annot.visible);
 348       annotSetting.setHasIcon(annot.hasIcons);
 349       alignAnnotPojo.setAnnotationSettings(annotSetting);
 350       SequenceI refSeq = annot.sequenceRef;
 351       if (refSeq != null)
 352       {
 353         alignAnnotPojo.setSequenceRef(String.valueOf(refSeq.hashCode()));
 354       }
 355       for (Annotation annotation : annot.annotations)
 356       {
 357         AnnotationPojo annotationPojo = new AnnotationPojo();
 358         if (annotation != null)
 359         {
 360           annotationPojo.setDescription(annotation.description);
 361           annotationPojo.setValue(annotation.value);
 362           annotationPojo
 363                   .setSecondaryStructure(annotation.secondaryStructure);
 364           String displayChar = annotation.displayCharacter == null ? null
 365                   : annotation.displayCharacter;
 366           // jalview.bin.Console.outPrintln("--------------------->[" +
 367           // displayChar + "]");
 368           annotationPojo.setDisplayCharacter(displayChar);
 369           if (annotation.colour != null)
 370           {
 371             annotationPojo.setColour(
 372                     jalview.util.Format.getHexString(annotation.colour));
 373           }
 374           alignAnnotPojo.getAnnotations().add(annotationPojo);
 375         }
 376         else
 377         {
 378           if (annot.getCalcId() != null
 379                   && annot.getCalcId().equalsIgnoreCase(TCOFFEE_SCORE))
 380           {
 381             // do nothing
 382           }
 383           else
 384           {
 385             alignAnnotPojo.getAnnotations().add(annotationPojo);
 386           }
 387         }
 388       }
 389       jsonAnnotations.add(alignAnnotPojo);
 390     }
 391     return jsonAnnotations;
 392   }
 393
 394   @SuppressWarnings("unchecked")
 395   public JSONFile parse(Reader jsonAlignmentString)
 396   {
 397     try
 398     {
 399       Map<String, Object> alignmentJsonObj = (Map<String, Object>) JSONUtils
 400               .parse(jsonAlignmentString);
 401       List<Object> seqJsonArray = (List<Object>) alignmentJsonObj
 402               .get("seqs");
 403       List<Object> alAnnotJsonArray = (List<Object>) alignmentJsonObj
 404               .get("alignAnnotation");
 405       List<Object> jsonSeqArray = (List<Object>) alignmentJsonObj
 406               .get("seqFeatures");
 407       List<Object> seqGrpJsonArray = (List<Object>) alignmentJsonObj
 408               .get("seqGroups");
 409       Map<String, Object> jvSettingsJsonObj = (Map<String, Object>) alignmentJsonObj
 410               .get("appSettings");
 411
 412       if (jvSettingsJsonObj != null)
 413       {
 414         globalColourScheme = (String) jvSettingsJsonObj
 415                 .get("globalColorScheme");
 416         Boolean showFeatures = Boolean.valueOf(
 417                 jvSettingsJsonObj.get("showSeqFeatures").toString());
 418         setShowSeqFeatures(showFeatures);
 419         parseHiddenSeqRefsAsList(jvSettingsJsonObj);
 420         parseHiddenCols(jvSettingsJsonObj);
 421       }
 422
 423       hiddenSequences = new ArrayList<>();
 424       seqMap = new Hashtable<>();
 425       for (Iterator<Object> sequenceIter = seqJsonArray
 426               .iterator(); sequenceIter.hasNext();)
 427       {
 428         Map<String, Object> sequence = (Map<String, Object>) sequenceIter
 429                 .next();
 430         String sequcenceString = sequence.get("seq").toString();
 431         String sequenceName = sequence.get("name").toString();
 432         String seqUniqueId = sequence.get("id").toString();
 433         int start = Integer.valueOf(sequence.get("start").toString());
 434         int end = Integer.valueOf(sequence.get("end").toString());
 435         Sequence seq = new Sequence(sequenceName, sequcenceString, start,
 436                 end);
 437         if (hiddenSeqRefs != null && hiddenSeqRefs.contains(seqUniqueId))
 438         {
 439           hiddenSequences.add(seq);
 440         }
 441         seqs.add(seq);
 442         seqMap.put(seqUniqueId, seq);
 443       }
 444
 445       parseFeatures(jsonSeqArray);
 446
 447       for (Iterator<Object> seqGrpIter = seqGrpJsonArray
 448               .iterator(); seqGrpIter.hasNext();)
 449       {
 450         Map<String, Object> seqGrpObj = (Map<String, Object>) seqGrpIter
 451                 .next();
 452         String grpName = seqGrpObj.get("groupName").toString();
 453         String colourScheme = seqGrpObj.get("colourScheme").toString();
 454         String description = (seqGrpObj.get("description") == null) ? null
 455                 : seqGrpObj.get("description").toString();
 456         boolean displayBoxes = Boolean
 457                 .valueOf(seqGrpObj.get("displayBoxes").toString());
 458         boolean displayText = Boolean
 459                 .valueOf(seqGrpObj.get("displayText").toString());
 460         boolean colourText = Boolean
 461                 .valueOf(seqGrpObj.get("colourText").toString());
 462         boolean showNonconserved = Boolean
 463                 .valueOf(seqGrpObj.get("showNonconserved").toString());
 464         int startRes = Integer
 465                 .valueOf(seqGrpObj.get("startRes").toString());
 466         int endRes = Integer.valueOf(seqGrpObj.get("endRes").toString());
 467         List<Object> sequenceRefs = (List<Object>) seqGrpObj
 468                 .get("sequenceRefs");
 469
 470         ArrayList<SequenceI> grpSeqs = new ArrayList<>();
 471         if (sequenceRefs.size() > 0)
 472         {
 473           Iterator<Object> seqHashIter = sequenceRefs.iterator();
 474           while (seqHashIter.hasNext())
 475           {
 476             Sequence sequence = seqMap.get(seqHashIter.next());
 477             if (sequence != null)
 478             {
 479               grpSeqs.add(sequence);
 480             }
 481           }
 482         }
 483         SequenceGroup seqGrp = new SequenceGroup(grpSeqs, grpName, null,
 484                 displayBoxes, displayText, colourText, startRes, endRes);
 485         seqGrp.setColourScheme(ColourSchemeMapper
 486                 .getJalviewColourScheme(colourScheme, seqGrp));
 487         seqGrp.setShowNonconserved(showNonconserved);
 488         seqGrp.setDescription(description);
 489         this.seqGroups.add(seqGrp);
 490
 491       }
 492
 493       for (Iterator<Object> alAnnotIter = alAnnotJsonArray
 494               .iterator(); alAnnotIter.hasNext();)
 495       {
 496         Map<String, Object> alAnnot = (Map<String, Object>) alAnnotIter
 497                 .next();
 498         List<Object> annotJsonArray = (List<Object>) alAnnot
 499                 .get("annotations");
 500         Annotation[] annotations = new Annotation[annotJsonArray.size()];
 501         int count = 0;
 502         for (Iterator<Object> annotIter = annotJsonArray
 503                 .iterator(); annotIter.hasNext();)
 504         {
 505           Map<String, Object> annot = (Map<String, Object>) annotIter
 506                   .next();
 507           if (annot == null)
 508           {
 509             annotations[count] = null;
 510           }
 511           else
 512           {
 513             float val = annot.get("value") == null ? null
 514                     : Float.valueOf(annot.get("value").toString());
 515             String desc = annot.get("description") == null ? null
 516                     : annot.get("description").toString();
 517             char ss = annot.get("secondaryStructure") == null
 518                     || annot.get("secondaryStructure").toString()
 519                             .equalsIgnoreCase("u0000") ? ' '
 520                                     : annot.get("secondaryStructure")
 521                                             .toString().charAt(0);
 522             String displayChar = annot.get("displayCharacter") == null ? ""
 523                     : annot.get("displayCharacter").toString();
 524
 525             annotations[count] = new Annotation(displayChar, desc, ss, val);
 526             if (annot.get("colour") != null)
 527             {
 528               Color color = ColorUtils
 529                       .parseColourString(annot.get("colour").toString());
 530               annotations[count].colour = color;
 531             }
 532           }
 533           ++count;
 534         }
 535
 536         AlignmentAnnotation alignAnnot = new AlignmentAnnotation(
 537                 alAnnot.get("label").toString(),
 538                 alAnnot.get("description").toString(), annotations);
 539         alignAnnot.graph = (alAnnot.get("graphType") == null) ? 0
 540                 : Integer.valueOf(alAnnot.get("graphType").toString());
 541
 542         Map<String, Object> diplaySettings = (Map<String, Object>) alAnnot
 543                 .get("annotationSettings");
 544         if (diplaySettings != null)
 545         {
 546
 547           alignAnnot.scaleColLabel = (diplaySettings
 548                   .get("scaleColLabel") == null) ? false
 549                           : Boolean.valueOf(diplaySettings
 550                                   .get("scaleColLabel").toString());
 551           alignAnnot.showAllColLabels = (diplaySettings
 552                   .get("showAllColLabels") == null) ? true
 553                           : Boolean.valueOf(diplaySettings
 554                                   .get("showAllColLabels").toString());
 555           alignAnnot.centreColLabels = (diplaySettings
 556                   .get("centreColLabels") == null) ? true
 557                           : Boolean.valueOf(diplaySettings
 558                                   .get("centreColLabels").toString());
 559           alignAnnot.belowAlignment = (diplaySettings
 560                   .get("belowAlignment") == null) ? false
 561                           : Boolean.valueOf(diplaySettings
 562                                   .get("belowAlignment").toString());
 563           alignAnnot.visible = (diplaySettings.get("visible") == null)
 564                   ? true
 565                   : Boolean.valueOf(
 566                           diplaySettings.get("visible").toString());
 567           alignAnnot.hasIcons = (diplaySettings.get("hasIcon") == null)
 568                   ? true
 569                   : Boolean.valueOf(
 570                           diplaySettings.get("hasIcon").toString());
 571
 572         }
 573         if (alAnnot.get("score") != null)
 574         {
 575           alignAnnot.score = Double
 576                   .valueOf(alAnnot.get("score").toString());
 577         }
 578
 579         String calcId = (alAnnot.get("calcId") == null) ? ""
 580                 : alAnnot.get("calcId").toString();
 581         alignAnnot.setCalcId(calcId);
 582         String seqHash = (alAnnot.get("sequenceRef") != null)
 583                 ? alAnnot.get("sequenceRef").toString()
 584                 : null;
 585
 586         Sequence sequence = (seqHash != null) ? seqMap.get(seqHash) : null;
 587         if (sequence != null)
 588         {
 589           alignAnnot.sequenceRef = sequence;
 590           sequence.addAlignmentAnnotation(alignAnnot);
 591           if (alignAnnot.label.equalsIgnoreCase("T-COFFEE"))
 592           {
 593             alignAnnot.createSequenceMapping(sequence, sequence.getStart(),
 594                     false);
 595             sequence.addAlignmentAnnotation(alignAnnot);
 596             alignAnnot.adjustForAlignment();
 597           }
 598         }
 599         alignAnnot.validateRangeAndDisplay();
 600         this.annotations.add(alignAnnot);
 601
 602       }
 603     } catch (Exception e)
 604     {
 605       e.printStackTrace();
 606     }
 607     return this;
 608   }
 609
 610   public void parseHiddenSeqRefsAsList(Map<String, Object> jvSettingsJson)
 611   {
 612     hiddenSeqRefs = new ArrayList<>();
 613     String hiddenSeqs = (String) jvSettingsJson.get("hiddenSeqs");
 614     if (hiddenSeqs != null && !hiddenSeqs.isEmpty())
 615     {
 616       String[] seqRefs = hiddenSeqs.split(";");
 617       for (int i = 0, n = seqRefs.length; i < n; i++)
 618       {
 619         hiddenSeqRefs.add(seqRefs[i]);
 620       }
 621     }
 622   }
 623
 624   public void parseHiddenCols(Map<String, Object> jvSettingsJson)
 625   {
 626     String hiddenCols = (String) jvSettingsJson.get("hiddenCols");
 627     if (hiddenCols != null && !hiddenCols.isEmpty())
 628     {
 629       hiddenColumns = new HiddenColumns();
 630       String[] rangeStrings = hiddenCols.split(";");
 631       for (int i = 0, n = rangeStrings.length; i < n; i++)
 632       {
 633         String[] range = rangeStrings[i].split("-");
 634         hiddenColumns.hideColumns(Integer.valueOf(range[0]),
 635                 Integer.valueOf(range[1]));
 636       }
 637     }
 638   }
 639
 640   @SuppressWarnings("unchecked")
 641   private void parseFeatures(List<Object> jsonSeqFeatures)
 642   {
 643     if (jsonSeqFeatures != null)
 644     {
 645       displayedFeatures = new FeaturesDisplayed();
 646       for (Object o : jsonSeqFeatures)
 647       {
 648         Map<String, Object> jsonFeature = (Map<String, Object>) o;
 649         Long begin = (Long) jsonFeature.get("xStart");
 650         Long end = (Long) jsonFeature.get("xEnd");
 651         String type = (String) jsonFeature.get("type");
 652         String featureGrp = (String) jsonFeature.get("featureGroup");
 653         String description = (String) jsonFeature.get("description");
 654         String seqRef = (String) jsonFeature.get("sequenceRef");
 655         Float score = Float.valueOf(jsonFeature.get("score").toString());
 656
 657         Sequence seq = seqMap.get(seqRef);
 658
 659         /*
 660          * begin/end of 0 is for a non-positional feature
 661          */
 662         int featureBegin = begin.intValue() == 0 ? 0
 663                 : seq.findPosition(begin.intValue());
 664         int featureEnd = end.intValue() == 0 ? 0
 665                 : seq.findPosition(end.intValue()) - 1;
 666
 667         SequenceFeature sequenceFeature = new SequenceFeature(type,
 668                 description, featureBegin, featureEnd, score, featureGrp);
 669
 670         List<Object> linksJsonArray = (List<Object>) jsonFeature
 671                 .get("links");
 672         if (linksJsonArray != null && linksJsonArray.size() > 0)
 673         {
 674           Iterator<Object> linkList = linksJsonArray.iterator();
 675           while (linkList.hasNext())
 676           {
 677             sequenceFeature.addLink((String) linkList.next());
 678           }
 679         }
 680
 681         seq.addSequenceFeature(sequenceFeature);
 682         displayedFeatures.setVisible(type);
 683       }
 684     }
 685   }
 686
 687   @Override
 688   public String getGlobalColourScheme()
 689   {
 690     return globalColourScheme;
 691   }
 692
 693   public void setGlobalColorScheme(String globalColourScheme)
 694   {
 695     this.globalColourScheme = globalColourScheme;
 696   }
 697
 698   @Override
 699   public FeaturesDisplayedI getDisplayedFeatures()
 700   {
 701     return displayedFeatures;
 702   }
 703
 704   public void setDisplayedFeatures(FeaturesDisplayedI displayedFeatures)
 705   {
 706     this.displayedFeatures = displayedFeatures;
 707   }
 708
 709   @Override
 710   public void configureForView(AlignmentViewPanel avpanel)
 711   {
 712     if (avpanel == null)
 713     {
 714       return;
 715     }
 716     super.configureForView(avpanel);
 717     AlignViewportI viewport = avpanel.getAlignViewport();
 718     AlignmentI alignment = viewport.getAlignment();
 719     AlignmentAnnotation[] annots = alignment.getAlignmentAnnotation();
 720
 721     seqGroups = alignment.getGroups();
 722     fr = avpanel.cloneFeatureRenderer();
 723
 724     // Add non auto calculated annotation to AlignFile
 725     if (annots != null)
 726     {
 727       for (AlignmentAnnotation annot : annots)
 728       {
 729         if (annot != null && !annot.autoCalculated)
 730         {
 731           annotations.add(annot);
 732         }
 733       }
 734     }
 735     globalColourScheme = ColourSchemeProperty
 736             .getColourName(viewport.getGlobalColourScheme());
 737     setDisplayedFeatures(viewport.getFeaturesDisplayed());
 738     showSeqFeatures = viewport.isShowSequenceFeatures();
 739
 740   }
 741
 742   @Override
 743   public boolean isShowSeqFeatures()
 744   {
 745     return showSeqFeatures;
 746   }
 747
 748   public void setShowSeqFeatures(boolean showSeqFeatures)
 749   {
 750     this.showSeqFeatures = showSeqFeatures;
 751   }
 752
 753   public Vector<AlignmentAnnotation> getAnnotations()
 754   {
 755     return annotations;
 756   }
 757
 758   @Override
 759   public HiddenColumns getHiddenColumns()
 760   {
 761     return hiddenColumns;
 762   }
 763
 764   public void setHiddenColumns(HiddenColumns hidden)
 765   {
 766     this.hiddenColumns = hidden;
 767   }
 768
 769   @Override
 770   public SequenceI[] getHiddenSequences()
 771   {
 772     if (hiddenSequences == null || hiddenSequences.isEmpty())
 773     {
 774       return new SequenceI[] {};
 775     }
 776     synchronized (hiddenSequences)
 777     {
 778       return hiddenSequences.toArray(new SequenceI[hiddenSequences.size()]);
 779     }
 780   }
 781
 782   public void setHiddenSequences(ArrayList<SequenceI> hiddenSequences)
 783   {
 784     this.hiddenSequences = hiddenSequences;
 785   }
 786
 787   public class JSONExportSettings
 788   {
 789     private boolean exportSequence;
 790
 791     private boolean exportSequenceFeatures;
 792
 793     private boolean exportAnnotations;
 794
 795     private boolean exportGroups;
 796
 797     private boolean exportJalviewSettings;
 798
 799     public boolean isExportSequence()
 800     {
 801       return exportSequence;
 802     }
 803
 804     public void setExportSequence(boolean exportSequence)
 805     {
 806       this.exportSequence = exportSequence;
 807     }
 808
 809     public boolean isExportSequenceFeatures()
 810     {
 811       return exportSequenceFeatures;
 812     }
 813
 814     public void setExportSequenceFeatures(boolean exportSequenceFeatures)
 815     {
 816       this.exportSequenceFeatures = exportSequenceFeatures;
 817     }
 818
 819     public boolean isExportAnnotations()
 820     {
 821       return exportAnnotations;
 822     }
 823
 824     public void setExportAnnotations(boolean exportAnnotations)
 825     {
 826       this.exportAnnotations = exportAnnotations;
 827     }
 828
 829     public boolean isExportGroups()
 830     {
 831       return exportGroups;
 832     }
 833
 834     public void setExportGroups(boolean exportGroups)
 835     {
 836       this.exportGroups = exportGroups;
 837     }
 838
 839     public boolean isExportJalviewSettings()
 840     {
 841       return exportJalviewSettings;
 842     }
 843
 844     public void setExportJalviewSettings(boolean exportJalviewSettings)
 845     {
 846       this.exportJalviewSettings = exportJalviewSettings;
 847     }
 848   }
 849
 850   /**
 851    * Returns a descriptor for suitable feature display settings with
 852    * <ul>
 853    * <li>ResNums or insertions features visible</li>
 854    * <li>insertions features coloured red</li>
 855    * <li>ResNum features coloured by label</li>
 856    * <li>Insertions displayed above (on top of) ResNums</li>
 857    * </ul>
 858    */
 859   @Override
 860   public FeatureSettingsModelI getFeatureColourScheme()
 861   {
 862     return new PDBFeatureSettings();
 863   }
 864 }