codebase / stimlib

#ifndef STIM_ENVI_H
#define STIM_ENVI_H

#include "../envi/envi_header.h"
#include "../envi/bsq.h"
#include "../envi/bip.h"
#include "../envi/bil.h"
#include <iostream>
#include "../CImg/CImg.h"

namespace stim{

//container class for an ENVI binary file reader
class envi{	

	void* file;		//void pointer to the relevant file reader (bip, bsq, or bil - with appropriate data type)

public:

	envi_header header;

	bool allocate(){

		file = NULL;	//set file to a NULL pointer

		if(header.interleave == envi_header::BSQ){
			if(header.data_type ==envi_header::float32)
				return(file = new bsq<float>());
			else if(header.data_type == envi_header::float64)
				return(file = new bsq<double>());
		}
		else if(header.interleave == envi_header::BIP){
			if(header.data_type ==envi_header::float32)
				return(file = new bip<float>());
			else if(header.data_type == envi_header::float64)
				return(file = new bip<double>());
		}
		else if(header.interleave == envi_header::BIL){
			if(header.data_type ==envi_header::float32)
				return(file = new bil<float>());
			else if(header.data_type == envi_header::float64)
				return(file = new bil<double>());
		}

		exit(1);	//if the function hasn't already returned, we don't handle this state

	}

	bool open(std::string filename, std::string headername){

		//allocate memory
		allocate();

		//load the header
		header.load(headername);

		//load the file
		if(header.interleave == envi_header::BSQ) {		//if the infile is bsq file
			if(header.data_type == envi_header::float32) {
				return ((bsq<float>*)file)->open(filename, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else if(header.data_type == envi_header::float64) {
				return ((bsq<double>*)file)->open(filename, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else
				return false;
		}

		else if(header.interleave == envi_header::BIL) {		//if the infile is bil file
			if(header.data_type == envi_header::float32) {
				return ((bil<float>*)file)->open(filename, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else if(header.data_type == envi_header::float64) {
				return ((bil<double>*)file)->open(filename, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else
				return false;
		}
				
		else if(header.interleave == envi_header::BIP) {		//if the infile is bip file
			if(header.data_type == envi_header::float32) {
				return ((bip<float>*)file)->open(filename, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else if(header.data_type == envi_header::float64) {
				return ((bip<double>*)file)->open(filename, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else
				return false;		
		}
		
		else{
		std::cout<<"ERROR: unidentified type file       "<<headername<<std::endl;
		exit(1);
		}

	}

	//perform normalization
	bool normalize(std::string outfile, double band){
	
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->normalize(outfile, band);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->normalize(outfile,band);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->normalize(outfile, band);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->normalize(outfile,band);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->normalize(outfile, band);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->normalize(outfile,band);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}

	//perform baseline correction
	bool baseline(std::string outfile, std::vector<double> w){

		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->baseline(outfile, w);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->baseline(outfile,w);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->baseline(outfile, w);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->baseline(outfile, w);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file 
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->baseline(outfile, w);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->baseline(outfile, w);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
	}

	//perform conversion
	bool convert(std::string outfile, stim::envi_header::interleaveType interleave){

		if(header.interleave == envi_header::BSQ){			//if the infile is bsq file

			if(header.data_type ==envi_header::float32){		//if the data type of infile is float
				if(interleave == envi_header::BSQ){
					std::cout<<"ERROR:  is already BSQ file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)			//if the target file is bil file
					return ((bsq<float>*)file)->bil(outfile);
				else if(interleave == envi_header::BIP)			//if the target file is bip file
					return ((bsq<float>*)file)->bip(outfile);
			}

			else if(header.data_type == envi_header::float64){		//if the data type is float
				if(interleave == envi_header::BSQ){
					std::cout<<"ERROR:  is already BSQ file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)
					return ((bsq<double>*)file)->bil(outfile);
				else if(interleave == envi_header::BIP)
					return ((bsq<double>*)file)->bip(outfile);
			}
			
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);				
			}
		}

		else if(header.interleave == envi_header::BIL){

			if(header.data_type ==envi_header::float32){		//if the data type of infile is float
				if(interleave == envi_header::BIL){
					std::cout<<"ERROR:  is already BIL file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BSQ)			//if the target file is bsq file
					return ((bil<float>*)file)->bsq(outfile);
				else if(interleave == envi_header::BIP)			//if the target file is bip file
					return ((bil<float>*)file)->bip(outfile);
			}

			else if(header.data_type == envi_header::float64){		//if the data type is float
				if(interleave == envi_header::BIL){
					std::cout<<"ERROR:  is already BIL file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BSQ)
					return ((bil<double>*)file)->bsq(outfile);
				else if(interleave == envi_header::BIP)
					return ((bil<double>*)file)->bip(outfile);
			}
			
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);				
			}
		}

		else if(header.interleave == envi_header::BIP){
		
			if(header.data_type ==envi_header::float32){		//if the data type of infile is float
				if(interleave == envi_header::BIP){
					std::cout<<"ERROR:  is already BIP file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)			//if the target file is bil file
					return ((bip<float>*)file)->bil(outfile);
				else if(interleave == envi_header::BSQ)			//if the target file is bsq file
					return ((bip<float>*)file)->bsq(outfile);
			}

			else if(header.data_type == envi_header::float64){		//if the data type is float
				if(interleave == envi_header::BIP){
					std::cout<<"ERROR:  is already BIP file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)			//if the target file is bil file
					return ((bip<double>*)file)->bil(outfile);
				else if(interleave == envi_header::BSQ)			//if the target file is bsq file
					return ((bip<double>*)file)->bsq(outfile);
			}
			
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);				
			}
		}
		
		else{
			std::cout<<"ERROR: unidentified interleave type"<<std::endl;
			exit(1);
		}
		return false;
	
	}

	//create a mask based on a band and threshold, save it to p (if p is not NULL)
	bool build_mask(double mask_band, double threshold, unsigned char* p = NULL)	{

		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->build_mask(mask_band, threshold, p);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->build_mask(mask_band, threshold, p);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->build_mask(mask_band, threshold, p);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->build_mask(mask_band, threshold, p);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->build_mask(mask_band, threshold, p);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->build_mask(mask_band, threshold, p);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		return false;
	}

	//apply mask
	bool apply_mask(std::string outfile, unsigned char* p)	
	{

		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->apply_mask(outfile, p);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->apply_mask(outfile, p);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->apply_mask(outfile, p);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->apply_mask(outfile, p);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->apply_mask(outfile, p);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->apply_mask(outfile, p);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}

	//peak height to peak height ratio
	bool ph_to_ph(double lb1, double rb1, double pos1, double lb2, double rb2, double pos2, void * result){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->ph_to_ph(lb1, rb1, pos1, lb2, rb2, pos2, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->ph_to_ph(lb1, rb1, pos1, lb2, rb2, pos2, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->ph_to_ph(lb1, rb1, pos1, lb2, rb2, pos2, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->ph_to_ph(lb1, rb1, pos1, lb2, rb2, pos2, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->ph_to_ph(lb1, rb1, pos1, lb2, rb2, pos2, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->ph_to_ph(lb1, rb1, pos1, lb2, rb2, pos2, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}

	//peak area to peak height ratio
	bool pa_to_ph(double lb1, double rb1, double lab1, double rab1, double lb2, double rb2, double pos, void * result){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->pa_to_ph(lb1, rb1, lab1, rab1, lb2, rb2, pos, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->pa_to_ph(lb1, rb1, lab1, rab1, lb2, rb2, pos, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->pa_to_ph(lb1, rb1, lab1, rab1, lb2, rb2, pos, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->pa_to_ph(lb1, rb1, lab1, rab1, lb2, rb2, pos, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->pa_to_ph(lb1, rb1, lab1, rab1, lb2, rb2, pos, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->pa_to_ph(lb1, rb1, lab1, rab1, lb2, rb2, pos, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}

	//peak area to peak area ratio
	bool pa_to_pa(double lb1, double rb1, double lab1, double rab1,
					double lb2, double rb2, double lab2, double rab2, void* result){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->pa_to_pa(lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->pa_to_pa(lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->pa_to_pa(lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->pa_to_pa(lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->pa_to_pa(lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->pa_to_pa(lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}

		//center of gravity
	bool cpoint(double lb1, double rb1, double lab1, double rab1, void* result){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->cpoint(lb1, rb1, lab1, rab1, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->cpoint(lb1, rb1, lab1, rab1, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->cpoint(lb1, rb1, lab1, rab1, (float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->cpoint(lb1, rb1, lab1, rab1, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->cpoint(lb1, rb1, lab1, rab1,(float*)result);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->cpoint(lb1, rb1, lab1, rab1, (double*)result);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}

		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}

	bool close(){
		if(header.interleave == envi_header::BSQ){
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->close();
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->close();
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}

		else if(header.interleave == envi_header::BIL){
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->close();
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->close();
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}

		else if(header.interleave == envi_header::BIP){
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->close();
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->close();
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		return false;
	}
	//get one pixel from binary file
	bool pixel(void * p, unsigned n){
		if(header.interleave == envi_header::BSQ){
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->pixel((float*)p, n);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->pixel((double*)p, n);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		else if(header.interleave == envi_header::BIL){
			if(header.data_type ==envi_header::float32)
				return ((bil<float>*)file)->pixel((float*)p, n);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->pixel((double*)p, n);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		else if(header.interleave == envi_header::BIP){
			if(header.data_type ==envi_header::float32)
				return ((bip<float>*)file)->pixel((float*)p, n);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->pixel((double*)p, n);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		return false;
	}

	bool save_header(std::string filename){

		//save the header file here
		header.save(filename);

		return true;
	}

	bool band(void* ptr, double wavelength){

		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->band((float*)ptr, wavelength);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->band((double*)ptr, wavelength);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIL){
			if (header.data_type == envi_header::float32)
				return ((bil<float>*)file)->band((float*)ptr, wavelength);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->band((double*)ptr, wavelength);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIP){
			if (header.data_type == envi_header::float32)
				return ((bip<float>*)file)->band((float*)ptr, wavelength);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->band((double*)ptr, wavelength);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}

	bool band_index(void* ptr, unsigned int b){
		if (header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->band_index((float*)ptr, b);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->band_index((double*)ptr, b);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIL){
			if (header.data_type == envi_header::float32)
				return ((bil<float>*)file)->band_index((float*)ptr, b);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->band_index((double*)ptr, b);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIP){
			if (header.data_type == envi_header::float32)
				return ((bip<float>*)file)->band_index((float*)ptr, b);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->band_index((double*)ptr, b);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
	
	//load mask from maskfile and save it into memory
	bool load_mask(unsigned char * mask, std::string maskname){
		//open the mask file
		cimg_library::CImg<unsigned char> mask_image(maskname.c_str());
		//save mask file into memory
		memcpy(mask, mask_image.data(), mask_image.size());
		mask_image.clear();
		return true;
	}

	//p:start positon; N: number of pixels saved in X;
	bool feature_matrix(void * X,  unsigned char * mask, unsigned start, unsigned N)
	{
		//save pixels in X as floating numbers: float * p
		float * p = (float*)malloc(header.bands * sizeof(float));		//save pixel information
		unsigned pixels = header.samples * header.lines;		//calculate pixel numbers in a band
		unsigned count = 0;		//for counting use
		unsigned j = 0;		//memory the pointer location in X

		//create two indices into the mask (mask index and pixel index)
		unsigned mi = 0;	//valid pixel index
		unsigned pi = 0;	//actual pixel in the mask

		//find the actual pixel index for the mask index "start"
		while(mi < start){
			if(mask[pi])
				mi++;

			pi++;
		}

		for(unsigned i = pi; i < pixels; i++){
			if(mask[i] != 0){
				pixel(p, i);
				//copy p to X
				for(unsigned k = 0; k < header.bands; k++){
					((float *)X)[j] = p[k];
					j++;
				}
				count++;
				if(count == N)
					break;
			}
			else
				continue;
		}
		if(count < N){
			std::cout << "number of valid pixels in the mask : " << count <<"is less than N: "<< N;
			exit(1);
		}
		free(p);
		return true;
	}

	//calculate band average
	bool avg_band(void * p, unsigned char* mask){
		if (header.interleave == envi_header::BSQ){
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->avg_band((float*)p, mask);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->avg_band((double*)p,  mask);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIL){
			if (header.data_type == envi_header::float32)
				return ((bil<float>*)file)->avg_band((float*)p,  mask);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->avg_band((double*)p,  mask);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIP){
			if (header.data_type == envi_header::float32)
				return ((bip<float>*)file)->avg_band((float*)p, mask);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->avg_band((double*)p, mask);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}

	//calculate correlation coefficient matrix with mask
	bool co_matrix(void* co, void* avg, unsigned char* mask){
		if (header.interleave == envi_header::BSQ){
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->co_matrix((float*)co, (float*)avg, mask);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->co_matrix((double*)co, (double*)avg, mask);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIL){
			if (header.data_type == envi_header::float32)
				return ((bil<float>*)file)->co_matrix((float*)co, (float*)avg, mask);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->co_matrix((double*)co, (double*)avg, mask);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIP){
			if (header.data_type == envi_header::float32)
				return ((bip<float>*)file)->co_matrix((float*)co, (float*)avg, mask);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->co_matrix((double*)co, (double*)avg, mask);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}


	//crop specified area the of the original file
	bool crop(std::string outfile,unsigned x0, unsigned y0, unsigned x1, unsigned y1){

		if (header.interleave == envi_header::BSQ){
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->crop(outfile, x0, y0, x1, y1);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->crop(outfile, x0, y0, x1, y1);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIL){
			if (header.data_type == envi_header::float32)
				return ((bil<float>*)file)->crop(outfile, x0, y0, x1, y1);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->crop(outfile, x0, y0, x1, y1);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		else if (header.interleave == envi_header::BIP){
			if (header.data_type == envi_header::float32)
				return ((bip<float>*)file)->crop(outfile, x0, y0, x1, y1);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->crop(outfile, x0, y0, x1, y1);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}

};

}	//end namespace rts

#endif