src/jalview/viewmodel/PCAModel.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.viewmodel;
  22
  23 import jalview.analysis.PCA;
  24 import jalview.api.RotatableCanvasI;
  25 import jalview.api.analysis.ScoreModelI;
  26 import jalview.api.analysis.SimilarityParamsI;
  27 import jalview.datamodel.AlignmentView;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.datamodel.SequencePoint;
  30
  31 import java.util.Vector;
  32
  33 public class PCAModel
  34 {
  35   private volatile PCA pca;
  36
  37   int top;
  38
  39   AlignmentView seqstrings;
  40
  41   SequenceI[] seqs;
  42
  43   /*
  44    * Score model used to calculate PCA
  45    */
  46   ScoreModelI scoreModel;
  47
  48   private boolean nucleotide = false;
  49
  50   private Vector<SequencePoint> points;
  51
  52   private boolean jvCalcMode = true;
  53
  54   private SimilarityParamsI similarityParams;
  55
  56   /**
  57    * Constructor given sequence data, score model and score calculation
  58    * parameter options.
  59    *
  60    * @param seqData
  61    * @param sqs
  62    * @param nuc
  63    * @param sm
  64    * @param params
  65    */
  66   public PCAModel(AlignmentView seqData, SequenceI[] sqs, boolean nuc, ScoreModelI sm,
  67           SimilarityParamsI params)
  68   {
  69     seqstrings = seqData;
  70     seqs = sqs;
  71     nucleotide = nuc;
  72     scoreModel = sm;
  73     similarityParams = params;
  74   }
  75
  76   public boolean isJvCalcMode()
  77   {
  78     return jvCalcMode;
  79   }
  80
  81   public void run()
  82   {
  83     pca = new PCA(seqstrings, scoreModel, similarityParams);
  84     pca.setJvCalcMode(jvCalcMode);
  85     pca.run();
  86
  87     // Now find the component coordinates
  88     int ii = 0;
  89
  90     while ((ii < seqs.length) && (seqs[ii] != null))
  91     {
  92       ii++;
  93     }
  94
  95     int height = pca.getHeight();
  96     // top = pca.getM().height() - 1;
  97     top = height - 1;
  98
  99     points = new Vector<SequencePoint>();
 100     float[][] scores = pca.getComponents(top - 1, top - 2, top - 3, 100);
 101
 102     for (int i = 0; i < height; i++)
 103     {
 104       SequencePoint sp = new SequencePoint(seqs[i], scores[i]);
 105       points.addElement(sp);
 106     }
 107   }
 108
 109   public void updateRc(RotatableCanvasI rc)
 110   {
 111     rc.setPoints(points, pca.getHeight());
 112   }
 113
 114   public boolean isNucleotide()
 115   {
 116     return nucleotide;
 117   }
 118
 119   public void setNucleotide(boolean nucleotide)
 120   {
 121     this.nucleotide = nucleotide;
 122   }
 123
 124   /**
 125    *
 126    *
 127    * @return index of principle dimension of PCA
 128    */
 129   public int getTop()
 130   {
 131     return top;
 132   }
 133
 134   /**
 135    * update the 2d coordinates for the list of points to the given dimensions
 136    * Principal dimension is getTop(). Next greatest eigenvector is getTop()-1.
 137    * Note - pca.getComponents starts counting the spectrum from rank-2 to zero,
 138    * rather than rank-1, so getComponents(dimN ...) == updateRcView(dimN+1 ..)
 139    *
 140    * @param dim1
 141    * @param dim2
 142    * @param dim3
 143    */
 144   public void updateRcView(int dim1, int dim2, int dim3)
 145   {
 146     // note: actual indices for components are dim1-1, etc (patch for JAL-1123)
 147     float[][] scores = pca.getComponents(dim1 - 1, dim2 - 1, dim3 - 1, 100);
 148
 149     for (int i = 0; i < pca.getHeight(); i++)
 150     {
 151       points.elementAt(i).coord = scores[i];
 152     }
 153   }
 154
 155   public String getDetails()
 156   {
 157     return pca.getDetails();
 158   }
 159
 160   public AlignmentView getSeqtrings()
 161   {
 162     return seqstrings;
 163   }
 164
 165   public String getPointsasCsv(boolean transformed, int xdim, int ydim,
 166           int zdim)
 167   {
 168     StringBuffer csv = new StringBuffer();
 169     csv.append("\"Sequence\"");
 170     if (transformed)
 171     {
 172       csv.append(",");
 173       csv.append(xdim);
 174       csv.append(",");
 175       csv.append(ydim);
 176       csv.append(",");
 177       csv.append(zdim);
 178     }
 179     else
 180     {
 181       for (int d = 1, dmax = pca.component(1).length; d <= dmax; d++)
 182       {
 183         csv.append("," + d);
 184       }
 185     }
 186     csv.append("\n");
 187     for (int s = 0; s < seqs.length; s++)
 188     {
 189       csv.append("\"" + seqs[s].getName() + "\"");
 190       double fl[];
 191       if (!transformed)
 192       {
 193         // output pca in correct order
 194         fl = pca.component(s);
 195         for (int d = fl.length - 1; d >= 0; d--)
 196         {
 197           csv.append(",");
 198           csv.append(fl[d]);
 199         }
 200       }
 201       else
 202       {
 203         // output current x,y,z coords for points
 204         fl = getPointPosition(s);
 205         for (int d = 0; d < fl.length; d++)
 206         {
 207           csv.append(",");
 208           csv.append(fl[d]);
 209         }
 210       }
 211       csv.append("\n");
 212     }
 213     return csv.toString();
 214   }
 215
 216   /**
 217    *
 218    * @return x,y,z positions of point s (index into points) under current
 219    *         transform.
 220    */
 221   public double[] getPointPosition(int s)
 222   {
 223     double pts[] = new double[3];
 224     float[] p = points.elementAt(s).coord;
 225     pts[0] = p[0];
 226     pts[1] = p[1];
 227     pts[2] = p[2];
 228     return pts;
 229   }
 230
 231   public void setJvCalcMode(boolean state)
 232   {
 233     jvCalcMode = state;
 234   }
 235
 236   public String getScoreModelName()
 237   {
 238     return scoreModel == null ? "" : scoreModel.getName();
 239   }
 240
 241   public void setScoreModel(ScoreModelI sm)
 242   {
 243     this.scoreModel = sm;
 244   }
 245
 246 }