// Copyright 2004-2005, FreeHEP.
   package hep.wired.heprep.projection;
   
   import java.awt.geom.*;
   import java.util.*;
   
   import org.jdom.Element;
   
   import org.freehep.xml.io.XMLIO;
  import org.freehep.xml.io.XMLIOManager;
  
  import hep.wired.feature.Rotateable2D;
  import hep.wired.feature.Transformable2D;
  import hep.wired.feature.Resetable;
  import hep.wired.services.ViewPort;
  import hep.wired.heprep.services.Projection;
  import hep.wired.util.Matrix2D;
  
  /***
   * 2D projection of (X,Y) into (U,V).
   *
   * @author Mark Donszelmann
   * @version $Id: FlatProjection.java 2074 2005-07-20 06:22:09Z duns $
   */
  
  public class FlatProjection extends AbstractProjection 
          implements Rotateable2D, Transformable2D, 
                     Resetable {
  
      // FIXME WIRED-242, take from preferences
      public final static double defaultScaleFactor = 0.001;
  
      private Matrix2D matrix;
      private Matrix2D resetMatrix;
      
      /***
       * Creates a 2D projection with given scale factor.
       */
      public FlatProjection(double s) {
          this(new Matrix2D(s, 0, 
                            0, s, 
                            0, 0));
      }
      
      /***
       * Creates a 2D projection.
       */ 
      public FlatProjection() {
          this(defaultScaleFactor);
      }
      
      private FlatProjection(Matrix2D matrix) {
          this(matrix, matrix);
      }
      
      private FlatProjection(Matrix2D matrix, Matrix2D resetMatrix) {
          super();
          this.matrix = (Matrix2D)matrix.clone();
          this.resetMatrix = (Matrix2D)resetMatrix.clone();
      }
  
      public String getFormula() {
          return "(u,v,w) = "+
                 "m00*x + m01*y + m02, "+
                 "m10*x + m11*y + m12, "+
          	   "z";
      }
      
      public double[] transform(double[] xyz) {
          return matrix.transform(xyz, false);
      }
      
      public double[][] transform(double[][] xyz, int n) {
          return matrix.transform(xyz, n, false);
      }
  
      public double[] deltaTransform(double[] xyz) {
          return matrix.transform(xyz, true);
      }
  
      public double[] inverseTransform(double[] uvw) throws UnsupportedOperationException {
          try {
              Matrix2D inverse = matrix.createInverse();
              return inverse.transform(uvw, false);
          } catch (NoninvertibleTransformException e) {
              throw new UnsupportedOperationException(e.getMessage());
          }
      }
      
      public double[] inverseDeltaTransform(double[] uvw) throws UnsupportedOperationException {
          try {
              Matrix2D inverse = matrix.createInverse();
              return inverse.transform(uvw, true);
          } catch (NoninvertibleTransformException e) {
              throw new UnsupportedOperationException(e.getMessage());
          }
      }
      
      public Projection copy() {
         return new FlatProjection(matrix, resetMatrix);
     }
 
     public String toString() {
         return super.toString()+" : \n"+matrix.toString();
     }
 
 // Rotateable2D
     public void rotate(double theta) {
         matrix.rotate(theta);
     }
 
 // Translateable
     public double[] getModelTranslation(double[] uvw, ViewPort viewPort) {
         uvw = viewPort.inverseDeltaTransform(uvw);
         return inverseDeltaTransform(uvw);         
     }
 
     public double[] getScreenTranslation(double[] xyz, ViewPort viewPort) {
         xyz = deltaTransform(xyz);
         return viewPort.deltaTransform(xyz);
     }
 
 // Transformable2D
     public void scale(double s) {
         scale(s, s);
     }
     
     public void setScale(double s) {
         setScale(s, s);
     }
     
     public void scale(double sx, double sy) {
         matrix.scale(sx, sy);
     }
 
     public void setScale(double sx, double sy) {
         double[] s = getScale();
         matrix.scale(sx/s[X], sy/s[Y]);
     }
 
     public double[] getScale() {
         return new double[] {matrix.getScaleX(), matrix.getScaleY()};
     }
 
     public void shear(double shx, double shy) {
         matrix.shear(shx, shy);
     }
         
     public void translate(double tx, double ty) {
         matrix.modelTranslate(tx, ty);
     }
 
     public void setTranslate(double tx, double ty) {
         double[] t = getTranslate();
         matrix.modelTranslate(tx - t[X], ty - t[Y]);
     }
 
     public double[] getTranslate() {
         return inverseDeltaTransform(new double[] {matrix.getTranslateX(), matrix.getTranslateY()});
     }
 
 // Resetable
     public Object reset(Object newState) {
         Object oldState = matrix.clone();
         matrix = (newState == null) ? (Matrix2D)resetMatrix.clone() : (Matrix2D)newState;
         return oldState;
     }
 
 //
 // XMLIO
 //
     public void save(XMLIOManager xmlioManager,
                      org.jdom.Element nodeEl) {
         super.save(xmlioManager, nodeEl);
         nodeEl.addContent(xmlioManager.save(matrix));
         nodeEl.addContent(xmlioManager.save(resetMatrix));
     }
 
     public void restore(XMLIOManager xmlioManager,
                         org.jdom.Element nodeEl) {
         super.restore(xmlioManager, nodeEl);
         Iterator i=nodeEl.getChildren().iterator();
         matrix = (Matrix2D)xmlioManager.restore((Element)i.next());
         resetMatrix = (Matrix2D)xmlioManager.restore((Element)i.next());
     }     
 }