stim/envi/envi.h

#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 "../image/image.h"
namespace stim{
/** This class implements reading of ENVI hyperspectral files. These files can be stored in multiple orientations
	(including BSQ, BIP, and BIL) in order to optimize streaming speed depending on applications. Basic ENVI
	files are stored on disk as a large binary file with a corresponding header. Code for reading and processing
	ENVI header files is in the envi_header class.
*/
class envi{
	void* file;		//void pointer to the relevant file reader (bip, bsq, or bil - with appropriate data type)
	std::string fname;					//file name used for repeated opening and closing
public:
	envi_header header;
	/// Returns the size of the data type in bytes
	unsigned int type_size(){
		if(header.data_type == envi_header::float32) return 4;
		if(header.data_type == envi_header::float64) return 8;
		exit(1);
	}
	/// Returns the progress of the current processing operation as a percentage
	void reset_progress(){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				((bsq<float>*)file)->reset_progress();
			else if(header.data_type == envi_header::float64)
				((bsq<double>*)file)->reset_progress();
			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)
				((bil<float>*)file)->reset_progress();
			else if(header.data_type == envi_header::float64)
				((bil<double>*)file)->reset_progress();
			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)
				((bip<float>*)file)->reset_progress();
			else if(header.data_type == envi_header::float64)
				((bip<double>*)file)->reset_progress();
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
	}
	/// Returns the progress of the current processing operation as a percentage
	double progress(){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->get_progress();
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->get_progress();
			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)->get_progress();
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->get_progress();
			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)->get_progress();
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->get_progress();
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
		}
		return 0;
	}
	/// Allocate memory for a new ENVI file based on the current interleave format (BIP, BIL, BSQ) and data type.
	void allocate(){
		file = NULL;	//set file to a NULL pointer
		if(header.interleave == envi_header::BSQ){
			if(header.data_type ==envi_header::float32)
				file = new bsq<float>();
			else if(header.data_type == envi_header::float64)
				file = new bsq<double>();
		}
		else if(header.interleave == envi_header::BIP){
			if(header.data_type ==envi_header::float32)
				file = new bip<float>();
			else if(header.data_type == envi_header::float64)
				file = new bip<double>();
		}
		else if(header.interleave == envi_header::BIL){
			if(header.data_type ==envi_header::float32)
				file = new bil<float>();
			else if(header.data_type == envi_header::float64)
				file = new bil<double>();
		}
	}
	/// Open a previously opened ENVI file
	bool open(){
		//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(fname, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else if(header.data_type == envi_header::float64) {
				return ((bsq<double>*)file)->open(fname, 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(fname, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else if(header.data_type == envi_header::float64) {
				return ((bil<double>*)file)->open(fname, 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(fname, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else if(header.data_type == envi_header::float64) {
				return ((bip<double>*)file)->open(fname, header.samples, header.lines, header.bands, header.header_offset, header.wavelength);
			}
			else
				return false;
		}
		return true;
	}
	/// Open an existing ENVI file given the filename and a header structure
	/// @param filename is the name of the ENVI binary file
	/// @param header is an ENVI header structure
	bool open(std::string filename, stim::envi_header h){
		
		header = h;							//store the header
		fname = filename;					//save the filename
		allocate();
		return open();						//open the ENVI file;
		
	}
	/// Open an existing ENVI file given the file and header names.
	/// @param filename is the name of the ENVI binary file
	/// @param headername is the name of the ENVI header file
	bool open(std::string filename, std::string headername){
		//allocate memory
		//allocate();
		stim::envi_header h;
		h.load(headername);
		//load the header
		//header.load(headername);
		return open(filename, h);
	}
	/// Normalize a hyperspectral ENVI file given a band number and threshold.
	/// @param outfile is the name of the normalized file to be output
	/// @param band is the band label to be output
	/// @param threshold is a threshold value specified such that normalization will only be done to values in the band > threshold (preventing division by small numbers)
	bool normalize(std::string outfile, double band, unsigned char* mask = NULL, bool PROGRESS = false){
		header.save(outfile + ".hdr");
		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, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->normalize(outfile,band, mask, PROGRESS);
			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, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->normalize(outfile,band, mask, PROGRESS);
			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, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->normalize(outfile,band, mask, PROGRESS);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}
	/// Performs piecewise linear baseline correction of a hyperspectral file/
	/// @param outfile is the file name for the baseline corrected output
	/// @param w is a list of band labels to serve as baseline points (zero values)
	bool baseline(std::string outfile, std::vector<double> w, unsigned char* mask = NULL, bool PROGRESS = false){
		header.save(outfile + ".hdr");
		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, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->baseline(outfile,w, mask, PROGRESS);
			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, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->baseline(outfile, w, mask, PROGRESS);
			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, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->baseline(outfile, w, mask, PROGRESS);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
	}
	void project(std::string outfile, double* center, double* basis, unsigned long long M, unsigned char* mask, bool PROGRESS = false){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			std::cout<<"ERROR: BSQ projection not supported"<<std::endl;
			exit(1);
		}
		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			std::cout<<"ERROR: BIL projection not supported"<<std::endl;
			exit(1);
		}
		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				((bip<float>*)file)->project(outfile, center, basis, M, mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				((bip<double>*)file)->project(outfile, center, basis, M, mask, PROGRESS);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		stim::envi_header out_hdr = header;							
		out_hdr.bands = M;											//set the number of bands in the output header
		out_hdr.wavelength.clear();
		out_hdr.band_names.clear();
		out_hdr.save(outfile + ".hdr");								//save the output header
	}
	void inverse(std::string outfile, double* center, double* basis, unsigned long long B, unsigned long long C = 0, bool PROGRESS = false){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			std::cout<<"ERROR: BSQ projection not supported"<<std::endl;
			exit(1);
		}
		else if(header.interleave == envi_header::BIL){		//if the infile is bil file
			std::cout<<"ERROR: BIL projection not supported"<<std::endl;
			exit(1);
		}
		else if(header.interleave == envi_header::BIP){		//if the infile is bip file
			if(header.data_type ==envi_header::float32)
				((bip<float>*)file)->inverse(outfile, center, basis, B, C, PROGRESS);
			else if(header.data_type == envi_header::float64)
				((bip<double>*)file)->inverse(outfile, center, basis, B, C, PROGRESS);
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		stim::envi_header out_hdr = header;							
		out_hdr.bands = B;											//set the number of bands in the output header
		out_hdr.save(outfile + ".hdr");								//save the output header
	}
	/// Converts ENVI files between interleave types (BSQ, BIL, and BIP)
	/// @param outfile is the file name for the converted output
	/// @param interleave is the interleave format for the destination file
	bool convert(std::string outfile, stim::envi_header::interleaveType interleave, bool PROGRESS = false){
		
		if(header.interleave == envi_header::BSQ){			//if the infile is bsq file
			if(header.data_type ==envi_header::float32){		//ERROR
				if(interleave == envi_header::BSQ){
					std::cout<<"ERROR:  is already BSQ file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)			//convert BSQ -> BIL
					((bsq<float>*)file)->bil(outfile, PROGRESS);
				else if(interleave == envi_header::BIP){			//ERROR
					std::cout<<"ERROR: conversion from BSQ to BIP isn't practical; use BSQ->BIL->BIP instead"<<std::endl;
					//return ((bsq<float>*)file)->bip(outfile, PROGRESS);
					exit(1);
				}
			}
			else if(header.data_type == envi_header::float64){		//if the data type is float
				if(interleave == envi_header::BSQ){							//ERROR
					std::cout<<"ERROR:  is already BSQ file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)					//convert BSQ -> BIL
					((bsq<double>*)file)->bil(outfile, PROGRESS);
				else if(interleave == envi_header::BIP){					//ERROR
					std::cout<<"ERROR: conversion from BSQ to BIP isn't practical; use BSQ->BIL->BIP instead"<<std::endl;
					//return ((bsq<float>*)file)->bip(outfile, PROGRESS);
					exit(1);
				}
			}
			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){						//ERROR
				if(interleave == envi_header::BIL){
					std::cout<<"ERROR:  is already BIL file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BSQ)							//BIL -> BSQ
					((bil<float>*)file)->bsq(outfile, PROGRESS);
				else if(interleave == envi_header::BIP)							//BIL -> BIP
					((bil<float>*)file)->bip(outfile, PROGRESS);
			}
			else if(header.data_type == envi_header::float64){
				if(interleave == envi_header::BIL){								//ERROR
					std::cout<<"ERROR:  is already BIL file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BSQ)							//BIL -> BSQ
					((bil<double>*)file)->bsq(outfile, PROGRESS);
				else if(interleave == envi_header::BIP)							//BIL -> BIP
					((bil<double>*)file)->bip(outfile, PROGRESS);
			}
			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(interleave == envi_header::BIP){								//ERROR
					std::cout<<"ERROR:  is already BIP file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)							//BIP -> BIL
					((bip<float>*)file)->bil(outfile, PROGRESS);
				else if(interleave == envi_header::BSQ){						//ERROR
					std::cout<<"ERROR: conversion from BIP to BSQ isn't practical; use BIP->BIL->BSQ instead"<<std::endl;
					//return ((bsq<float>*)file)->bip(outfile, PROGRESS);
					exit(1);
				}
			}
			else if(header.data_type == envi_header::float64){
				if(interleave == envi_header::BIP){								//ERROR
					std::cout<<"ERROR:  is already BIP file"<<std::endl;
					exit(1);
				}
				else if(interleave == envi_header::BIL)							//BIP -> BIL
					((bip<double>*)file)->bil(outfile, PROGRESS);
				else if(interleave == envi_header::BSQ){						//ERROR
					std::cout<<"ERROR: conversion from BIP to BSQ isn't practical; use BIP->BIL->BSQ instead"<<std::endl;
					//return ((bsq<float>*)file)->bip(outfile, PROGRESS);
					exit(1);
				}
			}
			else{
				std::cout<<"ERROR: unidentified data type"<<std::endl;
				exit(1);
			}
		}
		else{
			std::cout<<"ERROR: unidentified interleave type"<<std::endl;
			exit(1);
		}
		stim::envi_header h = header;
		h.interleave = interleave;
		h.save(outfile + ".hdr");
		return true;
	}
	/// Builds a mask from a band image and threshold value
	/// @param mask_band is the label for the band that will be used to build the mask
	/// @param threshold is a value selected such that all band values greater than threshold will have a mask value of 'true'
	/// @param p is memory of size X*Y that will store the resulting mask
	bool build_mask(unsigned char* mask, double mask_band, double threshold, bool PROGRESS = false)	{
		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, mask_band, threshold, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->build_mask(mask, mask_band, threshold, PROGRESS);
			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, mask_band, threshold, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->build_mask(mask, mask_band, threshold, PROGRESS);
			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, mask_band, threshold, PROGRESS);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->build_mask(mask, mask_band, threshold, PROGRESS);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		return false;
	}
	/// Creates a mask with a true value for all pixels that contain finite values
	void mask_finite(unsigned char* mask, bool PROGRESS = false){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				((bsq<float>*)file)->mask_finite(mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				((bsq<double>*)file)->mask_finite(mask, PROGRESS);
			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)
				((bil<float>*)file)->mask_finite(mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				((bil<double>*)file)->mask_finite(mask, PROGRESS);
			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)
				((bip<float>*)file)->mask_finite(mask, PROGRESS);
			else if(header.data_type == envi_header::float64)
				((bip<double>*)file)->mask_finite(mask, PROGRESS);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
	}
	/// Applies a mask to the ENVI file.
	/// @param outfile is the name of the resulting masked output file
	/// @param p is memory of size X*Y containing the mask (0 = false, all other values are true)
	void apply_mask(std::string outfile, unsigned char* p, bool PROGRESS = false)
	{
		if (header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if (header.data_type == envi_header::float32)
				((bsq<float>*)file)->apply_mask(outfile, p, PROGRESS);
			else if (header.data_type == envi_header::float64)
				((bsq<double>*)file)->apply_mask(outfile, p, PROGRESS);
			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)
				((bil<float>*)file)->apply_mask(outfile, p, PROGRESS);
			else if (header.data_type == envi_header::float64)
				((bil<double>*)file)->apply_mask(outfile, p, PROGRESS);
			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)
				((bip<float>*)file)->apply_mask(outfile, p, PROGRESS);
			else if (header.data_type == envi_header::float64)
				((bip<double>*)file)->apply_mask(outfile, p, PROGRESS);
			else
				std::cout << "ERROR: unidentified data type" << std::endl;
		}
		else{
			std::cout << "ERROR: unidentified file type" << std::endl;
			exit(1);
		}
		header.save(outfile + ".hdr");
	}
	/// Copies all spectra corresponding to nonzero values of a mask into a pre-allocated matrix of size (P x B)
	///		where P is the number of masked pixels and B is the number of bands. The allocated memory can be accessed
	///		using the following indexing: i = b*P + p
	/// @param matrix is the destination for the pixel data
	/// @param p is the mask
	bool sift(void* matrix, 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)->sift((float*)matrix, p);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->sift((double*)matrix, p);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		if (header.interleave == envi_header::BIP){
			if (header.data_type == envi_header::float32)
				return ((bip<float>*)file)->sift((float*)matrix, p);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->sift((double*)matrix, p);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		if (header.interleave == envi_header::BIL){
			if (header.data_type == envi_header::float32)
				return ((bil<float>*)file)->sift((float*)matrix, p);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->sift((double*)matrix, p);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
	/// Saves in an array only those spectra corresponding to nonzero values of the mask.
	/// @param outfile is the name of the sifted output file
	/// @param p is the mask
	bool sift(std::string outfile, unsigned char* p, bool PROGRESS = false)
	{
		//calculate the number of non-zero values in the mask
		unsigned long long nnz = 0;
		unsigned long long npixels = header.lines * header.samples;
		for(unsigned long long i = 0; i < npixels; i++)
			if( p[i] > 0 ) nnz++;
		//create a new header
		envi_header new_header = header;
		//if a BIL file is sifted, it's saved as a BIP
		if(header.interleave == envi_header::BIL)
			new_header.interleave = envi_header::BIP;
		//set the number of lines to 1 (this is a matrix with 1 line and N samples)
		new_header.lines = 1;
		new_header.samples = nnz;
		new_header.save(outfile + ".hdr");
		if (header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->sift(outfile, p, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->sift(outfile, p, PROGRESS);
			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)->sift(outfile, p, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->sift(outfile, p, PROGRESS);
			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)->sift(outfile, p, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->sift(outfile, p, PROGRESS);
			else
				std::cout << "ERROR: unidentified data type" << std::endl;
		}
		else{
			std::cout << "ERROR: unidentified file type" << std::endl;
			exit(1);
		}
		return false;
	}
	bool unsift(std::string outfile, unsigned char* mask, unsigned long long samples, unsigned long long lines, bool PROGRESS = false){
		//create a new header
		envi_header new_header = header;
		//set the number of lines and samples in the output file (that's all that changes)
		new_header.lines = lines;
		new_header.samples = samples;
		new_header.save(outfile + ".hdr");
		if (header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->unsift(outfile, mask, samples, lines, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->unsift(outfile, mask, samples, lines, PROGRESS);
			else
				std::cout << "ERROR: unidentified data type" << std::endl;
		}
		else if (header.interleave == envi_header::BIL){		//if the infile is bil file
				std::cout << "ERROR in stim::envi::unsift - BIL files aren't supported yet" << 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)->unsift(outfile, mask, samples, lines, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->unsift(outfile, mask, samples, lines, PROGRESS);
			else
				std::cout << "ERROR: unidentified data type" << std::endl;
		}
		else{
			std::cout << "ERROR: unidentified file type" << std::endl;
		}
		return 0;
	}
	/// Compute the ratio of two baseline-corrected peaks. The result is stored in a pre-allocated array.
	/// @param lb1 is the label value for the left baseline point for the first peak (numerator)
	/// @param rb1 is the label value for the right baseline point for the first peak (numerator)
	/// @param pos1 is the label value for the first peak (numerator) position
	/// @param lb2 is the label value for the left baseline point for the second peak (denominator)
	/// @param rb2 is the label value for the right baseline point for the second peak (denominator)
	/// @param pos2 is the label value for the second peak (denominator) position
	/// @param result is a pointer to a pre-allocated array at least X * Y * sizeof(T) in size
	bool ph_to_ph(void * result, double lb1, double rb1, double pos1, double lb2, double rb2, double pos2, unsigned char* mask){
		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((float*)result, lb1, rb1, pos1, lb2, rb2, pos2, mask);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->ph_to_ph((double*)result, lb1, rb1, pos1, lb2, rb2, pos2, mask);
			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((float*)result, lb1, rb1, pos1, lb2, rb2, pos2, mask);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->ph_to_ph((double*)result, lb1, rb1, pos1, lb2, rb2, pos2, mask);
			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((float*)result, lb1, rb1, pos1, lb2, rb2, pos2, mask);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->ph_to_ph((double*)result, lb1, rb1, pos1, lb2, rb2, pos2, mask);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}
	/// Compute the ratio between a peak area and peak height.
	/// @param lb1 is the label value for the left baseline point for the first peak (numerator)
	/// @param rb1 is the label value for the right baseline point for the first peak (numerator)
	/// @param pos1 is the label value for the first peak (numerator) position
	/// @param lb2 is the label value for the left baseline point for the second peak (denominator)
	/// @param rb2 is the label value for the right baseline point for the second peak (denominator)
	/// @param pos2 is the label value for the second peak (denominator) position
	/// @param result is a pointer to a pre-allocated array at least X * Y * sizeof(T) in size
	bool pa_to_ph(void* result, double lb1, double rb1, double lab1, double rab1, double lb2, double rb2, double pos, unsigned char* mask = NULL){
		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((float*)result, lb1, rb1, lab1, rab1, lb2, rb2, pos, mask);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->pa_to_ph((double*)result, lb1, rb1, lab1, rab1, lb2, rb2, pos, mask);
			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((float*)result, lb1, rb1, lab1, rab1, lb2, rb2, pos, mask);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->pa_to_ph((double*)result, lb1, rb1, lab1, rab1, lb2, rb2, pos, mask);
			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((float*)result, lb1, rb1, lab1, rab1, lb2, rb2, pos, mask);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->pa_to_ph((double*)result, lb1, rb1, lab1, rab1, lb2, rb2, pos, mask);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}
	/// Compute the ratio between two peak areas.
	/// @param lb1 is the label value for the left baseline point for the first peak (numerator)
	/// @param rb1 is the label value for the right baseline point for the first peak (numerator)
	/// @param lab1 is the label value for the left bound (start of the integration) of the first peak (numerator)
	/// @param rab1 is the label value for the right bound (end of the integration) of the first peak (numerator)
	/// @param lb2 is the label value for the left baseline point for the second peak (denominator)
	/// @param rb2 is the label value for the right baseline point for the second peak (denominator)
	/// @param lab2 is the label value for the left bound (start of the integration) of the second peak (denominator)
	/// @param rab2 is the label value for the right bound (end of the integration) of the second peak (denominator)
	/// @param result is a pointer to a pre-allocated array at least X * Y * sizeof(T) in size
	bool pa_to_pa(void* result, double lb1, double rb1, double lab1, double rab1,
					double lb2, double rb2, double lab2, double rab2, unsigned char* mask = NULL){
		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((float*)result, lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, mask);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->pa_to_pa((double*)result, lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, mask);
			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((float*)result, lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, mask);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->pa_to_pa((double*)result, lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, mask);
			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((float*)result, lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, mask);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->pa_to_pa((double*)result, lb1, rb1, lab1, rab1, lb2, rb2, lab2, rab2, mask);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}
	/// Compute the centroid of a baseline corrected peak.
	/// @param lb is the label value for the left baseline point
	/// @param rb is the label value for the right baseline point
	/// @param lab is the label for the start of the peak
	/// @param rab is the label for the end of the peak
	/// @param result is a pointer to a pre-allocated array at least X * Y * sizeof(T) in size
	bool centroid(void* result, double lb1, double rb1, double lab1, double rab1, unsigned char* mask = NULL){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->centroid((float*)result, lb1, rb1, lab1, rab1, mask);
			else if(header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->centroid((double*)result, lb1, rb1, lab1, rab1, mask);
			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)->centroid((float*)result, lb1, rb1, lab1, rab1, mask);
			else if(header.data_type == envi_header::float64)
				return ((bil<double>*)file)->centroid((double*)result, lb1, rb1, lab1, rab1, mask);
			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)->centroid((float*)result, lb1, rb1, lab1, rab1, mask);
			else if(header.data_type == envi_header::float64)
				return ((bip<double>*)file)->centroid((double*)result, lb1, rb1, lab1, rab1, mask);
			else
				std::cout<<"ERROR: unidentified data type"<<std::endl;
		}
		else{
			std::cout<<"ERROR: unidentified file type"<<std::endl;
			exit(1);
		}
		return false;
	}
	/// Closes the ENVI file.
	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;
	}
	/// Retrieve a single pixel and stores it in pre-allocated memory.
	/// @param p is a pointer to pre-allocated memory at least sizeof(T) in size.
	/// @param n is an integer index to the pixel using linear array indexing.
	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;
	}
	/// Saves a header file describing the current ENVI file parameters.
	bool save_header(std::string filename){
		//save the header file here
		header.save(filename);
		return true;
	}
	/// Retrieve a single band (by numerical label) and stores it in pre-allocated memory.
	/// @param p is a pointer to an allocated region of memory at least X * Y * sizeof(T) in size.
	/// @param wavelength is a floating point value (usually a wavelength in spectral data) used as a label for the band to be copied.
	bool band(void* ptr, double wavelength, bool PROGRESS = false){
		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, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->band((double*)ptr, wavelength, PROGRESS);
			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, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->band((double*)ptr, wavelength, PROGRESS);
			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, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->band((double*)ptr, wavelength, PROGRESS);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
	/// Retrieve a spectrum from the specified location
	/// @param ptr is a pointer to pre-allocated memory of size B*sizeof(T)
	/// @param x is the x-coordinate of the spectrum
	/// @param y is the y-coordinate of the spectrum
	bool spectrum(void* ptr, unsigned long long x, unsigned long long y, bool PROGRESS = false){
		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
			if(header.data_type ==envi_header::float32)
				return ((bsq<float>*)file)->spectrum((float*)ptr, x, y, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->spectrum((double*)ptr, x, y, PROGRESS);
			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)->spectrum((float*)ptr, x, y, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->spectrum((double*)ptr, x, y, PROGRESS);
			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)->spectrum((float*)ptr, x, y, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->spectrum((double*)ptr, x, y, PROGRESS);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
	/// Retrieve a single band (based on index) and stores it in pre-allocated memory.
	/// @param p is a pointer to an allocated region of memory at least X * Y * sizeof(T) in size.
	/// @param page <= B is the integer number of the band to be copied.
	bool band_index(void* ptr, unsigned long long 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;
	}
	/// Calculate the mean value for all masked (or valid) pixels in a band and returns the average spectrum
	/// @param p is a pointer to pre-allocated memory of size [B * sizeof(T)] that stores the mean spectrum
	/// @param mask is a pointer to memory of size [X * Y] that stores the mask value at each pixel location
	bool avg_band(double * p, unsigned char* mask, bool PROGRESS = false){
		if (header.interleave == envi_header::BSQ){
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->avg_band(p, mask, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->avg_band(p,  mask, PROGRESS);
			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(p,  mask, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->avg_band(p,  mask, PROGRESS);
			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(p, mask, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->avg_band(p, mask, PROGRESS);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
	/// Calculate the covariance matrix for all masked pixels in the image.
	/// @param co is a pointer to pre-allocated memory of size [B * B] that stores the resulting covariance matrix
	/// @param avg is a pointer to memory of size B that stores the average spectrum
	/// @param mask is a pointer to memory of size [X * Y] that stores the mask value at each pixel location
	bool co_matrix(double* co, double* avg, unsigned char* mask, bool PROGRESS = false){
		if (header.interleave == envi_header::BSQ){
			std::cout<<"ERROR: calculating the covariance matrix for a BSQ file is impractical; convert to BIL or BIP first"<<std::endl;
			exit(1);
			/*if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->co_matrix(co, avg, mask, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->co_matrix(co, avg, mask, PROGRESS);
			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(co, avg, mask, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->co_matrix(co, avg, mask, PROGRESS);
			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(co, avg, mask, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->co_matrix(co, avg, mask, PROGRESS);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
	/// Crop a region of the image and save it to a new file.
	/// @param outfile is the file name for the new cropped image
	/// @param x0 is the lower-left x pixel coordinate to be included in the cropped image
	/// @param y0 is the lower-left y pixel coordinate to be included in the cropped image
	/// @param x1 is the upper-right x pixel coordinate to be included in the cropped image
	/// @param y1 is the upper-right y pixel coordinate to be included in the cropped image
	bool crop(std::string outfile,
			  unsigned long long x0, 
			  unsigned long long y0, 
			  unsigned long long x1, 
			  unsigned long long y1, 
			  unsigned long long b0, 
			  unsigned long long b1, 
			  bool PROGRESS = false){
		//save the header for the cropped file
		stim::envi_header new_header = header;
		new_header.samples = x1 - x0;
		new_header.lines = y1 - y0;
		new_header.bands = b1 - b0;
		std::vector<double>::const_iterator first = new_header.wavelength.begin() + b0;
		std::vector<double>::const_iterator last = new_header.wavelength.begin() + b1;
		new_header.wavelength = std::vector<double>(first, last);
		new_header.save(outfile + ".hdr");
		if (header.interleave == envi_header::BSQ){
			if (header.data_type == envi_header::float32)
				return ((bsq<float>*)file)->crop(outfile, x0, y0, x1, y1, b0, b1, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bsq<double>*)file)->crop(outfile, x0, y0, x1, y1, b0, b1, PROGRESS);
			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, b0, b1, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bil<double>*)file)->crop(outfile, x0, y0, x1, y1, b0, b1, PROGRESS);
			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, b0, b1, PROGRESS);
			else if (header.data_type == envi_header::float64)
				return ((bip<double>*)file)->crop(outfile, x0, y0, x1, y1, b0, b1, PROGRESS);
			else{
				std::cout << "ERROR: unidentified data type" << std::endl;
				exit(1);
			}
		}
		return false;
	}
};
}	//end namespace rts
#endif