/**
    * FaceTracker Licence
    * -------------------
    * (Academic, non-commercial, not-for-profit licence)
    *
    * Copyright (c) 2010 Jason Mora Saragih
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   *     * The software is provided under the terms of this licence stricly for
   *       academic, non-commercial, not-for-profit purposes.
   *     * Redistributions of source code must retain the above copyright notice,
   *       this list of conditions (licence) and the following disclaimer.
   *     * Redistributions in binary form must reproduce the above copyright
   *       notice, this list of conditions (licence) and the following disclaimer
   *       in the documentation and/or other materials provided with the
   *       distribution.
   *     * The name of the author may not be used to endorse or promote products
   *       derived from this software without specific prior written permission.
   *     * As this software depends on other libraries, the user must adhere to and
   *       keep in place any licencing terms of those libraries.
   *     * Any publications arising from the use of this software, including but
   *       not limited to academic journal and conference publications, technical
   *       reports and manuals, must cite the following work:
   *
   *       J. M. Saragih, S. Lucey, and J. F. Cohn. Face Alignment through Subspace
   *       Constrained Mean-Shifts. International Journal of Computer Vision
   *       (ICCV), September, 2009.
   *
   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
   * EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.jsaragih;
  
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.util.List;
  import java.util.Scanner;
  
  import javax.xml.stream.XMLStreamException;
  
  import org.openimaj.image.FImage;
  import org.openimaj.image.objectdetection.filtering.OpenCVGrouping;
  import org.openimaj.image.objectdetection.haar.Detector;
  import org.openimaj.image.objectdetection.haar.OCVHaarLoader;
  import org.openimaj.image.objectdetection.haar.StageTreeClassifier;
  import org.openimaj.image.processing.algorithm.EqualisationProcessor;
  import org.openimaj.image.processing.resize.ResizeProcessor;
  import org.openimaj.math.geometry.shape.Rectangle;
  import org.openimaj.util.pair.ObjectIntPair;
  
  /**
   * Face detector.
   * <p>
   * Note: the face detector in any input file is ignored and is replaced by the
   * haarcascade_frontalface_alt2 cascade.
   *
   * @author Jason Mora Saragih
   * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
   */
  public class FDet {
  	static {
  		Tracker.init();
  	}
  
  	private static final int CV_HAAR_FEATURE_MAX = 3;
  
  	int _min_neighbours;
  	int _min_size;
  	float _img_scale;
  	float _scale_factor;
  	StageTreeClassifier _cascade;
  
  	FImage small_img_;
  
  	private Detector detector;
  
  	private OpenCVGrouping grouping;
  
  	FDet(final String fname, final float img_scale, final float scale_factor,
  			final int min_neighbours, final int min_size) throws IOException,
  			XMLStreamException
  	{
  		final FileInputStream fis = new FileInputStream(fname);
 		this._cascade = OCVHaarLoader.read(fis);
 		fis.close();
 
 		this._img_scale = img_scale;
 		this._scale_factor = scale_factor;
 		this._min_neighbours = min_neighbours;
 		this._min_size = min_size;
 
 		this.setupDetector();
 	}
 
 	FDet() {
 		try {
 			this._cascade = OCVHaarLoader.read(OCVHaarLoader.class.getResourceAsStream("haarcascade_frontalface_alt2.xml"));
 		} catch (final Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/**
 	 * Detect faces in an image
 	 *
 	 * @param im
 	 *            the image
 	 * @return the detected faces
 	 */
 	public List<Rectangle> detect(final FImage im) {
 		final int w = Math.round(im.width / this._img_scale);
 		final int h = Math.round(im.height / this._img_scale);
 
 		this.small_img_ = ResizeProcessor.resample(im, w, h).processInplace(
 				new EqualisationProcessor());
 
 		List<Rectangle> rects = this.detector.detect(this.small_img_);
 		rects = ObjectIntPair.getFirst(this.grouping.apply(rects));
 		for (final Rectangle r : rects) {
 			r.scale(this._img_scale);
 		}
 
 		return rects;
 	}
 
 	private void setupDetector() {
 		this.detector = new Detector(this._cascade, this._scale_factor);
 		this.grouping = new OpenCVGrouping(this._min_neighbours);
 		this.detector.setMinimumDetectionSize(this._min_size);
 	}
 
 	static FDet load(final String fname) throws FileNotFoundException {
 		BufferedReader br = null;
 		try {
 			br = new BufferedReader(new FileReader(fname));
 			final Scanner sc = new Scanner(br);
 			return FDet.read(sc, true);
 		} finally {
 			try {
 				br.close();
 			} catch (final IOException e) {
 			}
 		}
 	}
 
 	void save(final String fname) throws IOException {
 		BufferedWriter bw = null;
 		try {
 			bw = new BufferedWriter(new FileWriter(fname));
 
 			this.write(bw);
 		} finally {
 			try {
 				if (bw != null)
 					bw.close();
 			} catch (final IOException e) {
 			}
 		}
 	}
 
 	void write(final BufferedWriter s) {
 		// _cascade.
 		// int i,j,k,l;
 		// s.write(
 		// IO.Types.FDET.ordinal() + " "
 		// + _min_neighbours + " "
 		// + _min_size + " "
 		// + _img_scale + " "
 		// + _scale_factor + " "
 		// + _cascade.count + " "
 		// + _cascade.orig_window_size.width + " "
 		// + _cascade.orig_window_size.height + " "
 		// );
 		//
 		// for(i = 0; i < _cascade->count; i++){
 		// s + _cascade->stage_classifier[i].parent + " "
 		// + _cascade->stage_classifier[i].next + " "
 		// + _cascade->stage_classifier[i].child + " "
 		// + _cascade->stage_classifier[i].threshold + " "
 		// + _cascade->stage_classifier[i].count + " ";
 		// for(j = 0; j < _cascade->stage_classifier[i].count; j++){
 		// CvHaarClassifier* classifier =
 		// &_cascade->stage_classifier[i].classifier[j];
 		// s + classifier->count + " ";
 		// for(k = 0; k < classifier->count; k++){
 		// s + classifier->threshold[k] + " "
 		// + classifier->left[k] + " "
 		// + classifier->right[k] + " "
 		// + classifier->alpha[k] + " "
 		// + classifier->haar_feature[k].tilted + " ";
 		// for(l = 0; l < CV_HAAR_FEATURE_MAX; l++){
 		// s + classifier->haar_feature[k].rect[l].weight + " "
 		// + classifier->haar_feature[k].rect[l].r.x + " "
 		// + classifier->haar_feature[k].rect[l].r.y + " "
 		// + classifier->haar_feature[k].rect[l].r.width + " "
 		// + classifier->haar_feature[k].rect[l].r.height + " ";
 		// }
 		// }
 		// s + classifier->alpha[classifier->count] + " ";
 		// }
 		// }
 	}
 
 	/**
 	 * Read the Face detector.
 	 *
 	 * @param s
 	 * @param readType
 	 * @return the face detector
 	 */
 	public static FDet read(final Scanner s, final boolean readType) {
 		// FIXME: maybe this should actually read the cascade!!
 		if (readType) {
 			final int type = s.nextInt();
 			assert (type == IO.Types.FDET.ordinal());
 		}
 
 		final FDet fdet = new FDet();
 		fdet._min_neighbours = s.nextInt();
 		fdet._min_size = s.nextInt();
 		fdet._img_scale = s.nextFloat();
 		fdet._scale_factor = s.nextFloat();
 		final int n = s.nextInt();
 
 		// m = sizeof(CvHaarClassifierCascade)+n*sizeof(CvHaarStageClassifier);
 		// _cascade = (CvHaarClassifierCascade*)cvAlloc(m);
 		// memset(_cascade,0,m);
 		// _cascade->stage_classifier = (CvHaarStageClassifier*)(_cascade + 1);
 		// _cascade->flags = CV_HAAR_MAGIC_VAL;
 		// _cascade->count = n;
 
 		// s >> _cascade->orig_window_size.width >>
 		// _cascade->orig_window_size.height;
 		s.next();
 		s.next();
 
 		for (int i = 0; i < n; i++) {
 			// s >> _cascade->stage_classifier[i].parent
 			s.next();
 			// >> _cascade->stage_classifier[i].next
 			s.next();
 			// >> _cascade->stage_classifier[i].child
 			s.next();
 			// >> _cascade->stage_classifier[i].threshold
 			s.next();
 			// >> _cascade->stage_classifier[i].count;
 			final int count = s.nextInt();
 
 			// _cascade->stage_classifier[i].classifier =
 			// (CvHaarClassifier*)cvAlloc(_cascade->stage_classifier[i].count*
 			// sizeof(CvHaarClassifier));
 			for (int j = 0; j < count; j++) {
 				// CvHaarClassifier* classifier =
 				// &_cascade->stage_classifier[i].classifier[j];
 				// s >> classifier->count;
 				final int ccount = s.nextInt();
 
 				// classifier->haar_feature = (CvHaarFeature*)
 				// cvAlloc(classifier->count*(sizeof(CvHaarFeature) +
 				// sizeof(float) + sizeof(int) + sizeof(int)) +
 				// (classifier->count+1)*sizeof(float));
 				// classifier->threshold =
 				// (float*)(classifier->haar_feature+classifier->count);
 				// classifier->left = (int*)(classifier->threshold +
 				// classifier->count);
 				// classifier->right = (int*)(classifier->left +
 				// classifier->count);
 				// classifier->alpha = (float*)(classifier->right +
 				// classifier->count);
 				for (int k = 0; k < ccount; k++) {
 					// s >> classifier->threshold[k]
 					s.next();
 					// >> classifier->left[k]
 					s.next();
 					// >> classifier->right[k]
 					s.next();
 					// >> classifier->alpha[k]
 					s.next();
 					// >> classifier->haar_feature[k].tilted;
 					s.next();
 					for (int l = 0; l < FDet.CV_HAAR_FEATURE_MAX; l++) {
 						// s >> classifier->haar_feature[k].rect[l].weight
 						s.next();
 						// >> classifier->haar_feature[k].rect[l].r.x
 						s.next();
 						// >> classifier->haar_feature[k].rect[l].r.y
 						s.next();
 						// >> classifier->haar_feature[k].rect[l].r.width
 						s.next();
 						// >> classifier->haar_feature[k].rect[l].r.height;
 						s.next();
 					}
 				}
 				// s >> classifier->alpha[classifier->count];
 				s.next();
 			}
 		}
 
 		fdet.setupDetector();
 
 		return fdet;
 	}
 
 	/**
 	 *	@return the _min_size
 	 */
 	public int get_min_size()
 	{
 		return this._min_size;
 	}
 
 	/**
 	 *	@param _min_size the _min_size to set
 	 */
 	public void set_min_size( final int _min_size )
 	{
 		this._min_size = _min_size;
 		this.setupDetector();
 	}
 }