src/jalview/io/FormatAdapter.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 package jalview.io;
  22
  23 import jalview.api.AlignExportSettingI;
  24 import jalview.api.AlignmentViewPanel;
  25 import jalview.bin.Cache;
  26 import jalview.datamodel.Alignment;
  27 import jalview.datamodel.AlignmentAnnotation;
  28 import jalview.datamodel.AlignmentI;
  29 import jalview.datamodel.HiddenColumns;
  30 import jalview.datamodel.Sequence;
  31 import jalview.datamodel.SequenceGroup;
  32 import jalview.datamodel.SequenceI;
  33 import jalview.util.Comparison;
  34
  35 import java.io.IOException;
  36 import java.util.Locale;
  37
  38 /**
  39  * Additional formatting methods used by the application in a number of places.
  40  *
  41  * @author $author$
  42  * @version $Revision$
  43  */
  44 public class FormatAdapter extends AppletFormatAdapter
  45 {
  46   public FormatAdapter(AlignmentViewPanel viewpanel)
  47   {
  48     super(viewpanel);
  49     init();
  50   }
  51
  52   public FormatAdapter()
  53   {
  54     super();
  55     init();
  56   }
  57
  58   public FormatAdapter(AlignmentViewPanel alignPanel,
  59           AlignExportSettingI settings)
  60   {
  61     super(alignPanel, settings);
  62   }
  63
  64   private void init()
  65   {
  66     if (jalview.bin.Cache.getDefault("STRUCT_FROM_PDB", true))
  67     {
  68       annotFromStructure = jalview.bin.Cache.getDefault("ADD_TEMPFACT_ANN",
  69               true);
  70       localSecondaryStruct = jalview.bin.Cache.getDefault("ADD_SS_ANN",
  71               true);
  72       serviceSecondaryStruct = jalview.bin.Cache.getDefault("USE_RNAVIEW",
  73               true);
  74     }
  75     else
  76     {
  77       // disable all PDB annotation options
  78       annotFromStructure = false;
  79       localSecondaryStruct = false;
  80       serviceSecondaryStruct = false;
  81     }
  82   }
  83
  84   public String formatSequences(FileFormatI format, SequenceI[] seqs,
  85           String[] omitHiddenColumns, int[] exportRange)
  86   {
  87
  88     return formatSequences(format,
  89             replaceStrings(seqs, omitHiddenColumns, exportRange));
  90   }
  91
  92   /**
  93    * create sequences with each sequence string replaced with the one given in
  94    * omitHiddenCOlumns
  95    *
  96    * @param seqs
  97    * @param omitHiddenColumns
  98    * @return new sequences
  99    */
 100   public SequenceI[] replaceStrings(SequenceI[] seqs,
 101           String[] omitHiddenColumns, int[] startEnd)
 102   {
 103     if (omitHiddenColumns != null)
 104     {
 105       SequenceI[] tmp = new SequenceI[seqs.length];
 106
 107       int startRes;
 108       int endRes;
 109       int startIndex;
 110       int endIndex;
 111       for (int i = 0; i < seqs.length; i++)
 112       {
 113         startRes = seqs[i].getStart();
 114         endRes = seqs[i].getEnd();
 115         if (startEnd != null)
 116         {
 117           startIndex = startEnd[0];
 118           endIndex = startEnd[1];
 119           // get first non-gaped residue start position
 120           while (Comparison.isGap(seqs[i].getCharAt(startIndex))
 121                   && startIndex < endIndex)
 122           {
 123             startIndex++;
 124           }
 125
 126           // get last non-gaped residue end position
 127           while (Comparison.isGap(seqs[i].getCharAt(endIndex))
 128                   && endIndex > startIndex)
 129           {
 130             endIndex--;
 131           }
 132
 133           startRes = seqs[i].findPosition(startIndex);
 134           endRes = seqs[i].findPosition(endIndex);
 135         }
 136
 137         tmp[i] = new Sequence(seqs[i].getName(), omitHiddenColumns[i],
 138                 startRes, endRes);
 139         tmp[i].setDescription(seqs[i].getDescription());
 140       }
 141       seqs = tmp;
 142     }
 143     return seqs;
 144   }
 145
 146   /**
 147    * Format a vector of sequences as a flat alignment file. TODO: allow caller
 148    * to detect errors and warnings encountered when generating output
 149    *
 150    *
 151    * @param format
 152    * @param seqs
 153    *          vector of sequences to write
 154    *
 155    * @return String containing sequences in desired format
 156    */
 157   public String formatSequences(FileFormatI format, SequenceI[] seqs)
 158   {
 159     boolean withSuffix = getCacheSuffixDefault(format);
 160     return format.getWriter(null).print(seqs, withSuffix);
 161   }
 162
 163   public boolean getCacheSuffixDefault(FileFormatI format)
 164   {
 165     return Cache.getDefault(format.getName().toUpperCase(Locale.ROOT) + "_JVSUFFIX",
 166             true);
 167   }
 168
 169   public String formatSequences(FileFormatI format, AlignmentI alignment,
 170           String[] omitHidden, int[] exportRange, HiddenColumns hidden)
 171   {
 172     return formatSequences(format, alignment, omitHidden, exportRange,
 173             getCacheSuffixDefault(format), hidden, null);
 174   }
 175
 176   /**
 177    * hack function to replace sequences with visible sequence strings before
 178    * generating a string of the alignment in the given format.
 179    *
 180    * @param format
 181    * @param alignment
 182    * @param omitHidden
 183    *          sequence strings to write out in order of sequences in alignment
 184    * @param colSel
 185    *          defines hidden columns that are edited out of annotation
 186    * @return string representation of the alignment formatted as format
 187    */
 188   public String formatSequences(FileFormatI format, AlignmentI alignment,
 189           String[] omitHidden, int[] exportRange, boolean suffix,
 190           HiddenColumns hidden)
 191   {
 192     return formatSequences(format, alignment, omitHidden, exportRange,
 193             suffix, hidden, null);
 194   }
 195
 196   public String formatSequences(FileFormatI format, AlignmentI alignment,
 197           String[] omitHidden, int[] exportRange, boolean suffix,
 198           HiddenColumns hidden, SequenceGroup selgp)
 199   {
 200     if (omitHidden != null)
 201     {
 202       // TODO consider using AlignmentView to prune to visible region
 203       // TODO prune sequence annotation and groups to visible region
 204       // TODO: JAL-1486 - set start and end for output correctly. basically,
 205       // AlignmentView.getVisibleContigs does this.
 206       Alignment alv = new Alignment(replaceStrings(
 207               alignment.getSequencesArray(), omitHidden, exportRange));
 208       AlignmentAnnotation[] ala = alignment.getAlignmentAnnotation();
 209       if (ala != null)
 210       {
 211         for (int i = 0; i < ala.length; i++)
 212         {
 213           AlignmentAnnotation na = new AlignmentAnnotation(ala[i]);
 214           if (selgp != null)
 215           {
 216             na.makeVisibleAnnotation(selgp.getStartRes(), selgp.getEndRes(),
 217                     hidden);
 218           }
 219           else
 220           {
 221             na.makeVisibleAnnotation(hidden);
 222           }
 223           alv.addAnnotation(na);
 224         }
 225       }
 226       return this.formatSequences(format, alv, suffix);
 227     }
 228     return this.formatSequences(format, alignment, suffix);
 229   }
 230
 231   @Override
 232   public AlignmentI readFile(String file, DataSourceType sourceType,
 233           FileFormatI fileFormat) throws IOException
 234   {
 235     AlignmentI al = super.readFile(file, sourceType, fileFormat);
 236     return al;
 237   }
 238
 239   @Override
 240   public AlignmentI readFromFile(FileParse source, FileFormatI format)
 241           throws IOException
 242   {
 243     AlignmentI al = super.readFromFile(source, format);
 244     return al;
 245   }
 246
 247   /**
 248    * Create a flat file representation of a given view or selected region of a
 249    * view
 250    *
 251    * @param format
 252    * @param ap
 253    *          alignment panel originating the view
 254    * @return String containing flat file
 255    */
 256   public String formatSequences(FileFormatI format, AlignmentViewPanel ap,
 257           boolean selectedOnly)
 258   {
 259     return formatSequences(format, getCacheSuffixDefault(format), ap,
 260             selectedOnly);
 261   }
 262
 263   public AlignmentI readFromFile(AlignmentFileReaderI source,
 264           FileFormatI format) throws IOException
 265   {
 266     FileParse fp = new FileParse(source.getInFile(),
 267             source.getDataSourceType());
 268     return readFromFile(fp, format);
 269   }
 270
 271 }