package classification;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.LineNumberReader;

import segmentation.Labels;
import segmentation.Regions;

public class Features {
	
	private int nb_vect;
    private int size_vect;
    static private int nb_of_desc;
    
    static private double[] mean;
    static private double[] std;

    static private double[] data;
    static private double[] dec;

    
    
    public static void read_raw_scale_param (String file_name)
    {
    	

    	
    	String line = "";
    	try{ 
    		FileInputStream f = new FileInputStream(file_name);
    		DataInputStream din = new DataInputStream(f);
    		
    		BufferedReader d = new BufferedReader(new InputStreamReader(f));

        	line = d.readLine();
    		
    	    String[] s = line.trim().split("\\s");
			if(!line.trim().isEmpty()) {
    		   nb_of_desc = Integer.parseInt(s[0]);
			}   
			else {
				System.err.println ("File is incompatible ");
				System.exit(1);
			}
    		System.out.println("Number of desc : " + nb_of_desc);
    		
    	    mean = new double [nb_of_desc];
            std  = new double [nb_of_desc];
    		
    		for (int i = 0; i < nb_of_desc; i++) {
    			mean[i] = din.readByte();
    			System.out.println(mean[i]);
    		}
    		for (int i = 0; i < nb_of_desc; i++) {
    			System.out.println(mean[i]);
    		}
    	}
    	catch(Exception e){
    		System.err.println ("File \"" + file_name + "\" can not be loaded. ");
    		e.printStackTrace();
    	}
    	
         /*   SCALE_PARAMS sp;
            int nb_of_desc;
            fgets(buffer, SIZE_BUFFER, f); //2 # kernel type
            if (sscanf(buffer, "%d", &nb_of_desc)!=1) return NULL;

            this.nb_of_desc = nb_of_desc;
     
   

            fread(sp->mean, sizeof(double), nb_of_desc, f);
            fread(sp->std, sizeof(double), nb_of_desc, f);
            return sp; */
    }
    
    
    
   /*
    
    public void prepare_data_pzm (Labels lab, Regions[] regions, int nb_of_desc, int nb_of_regions)
    {
    	int width  = lab.getWidth();
    	int height = lab.getHeight();

    	double[] rho_max = new double[nb_of_regions];

       	Z[][] pzm = new Z[Z.PZM_LAST_ORDER + 1][2 * Z.PZM_LAST_ORDER + 1];
   
    	EXAMPLES e = new_examples(nb_of_regions, nb_of_desc);

    	for(int y = 1; y < height - 1; y++) {
    		for(int x = 1; x < width - 1; x++) {
    			int region_index = lab.getValue(x + y * width);
    			if (region_index != 0) {
    				int xg = regions[region_index].getXg (); 
    				int yg = regions[region_index].getYg ();
    				
    				double d = ( (x - xg) * (x - xg) + (y - yg) * (y - yg) );
    				if ( d > rho_max[region_index] ) {
    					rho_max[region_index] = d;
    				}
    			}
    		}
    	}


    	for(int i = 1; i < nb_of_regions; i++) {
    		rho_max[i] = Math.sqrt(rho_max[i]);
    	}

    	
    	for(int i = 1; i < nb_of_regions; i++) {
    		for(int p = Z.PZM_FIRST_ORDER; p <= Z.PZM_LAST_ORDER; p++) {
    			Z z = new Z();
    			z.pseudo_zernike_moment_0 (p, lab, regions, rho_max[i], i);
    			pzm[p][Z.PZM_LAST_ORDER] = z;
    			for(int q = 1; q <= p; q++) {
    				Z2 z2 = new Z2();
    				z2.pseudo_zernike_moment(p, q, lab, regions, rho_max[i], i);
    				pzm[p][-q + Z.PZM_LAST_ORDER] = z2.num1;
    				pzm[p][+q + Z.PZM_LAST_ORDER] = z2.num2;
    			}
    		}

    		int index = 1;
    		for(int p = Z.PZM_FIRST_ORDER; p <= Z.PZM_LAST_ORDER; p++)
    			for(int q = -p; q <= p; q++) {
    				if (scale_pzm->std[index]!=0) {
    					e->data[j++]=(module(pzm[p][q+PZM_LAST_ORDER])-scale_pzm->mean[index])/scale_pzm->std[index];

    				}
    				index++;
    			}
    	}
    	return e;
    } */

}
