mpicbg-trakem2/src/main/java/mpicbg/trakem2/transform/NonLinearCoordinateTransform.java

   1 /**
   2  *
   3  *      Copyright (C) 2008 Verena Kaynig.
   4  *
   5  *      This program is free software; you can redistribute it and/or
   6  *      modify it under the terms of the GNU General Public License
   7  *      as published by the Free Software Foundation (http://www.gnu.org/licenses/gpl.txt )
   8  *
   9  *      This program is distributed in the hope that it will be useful,
  10  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *      GNU General Public License for more details.
  13  *
  14  *      You should have received a copy of the GNU General Public License
  15  *      along with this program; if not, write to the Free Software
  16  *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 /* ****************************************************************  *
  20  * Representation of a non linear transform by explicit polynomial
  21  * kernel expansion.
  22  *
  23  * TODO:
  24  *      - make different kernels available
  25  *      - inverse transform for visualization
  26  *  - improve image interpolation
  27  *  - apply and applyInPlace should use precalculated transform?
  28  *    (What about out of image range pixels?)
  29  *
  30  *  Author: Verena Kaynig
  31  *  Kontakt: verena.kaynig@inf.ethz.ch
  32  *
  33  * ****************************************************************  */
  34
  35 package mpicbg.trakem2.transform;
  36
  37 public class NonLinearCoordinateTransform implements mpicbg.trakem2.transform.CoordinateTransform
  38 {
  39         protected double[][] beta = null;
  40         protected double[] normMean = null;
  41         protected double[] normVar = null;
  42         protected int dimension = 0;
  43         protected int length = 0;
  44         protected int width = 0;
  45         protected int height = 0;
  46
  47         public NonLinearCoordinateTransform(){};
  48
  49         @Override
  50         public void init( final String data ) throws NumberFormatException{
  51                 final String[] fields = data.split( " " );
  52                 int c = 0;
  53
  54                 dimension = Integer.parseInt(fields[c]); c++;
  55                 length = Integer.parseInt(fields[c]); c++;
  56
  57                 beta = new double[length][2];
  58                 normMean = new double[length];
  59                 normVar = new double[length];
  60
  61                 if ( fields.length == 4 + 4*length )
  62                 {
  63                         for (int i=0; i < length; i++){
  64                                 beta[i][0] = Double.parseDouble(fields[c]); c++;
  65                                 beta[i][1] = Double.parseDouble(fields[c]); c++;
  66                         }
  67
  68                         for (int i=0; i < length; i++){
  69                                 normMean[i] = Double.parseDouble(fields[c]); c++;
  70                         }
  71
  72                         for (int i=0; i < length; i++){
  73                                 normVar[i] = Double.parseDouble(fields[c]); c++;
  74                         }
  75
  76                         width = Integer.parseInt(fields[c]); c++;
  77                         height = Integer.parseInt(fields[c]); c++;
  78
  79                 }
  80                 else throw new NumberFormatException( "Inappropriate parameters for " + this.getClass().getCanonicalName() );
  81         }
  82
  83         @Override
  84         public String toXML(final String indent){
  85                 return new StringBuilder(indent).append("<ict_transform class=\"").append(this.getClass().getCanonicalName()).append("\" data=\"").append(toDataString()).append("\"/>").toString();
  86         }
  87
  88         @Override
  89         public String toDataString(){
  90                 String data = "";
  91                 data += Integer.toString(dimension) + " ";
  92                 data += Integer.toString(length) + " ";
  93
  94                 for (int i=0; i < length; i++){
  95                         data += Double.toString(beta[i][0]) + " ";
  96                         data += Double.toString(beta[i][1]) + " ";
  97                 }
  98
  99                 for (int i=0; i < length; i++){
 100                         data += Double.toString(normMean[i]) + " ";
 101                 }
 102
 103                 for (int i=0; i < length; i++){
 104                         data += Double.toString(normVar[i]) + " ";
 105                 }
 106                 data += Integer.toString(width) + " ";
 107                 data += Integer.toString(height) + " ";
 108
 109                 return data;
 110
 111         }
 112
 113         @Override
 114         public String toString(){ return toDataString(); }
 115
 116     @Override
 117     public float[] apply(final float[] location) {
 118
 119         final double[] position = { (double) location[0], (double) location[1] };
 120         final double[] featureVector = kernelExpand(position);
 121         final double[] newPosition = multiply(beta, featureVector);
 122
 123         final float[] newLocation = new float[2];
 124         newLocation[0] = (float) newPosition[0];
 125         newLocation[1] = (float) newPosition[1];
 126
 127         return newLocation;
 128     }
 129
 130     @Override
 131     public void applyInPlace(final float[] location) {
 132         final double[] position = { (double) location[0], (double) location[1] };
 133         final double[] featureVector = kernelExpand(position);
 134         final double[] newPosition = multiply(beta, featureVector);
 135
 136         location[0] = (float) newPosition[0];
 137         location[1] = (float) newPosition[1];
 138     }
 139
 140
 141     static protected double[] multiply(final double beta[][], final double featureVector[]) {
 142         final double[] result = { 0.0, 0.0 };
 143
 144         if (beta.length != featureVector.length)
 145         {
 146             return new double[2];
 147         }
 148
 149         for (int i = 0; i < featureVector.length; ++i)
 150         {
 151             result[0] = result[0] + featureVector[i] * beta[i][0];
 152             result[1] = result[1] + featureVector[i] * beta[i][1];
 153         }
 154
 155         return result;
 156     }
 157
 158     public double[] kernelExpand( final double position[] ) {
 159         final double expanded[] = new double[length];
 160
 161         int counter = 0;
 162         for (int i = 1; i <= dimension; i++) {
 163             for (double j = i; j >= 0; j--) {
 164                 final double val = Math.pow(position[0], j)
 165                         * Math.pow(position[1], i - j);
 166                 expanded[counter] = val;
 167                 ++counter;
 168             }
 169         }
 170
 171         for (int i = 0; i < length - 1; i++) {
 172             expanded[i] = expanded[i] - normMean[i];
 173             expanded[i] = expanded[i] / normVar[i];
 174         }
 175
 176         expanded[length - 1] = 100;
 177
 178         return expanded;
 179     }
 180
 181     /**
 182      * TODO Make this more efficient
 183      */
 184     @Override
 185     public NonLinearCoordinateTransform copy()
 186     {
 187         final NonLinearCoordinateTransform t = new NonLinearCoordinateTransform();
 188         t.init(toDataString());
 189         return t;
 190     }
 191 }