/**
 * This source code file is part of a direct port of Stan Birchfield's implementation
 * of a Kanade-Lucas-Tomasi feature tracker. The original implementation can be found
 * here: http://www.ces.clemson.edu/~stb/klt/
 *
 * As per the original code, the source code is in the public domain, available
 * for both commercial and non-commercial use.
 */
package org.openimaj.video.tracking.klt;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;

import org.openimaj.image.FImage;
import org.openimaj.image.MBFImage;
import org.openimaj.math.geometry.shape.Rectangle;


/**
 * A list of features
 * 
 * @author Stan Birchfield
 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
 */
public class FeatureList implements Iterable<Feature> {
        /**
         * The list of features
         */
        public Feature[] features;

        /*********************************************************************
         * KLTCreateFeatureList
         * @param nFeatures 
         */
        public FeatureList(int nFeatures)
        {
                features = new Feature[nFeatures];

                for (int i = 0 ; i < nFeatures ; i++) {
                        features[i] = new Feature();
                }
        }

        /*********************************************************************
         * KLTCountRemainingFeatures
         * @return the number of remaining features
         */
        public int countRemainingFeatures()
        {
                int count = 0;

                for (Feature f : features)
                        if (f.val >= 0) count++;

                return count;
        }
        
        @Override
        public FeatureList clone(){
                FeatureList ret = new FeatureList(this.features.length);
                for(int i = 0; i < this.features.length; i++){
                        ret.features[i] = this.features[i].clone();
                }
                return ret;
                
        }
        
        /*********************************************************************
         * KLTWriteFeatureListToPPM
         * @param img 
         * @return a new image 
         */
        public MBFImage drawFeatures(FImage img)
        {
                /* Allocate memory for component images */
                FImage redimg = img.clone();
                FImage grnimg = img.clone();
                FImage bluimg = img.clone();  

                /* Overlay features in red */
                for (int i = 0 ; i < features.length ; i++)
                        if (features[i].val >= 0)  {
                                int x = (int) (features[i].x + 0.5);
                                int y = (int) (features[i].y + 0.5);
                                for (int yy = y - 1 ; yy <= y + 1 ; yy++)
                                        for (int xx = x - 1 ; xx <= x + 1 ; xx++)  
                                                if (xx >= 0 && yy >= 0 && xx < img.width && yy < img.height)  {
                                                        redimg.pixels[yy][xx] = 1f;
                                                        grnimg.pixels[yy][xx] = 0f;
                                                        bluimg.pixels[yy][xx] = 0f;
                                                }
                        }

                return new MBFImage(redimg, grnimg, bluimg);
        }
        
        /*********************************************************************
         * KLTWriteFeatureListToPPM
         * @param img 
         * @return input image
         */
        public MBFImage drawFeatures(MBFImage img)
        {
                /* Allocate memory for component images */
                MBFImage out = img;

                /* Overlay features in red */
                for (int i = 0 ; i < features.length ; i++)
                        if (features[i].val >= 0)  {
                                int x = (int) (features[i].x + 0.5);
                                int y = (int) (features[i].y + 0.5);
                                for (int yy = y - 1 ; yy <= y + 1 ; yy++)
                                        for (int xx = x - 1 ; xx <= x + 1 ; xx++)  
                                                if (xx >= 0 && yy >= 0 && xx < img.getWidth()&& yy < img.getHeight())  {
                                                        out.bands.get(0).setPixel(xx, yy, 1.0f);
                                                }
                        }

                return out;
        }

        /*********************************************************************
         * KLTWriteFeatureList()
         * 
         * Writes features to file or to screen.
         *
         * INPUTS
         * @param fname name of file to write data; if NULL, then print to stderr
         * @param fmt   format for printing (e.g., "%5.1f" or "%3d");
         *        if NULL, and if fname is not NULL, then write to binary file.
         * @throws IOException 
         */
        public void writeFeatureList(File fname, String fmt) throws IOException
        {
                if (fmt != null) {  /* text file or stderr */ 
                        if (fname != null) {
                                PrintWriter bw = new PrintWriter(new FileOutputStream(fname)); 
                                bw.write(toString(fmt, true));
                                bw.close();
                        } else {
                                System.out.print(toString(fmt, false));
                        }
                } else {  /* binary file */
                        DataOutputStream dos = new DataOutputStream(new FileOutputStream(fname));
                        
                        dos.write(IOUtils.binheader_fl.getBytes("US-ASCII"));
                        dos.writeInt(features.length);
                        for (Feature f : features)  {
                                f.writeFeatureBin(dos);
                        }
                        
                        dos.close();
                }
        }


        /**
         * Convert to a string representation with the given format.
         * @param fmt
         * @param comments
         * @return the string representation.
         */
        public String toString(String fmt, boolean comments) {
                String [] setup = IOUtils.setupTxtFormat(fmt);
                String format = setup[0];
                String type = setup[1];

                String s = IOUtils.getHeader(format, IOUtils.StructureType.FEATURE_LIST, 0, features.length, comments);

                for (int i = 0 ; i < features.length; i++)  {
                        s += String.format("%7d | ", i);
                        s += features[i].toString(format, type);
                        s += String.format("\n");
                }

                return s;
        }

        @Override
        public String toString() {
                return toString("%3d", false);
        }

        @Override
        public Iterator<Feature> iterator() {
                Iterator<Feature> iterator = new Iterator<Feature>() {
                        private int index = 0;
                        
                        @Override
                        public boolean hasNext() {
                                int newindex = index;
                                while (newindex<features.length) {
                                        if (features[newindex].val>=0) 
                                                return true;
                                        newindex++;
                                }

                                return false;
                        }

                        @Override
                        public Feature next() {
                                int newindex = index;
                                while (newindex<features.length) {
                                        if (features[newindex].val>=0) 
                                                break;
                                        newindex++;
                                }
                                
                                Feature f = features[newindex];
                                
                                index++;
                                
                                return f;
                        }

                        @Override
                        public void remove() {
                                throw new UnsupportedOperationException("Remove not supported.");
                        }                       
                };
                
                return iterator;
        }
        
        /**
         *      Returns the bounding box of the features
         *  @return the bounding box of the features
         */
        public Rectangle getBounds()
        {
                float minX = Float.MAX_VALUE;
                float maxX = Float.MIN_VALUE;
                float minY = Float.MAX_VALUE;
                float maxY = Float.MIN_VALUE;
                
                for( Feature f : features )
                {
                        if( f.val >= 0 )
                        {
                                minX = Math.min( minX, f.x );
                                maxX = Math.max( maxX, f.x );
                                minY = Math.min( minY, f.y );
                                maxY = Math.max( maxY, f.y );
                        }
                }
                
                return new Rectangle( minX, minY, maxX-minX, maxY-minY );
        }
}