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