import java.io.FileNotFoundException;
import java.util.ArrayList;

/**
 * Course material for the "Konenako 2010" course.
 */

/** Computes a sum of all pixels in a grayscale image. */
class BlackAreaExtractor extends AbstractDumbGrayscaleFeatureExtractor{
    public BlackAreaExtractor(int height, int width) {
        super(height,width);
    }

    @Override
    double[] extractFromGrayscale(double[][] image) {
        double[] sumFeature = new double[1];

        for(int row=0;row<width;row++){
            for(int col=0;col<width;col++){
                sumFeature[0] += image[row][col];
            }
        }
        return sumFeature;
    }
}


/** Computes the number of times the intensity changes while scanning each row.*/
class NumberOfColorChangeExtractor extends AbstractDumbGrayscaleFeatureExtractor{
    public NumberOfColorChangeExtractor(int height, int width) {
        super(height,width);
    }

    @Override
    double[] extractFromGrayscale(double[][] image) {
        double[] feature = new double[height];
        double[][] bw = Tools.threshold(image,128);

        for(int row=0;row<width;row++){
            double previntens = 0;
            for(int col=0;col<width;col++){
                if (bw[row][col] != previntens){
                    previntens = bw[row][col];
                    feature[row] += 1;
                }
            }
        }
        return feature;
    }
}


/** Makes a 4x4 pixel approximation (hard-fitted to the 28x28 mnist .. just
 * one more example code..) 
 */
class CoarseResampleExtractor extends AbstractDumbGrayscaleFeatureExtractor{
    public CoarseResampleExtractor(int height, int width) {
        super(height,width);
    }

    @Override
    double[] extractFromGrayscale(double[][] image) {
        double[] feature = new double[4*4];

        for(int row=0;row<width;row++){
            for(int col=0;col<width;col++){
                feature[col/7*4+row/7] += image[row][col];
            }
        }
        return feature;
    }
}



/**
 * @author nieminen
 *
 */
public class DemoFeatureExtraction {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException {
        DataSet mnistRaw = DataSet.createFromTextFile("mnist_reduced.dat",1);

        ArrayList<FeatureExtractor> extractors = new ArrayList<FeatureExtractor>();
        
        /* Here you add instances of your feature extractors: */        
        
        extractors.add(new BlackAreaExtractor(28,28));
//        extractors.add(new NumberOfColorChangeExtractor(28,28));
//        extractors.add(new CoarseResampleExtractor(28,28));

        /* And here they are applied to each of the MNIST digit images: */
        DataSet mnist = mnistRaw.createNewByFeatureExtractors(extractors);

        // In our reduced set, we took 750/250 first samples from the real MNIST
        mnist.splitToTrainAndTest(.75);

        mnist.normalize(-1.0,1.0);

        int[] layerSizes = new int[]{mnist.getVecSize(),10,mnist.getNumOfClasses()};
        SimpleMLP mlp = new SimpleMLP(layerSizes);

        for(int i=0;i<100;i++){
            mlp.trainGD(mnist.trainInputs(), mnist.trainTargets(), 0.1, 200);

            System.out.println("Training set:");
            int[] outclasses = mlp.classifyMatrix(mnist.trainInputs());
            DataSet.printConfusion(outclasses,mnist.trainTargets());

            System.out.println("Test set:");
            outclasses = mlp.classifyMatrix(mnist.testInputs());
            DataSet.printConfusion(outclasses,mnist.testTargets());
        }
    }
}