/* Last edited on 2013-01-01 17:50:09 by stolfilocal */
/* Applies adaptive hresholding to an image given in the command line. */

import java.lang.Math;
import java.util.Arrays;
import java.util.Random;

import java.io.File;
import java.io.IOException;

import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;

import minetto.utils.FloatImage;
import minetto.utils.FloatImageSegment;

public class DoThresholdImage {

    public static void main(String[] args) throws IOException {
        String in_dir = args[0];
        String out_dir = args[1];
        String image_name = args[2];
        
        String fname = in_dir + "/" + image_name + ".png";
        BufferedImage buf = null;
        try {
            buf = ImageIO.read(new File(fname));
        } catch (IOException e) {
            System.err.println("Failure while reading image \"" + fname + "\"");
        }
        do_threshold_image(buf, out_dir + "/" + image_name);
    }
    
    public static void do_threshold_image(BufferedImage buf, String image_name) {
        FloatImage.set_debug_prefix(null);
        /* Pyramid parameters: */
        int max_levels = 3;
        int blur_step = 3;
        int dn_order = 5;
        int up_order = 5;
        double vcut_abs = -0.05;  /* Cut level for binarization. */
       
        /* Convert to grayscale: */
        FloatImage gry = FloatImage.from_BufferedImage(buf, 1, (float)0.0, (float)1.0, 1.000);
        
        /* Build a pyramid {gry_pyr} of luminance images: */
        FloatImage[] gry_pyr = FloatImage.build_avg_pyramid(gry, max_levels + blur_step, dn_order);
        
        /* Build a pyramid {var_pyr} of variance images for {gry_pyr}: */
        float vqt = (float)((1.0/12.0)/(256*256)); /* Quantization noise variance for 256 levels. */
        float[] noise_var = new float[gry.nc];
        Arrays.fill(noise_var, vqt);
        FloatImage[] var_pyr = FloatImage.build_var_pyramid(gry_pyr, noise_var, dn_order);
        
        /* Build blurred versions of {gry_pyr,var_pyr}: */
        FloatImage[] gry_blr_pyr = FloatImage.build_blurred_pyramid(gry_pyr, blur_step, up_order, "avg");
        FloatImage[] var_blr_pyr = FloatImage.build_blurred_pyramid(var_pyr, blur_step, up_order, "var");
        
        /* Build a contrast and brightness normalized pyramid {nor_pyr}: */
        FloatImage[] nor_pyr = FloatImage.build_normalized_pyramid(gry_pyr, gry_blr_pyr, var_blr_pyr);
        
        for (int level = 0; level < nor_pyr.length; level++) {
            /* Magnify the level to scale 0: */
            FloatImage nor = nor_pyr[level];
            for (int k = level; k > 0; k--) {
                int nx1 = nor_pyr[k-1].nx;
                int ny1 = nor_pyr[k-1].ny;
                nor = FloatImage.upsample(nor, nx1, ny1, up_order);
            }
            for (int sense = 0; sense < 2; sense++) {
                /* Threshold the level: */
                FloatImage thr = nor.copy();
                float vcut = (float)(vcut_abs * (1 - 2*sense));
                float vmin = (float)(1 - sense);
                float vmax = (float)sense;
                float blur = 0.1f;
                thr.threshold(0,3, vcut, vmin,vmax, blur);
                String outname = image_name + "_v" + String.format("%02d",level) + "_th" + sense;
                thr.write_as_png(outname, 0.0f, 1.0f, 2.5);
            }
        }
    }
}