// Copyright 2004, FreeHEP.
   package hep.wired.heprep.projection;
   
   import java.util.*;
   
   import org.jdom.Element;
   
   import org.freehep.xml.io.XMLIO;
   import org.freehep.xml.io.XMLIOManager;
  
  import hep.wired.services.Feature;
  import hep.wired.services.ViewPort;
  import hep.wired.feature.Resetable;
  import hep.wired.heprep.services.Projection;
  
  /***
   * Sequence of projections.
   *
   * @author Mark Donszelmann
   * @version $Id: CompositeProjection.java 645 2005-02-27 02:23:41Z duns $
   */
  
  public class CompositeProjection extends AbstractProjection implements Resetable {
  
      // used array for speed of projections
      private Projection[] projections = new Projection[5];
      private int noOfProjections = 0;
  
      /***
       * Creates a composite projection. A transform called on this
       * projection will use all added projections to transform x,y,z into u,v,w.
       */
      public CompositeProjection() {
          this(null);
      }
  
      /***
       * Creates a named empty composite projection. A transform called on this
       * projection will use all added projections to transform x,y,z into u,v,w.
       */
      public CompositeProjection(String name) {
          super(name);
      }
  
      /***
       * Creates a named composite projection filled with the given array of
       * projections. A transform called on this projection will use those 
       * projections to transform x,y,z into u,v,w.
       */
      public CompositeProjection(String name, Projection[] projections) {
          super(name);
          this.noOfProjections = projections.length;
          this.projections = new Projection[noOfProjections];
          System.arraycopy(projections, 0, this.projections, 0, noOfProjections);
      }
  
      public String getFormula() {
          return "(u,v,w) = Composite"+getName()+"(x,y,z)";   
      }
   
      public boolean supports(Class featureClass) {
          for (int i=0; i<noOfProjections; i++) {
              if (projections[i].supports(featureClass)) return true;
          }
          return false;
      }
      
      public Feature getFeature(Class featureClass) {
          for (int i=0; i<noOfProjections; i++) {
              Feature f = projections[i].getFeature(featureClass);
              if (f != null) return f;
          } 
          return null;
      }
  
      public void setViewPort(ViewPort viewPort) {
          super.setViewPort(viewPort);
          for (int i=0; i<noOfProjections; i++) {
              projections[i].setViewPort(viewPort);
          }
      }
  
      /***
       * Adds a projection to the end of the list.
       */
      public void add(Projection p) {
          if (noOfProjections >= projections.length) {
              Projection[] old = projections;
              projections = new Projection[projections.length + 5];
              System.arraycopy(old, 0, projections, 0, projections.length);   
          }
          projections[noOfProjections] = p;
          noOfProjections++;
      }
      
      // FIXME WIRED-256 we may need move and insert...
      /***
       * Returns the list of projections.
       */
     public List/*<Projection>*/ getProjections() {
         List list = new LinkedList();
         for (int i=0; i<noOfProjections; i++) {
             list.add(projections[i]);
         }
         return list;
     }
     
     public double[] transform(double[] xyz) {
         for (int i=0; i<noOfProjections; i++) {
             xyz = projections[i].transform(xyz);
         } 
         return xyz;
     }    
 
     public double[][] transform(double[][] xyz, int n) {
         for (int i=0; i<noOfProjections; i++) {
             xyz = projections[i].transform(xyz, n);
         } 
         return xyz;
     }
 
     public double[] deltaTransform(double[] xyz) {
         for (int i=0; i<noOfProjections; i++) {
             xyz = projections[i].deltaTransform(xyz);
         } 
         return xyz;
     }    
 
     public double[] inverseTransform(double[] uvw) throws UnsupportedOperationException {
         for (int i=noOfProjections-1; i>=0; i--) {
             uvw = projections[i].inverseTransform(uvw);
         } 
         return uvw;        
     }
 
     public double[] inverseDeltaTransform(double[] uvw) throws UnsupportedOperationException {
         for (int i=noOfProjections-1; i>=0; i--) {
             uvw = projections[i].inverseDeltaTransform(uvw);
         } 
         return uvw;        
     }
 
     public Projection copy() {
         CompositeProjection cp = new CompositeProjection(getName());
         for (int i=0; i<noOfProjections; i++) {
             cp.add(projections[i].copy());
         }
         return cp;
     }
     
 // Resetable
     public Object reset(Object newStates) {
         Object[] oldStates = new Object[noOfProjections];
         Object[] array = (Object[])newStates;
         
         for (int i=0; i<noOfProjections; i++) {
             Object state = (array != null) ? array[i] : null;
             if (projections[i] instanceof Resetable) {
                 oldStates[i] = ((Resetable)projections[i]).reset(state);
             }
         }
         return oldStates;
     }    
 
 
 //
 // XMLIO
 //
     public void save(XMLIOManager xmlioManager,
                      org.jdom.Element nodeEl) {
         super.save(xmlioManager, nodeEl);
         for (int i=0; i<noOfProjections; i++) {
             nodeEl.addContent(xmlioManager.save(projections[i]));
         }
     }
 
     public void restore(XMLIOManager xmlioManager,
                         org.jdom.Element nodeEl) {
         super.restore(xmlioManager, nodeEl);
         for (Iterator i=nodeEl.getChildren().iterator(); i.hasNext(); ) {
             Element element = (Element)i.next();
             add((Projection)xmlioManager.restore(element));
         }
     }     
 }