From 70407ea9143be076b3c5e3b24305c87de98c6256 Mon Sep 17 00:00:00 2001
From: heziqi <heziqi36@gmail.com>
Date: Wed, 15 Oct 2014 09:25:18 +0800
Subject: [PATCH] Ziqi completed height2heigth area2height area2area ratio

---
 envi/bil.h  | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------
 envi/bip.h  | 101 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------
 envi/bsq.h  | 109 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------
 envi/envi.h |  89 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------
 4 files changed, 311 insertions(+), 91 deletions(-)

diff --git a/envi/bil.h b/envi/bil.h
index 88fd3d5..733c7f5 100644
--- a/envi/bil.h
+++ b/envi/bil.h
@@ -403,17 +403,16 @@ public:
 	}
 	//untested
 	//providing the left and the right bound wavelength, return baseline-corrected band height
-	bool height(double lb, double rb, double bandwavelength){
+	bool height(double lb, double rb, double bandwavelength, T* result){
 
 		T* lp;
 		T* rp;
-		T* result;
-
-		lp = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));			//memory allocation
-		rp = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));
-		result = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));
+		unsigned XY = R[0] * R[1];
+		unsigned S = XY * sizeof(T);
+		lp = (T*) malloc(S);			//memory allocation
+		rp = (T*) malloc(S);
 
-		band(lp, lb);			//get the data of the left bounbd and the right bound
+		band(lp, lb);
 		band(rp, rb);		
 
 		baseline_band(lb, rb, lp, rp, bandwavelength, result);
@@ -421,14 +420,14 @@ public:
 		return true;
 	}
 
+
 	//calculate the area between two bound point(including baseline correction)
-	bool area(double lb, double rb){
+	bool area(double lb, double rb, double lab, double rab, T* result){
 
 		T* lp;	//left band pointer
 		T* rp;	//right band pointer
 		T* cur;		//current band 1
 		T* cur2;	//current band 2
-		T* result;		//area result
 
 		unsigned XY = R[0] * R[1];
 		unsigned S = XY * sizeof(T);
@@ -437,7 +436,6 @@ public:
 		rp = (T*) malloc(S);
 		cur = (T*) malloc(S);
 		cur2 = (T*) malloc(S);
-		result = (T*) malloc(S);
 
 		memset(result, (char)0, S);
 
@@ -460,10 +458,10 @@ public:
 		}
 
 		//get the position of lb and rb
-		while (lb >= w[ai]){
+		while (lab >= w[ai]){
 			ai++;
 		}
-		while (rb <= w[bi]){
+		while (rab <= w[bi]){
 			bi--;
 		}
 
@@ -471,13 +469,15 @@ public:
 		band(rp, rb);
 
 		//calculate the beginning and the ending part
-		baseline_band(lb, rb, lp, rp, w[bi], cur);		//ending part
+		baseline_band(lb, rb, lp, rp, rab, cur2);		//ending part
+		baseline_band(lb, rb, lp, rp, w[bi], cur);
 		for(unsigned j = 0; j < XY; j++){
-			result[j] += (rb - w[bi]) * cur[j] / 2.0;
+			result[j] += (rab - w[bi]) * (cur[j] + cur2[j]) / 2.0;
 		}
-		baseline_band(lb, rb, lp, rp, w[ai], cur);		//beginnning part
+		baseline_band(lb, rb, lp, rp, lab, cur2);		//beginnning part
+		baseline_band(lb, rb, lp, rp, w[ai], cur);
 		for(unsigned j = 0; j < XY; j++){	
-			result[j] += (w[ai] - lb) * cur[j] / 2.0;
+			result[j] += (w[ai] - lab) * (cur[j] + cur2[j]) / 2.0;
 		}
 		//calculate the area
 		ai++;
@@ -490,20 +490,69 @@ public:
 			}
 			std::swap(cur,cur2);		//swap the band pointers
 		}
-		///////////////for testing use
-		std::ofstream text("area_result.txt",std::ios::out);
-		for (unsigned i = 0; i < 640; i++)	
-		{
-			for (unsigned j = 0; j < 384; j++)
-			{
-				text<<result[i*384+j]<<", ";
-			}
-			text<<std::endl;
-		}
-		///////////////
+
 		return true;
 	}
 
+	//peak height ratio
+	bool ph_to_ph(double lb1, double rb1, double pos1, double lb2, double rb2, double pos2, T * result){
+
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the two peak band
+		height(lb1, rb1, pos1, p1);
+		height(lb2, rb2, pos2, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}
+	
+	//peak are to peak height ratio
+	bool pa_to_ph(double lb1, double rb1, double lab1, double rab1,
+					double lb2, double rb2, double pos, T* result){
+		
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the area and the peak band
+		area(lb1, rb1, lab1, rab1, p1);
+		height(lb2, rb2, pos, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}		
+	
+	//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, T* result){
+		
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the area and the peak band
+		area(lb1, rb1, lab1, rab1, p1);
+		area(lb2, rb2, lab2, rab2, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}		
+
 	//create mask file
 	bool mask(unsigned char* p, double mask_band, double threshold){
 
diff --git a/envi/bip.h b/envi/bip.h
index fc82096..4198751 100644
--- a/envi/bip.h
+++ b/envi/bip.h
@@ -490,17 +490,16 @@ public:
 	}
 	//untested
 	//providing the left and the right bound wavelength, return baseline-corrected band height
-	bool height(double lb, double rb, double bandwavelength){
+	bool height(double lb, double rb, double bandwavelength, T* result){
 
 		T* lp;
 		T* rp;
-		T* result;
-
-		lp = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));			//memory allocation
-		rp = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));
-		result = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));
+		unsigned XY = R[0] * R[1];
+		unsigned S = XY * sizeof(T);
+		lp = (T*) malloc(S);			//memory allocation
+		rp = (T*) malloc(S);
 
-		band(lp, lb);			//get the data of the left bounbd and the right bound
+		band(lp, lb);
 		band(rp, rb);		
 
 		baseline_band(lb, rb, lp, rp, bandwavelength, result);
@@ -510,13 +509,12 @@ public:
 
 
 	//calculate the area between two bound point(including baseline correction)
-	bool area(double lb, double rb){
+	bool area(double lb, double rb, double lab, double rab, T* result){
 
 		T* lp;	//left band pointer
 		T* rp;	//right band pointer
 		T* cur;		//current band 1
 		T* cur2;	//current band 2
-		T* result;		//area result
 
 		unsigned XY = R[0] * R[1];
 		unsigned S = XY * sizeof(T);
@@ -525,7 +523,6 @@ public:
 		rp = (T*) malloc(S);
 		cur = (T*) malloc(S);
 		cur2 = (T*) malloc(S);
-		result = (T*) malloc(S);
 
 		memset(result, (char)0, S);
 
@@ -548,10 +545,10 @@ public:
 		}
 
 		//get the position of lb and rb
-		while (lb >= w[ai]){
+		while (lab >= w[ai]){
 			ai++;
 		}
-		while (rb <= w[bi]){
+		while (rab <= w[bi]){
 			bi--;
 		}
 
@@ -559,13 +556,15 @@ public:
 		band(rp, rb);
 
 		//calculate the beginning and the ending part
-		baseline_band(lb, rb, lp, rp, w[bi], cur);		//ending part
+		baseline_band(lb, rb, lp, rp, rab, cur2);		//ending part
+		baseline_band(lb, rb, lp, rp, w[bi], cur);
 		for(unsigned j = 0; j < XY; j++){
-			result[j] += (rb - w[bi]) * cur[j] / 2.0;
+			result[j] += (rab - w[bi]) * (cur[j] + cur2[j]) / 2.0;
 		}
-		baseline_band(lb, rb, lp, rp, w[ai], cur);		//beginnning part
+		baseline_band(lb, rb, lp, rp, lab, cur2);		//beginnning part
+		baseline_band(lb, rb, lp, rp, w[ai], cur);
 		for(unsigned j = 0; j < XY; j++){	
-			result[j] += (w[ai] - lb) * cur[j] / 2.0;
+			result[j] += (w[ai] - lab) * (cur[j] + cur2[j]) / 2.0;
 		}
 		//calculate the area
 		ai++;
@@ -578,20 +577,68 @@ public:
 			}
 			std::swap(cur,cur2);		//swap the band pointers
 		}
-		///////////////for testing use
-		std::ofstream text("area_result.txt",std::ios::out);
-		for (unsigned i = 0; i < 640; i++)	
-		{
-			for (unsigned j = 0; j < 384; j++)
-			{
-				text<<result[i*384+j]<<", ";
-			}
-			text<<std::endl;
-		}
-		///////////////
+
 		return true;
 	}
 
+	//peak height ratio
+	bool ph_to_ph(double lb1, double rb1, double pos1, double lb2, double rb2, double pos2, T * result){
+
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the two peak band
+		height(lb1, rb1, pos1, p1);
+		height(lb2, rb2, pos2, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}
+	
+	//peak are to peak height ratio
+	bool pa_to_ph(double lb1, double rb1, double lab1, double rab1,
+					double lb2, double rb2, double pos, T* result){
+		
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the area and the peak band
+		area(lb1, rb1, lab1, rab1, p1);
+		height(lb2, rb2, pos, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}		
+	
+	//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, T* result){
+		
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the area and the peak band
+		area(lb1, rb1, lab1, rab1, p1);
+		area(lb2, rb2, lab2, rab2, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}		
 	//create mask file
 	bool mask(unsigned char* p, double mask_band, double threshold){
 
diff --git a/envi/bsq.h b/envi/bsq.h
index 0de7abd..54bac04 100644
--- a/envi/bsq.h
+++ b/envi/bsq.h
@@ -50,7 +50,11 @@ public:
 			return false;
 		}
 
-		getSlice(p, 2, page);
+		file.seekg(R[0] * R[1] * page * sizeof(T), std::ios::beg);
+
+		file.read((char *)p, sizeof(T) * R[0] * R[1]);
+
+//		getSlice(p, 2, page);
 		return true;
 	}
 
@@ -93,7 +97,7 @@ public:
 		}
 		else                           //if the wavelength is equal to a wavelength in header file
 		{
-			getSlice(p, 2, page);
+			band_index(p, page);
 		}
 
 		return true;
@@ -325,17 +329,16 @@ public:
 	}
 	//untested
 	//providing the left and the right bound wavelength, return baseline-corrected band height
-	bool height(double lb, double rb, double bandwavelength){
+	bool height(double lb, double rb, double bandwavelength, T* result){
 
 		T* lp;
 		T* rp;
-		T* result;
-
-		lp = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));			//memory allocation
-		rp = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));
-		result = (T*) malloc(sizeof(R[0] * R[1] * sizeof(T)));
+		unsigned XY = R[0] * R[1];
+		unsigned S = XY * sizeof(T);
+		lp = (T*) malloc(S);			//memory allocation
+		rp = (T*) malloc(S);
 
-		band(lp, lb);			//get the data of the left bounbd and the right bound
+		band(lp, lb);
 		band(rp, rb);		
 
 		baseline_band(lb, rb, lp, rp, bandwavelength, result);
@@ -345,13 +348,12 @@ public:
 
 
 	//calculate the area between two bound point(including baseline correction)
-	bool area(double lb, double rb){
+	bool area(double lb, double rb, double lab, double rab, T* result){
 
 		T* lp;	//left band pointer
 		T* rp;	//right band pointer
 		T* cur;		//current band 1
 		T* cur2;	//current band 2
-		T* result;		//area result
 
 		unsigned XY = R[0] * R[1];
 		unsigned S = XY * sizeof(T);
@@ -360,7 +362,6 @@ public:
 		rp = (T*) malloc(S);
 		cur = (T*) malloc(S);
 		cur2 = (T*) malloc(S);
-		result = (T*) malloc(S);
 
 		memset(result, (char)0, S);
 
@@ -383,10 +384,10 @@ public:
 		}
 
 		//get the position of lb and rb
-		while (lb >= w[ai]){
+		while (lab >= w[ai]){
 			ai++;
 		}
-		while (rb <= w[bi]){
+		while (rab <= w[bi]){
 			bi--;
 		}
 
@@ -394,14 +395,17 @@ public:
 		band(rp, rb);
 
 		//calculate the beginning and the ending part
-		baseline_band(lb, rb, lp, rp, w[bi], cur);		//ending part
+		baseline_band(lb, rb, lp, rp, rab, cur2);		//ending part
+		baseline_band(lb, rb, lp, rp, w[bi], cur);
 		for(unsigned j = 0; j < XY; j++){
-			result[j] += (rb - w[bi]) * cur[j] / 2.0;
+			result[j] += (rab - w[bi]) * (cur[j] + cur2[j]) / 2.0;
 		}
-		baseline_band(lb, rb, lp, rp, w[ai], cur);		//beginnning part
+		baseline_band(lb, rb, lp, rp, lab, cur2);		//beginnning part
+		baseline_band(lb, rb, lp, rp, w[ai], cur);
 		for(unsigned j = 0; j < XY; j++){	
-			result[j] += (w[ai] - lb) * cur[j] / 2.0;
+			result[j] += (w[ai] - lab) * (cur[j] + cur2[j]) / 2.0;
 		}
+
 		//calculate the area
 		ai++;
 		for(unsigned i = ai; i <= bi ;i++)
@@ -413,21 +417,68 @@ public:
 			}
 			std::swap(cur,cur2);		//swap the band pointers
 		}
-		///////////////for testing use
-		std::ofstream text("area_result.txt",std::ios::out);
-		for (unsigned i = 0; i < 640; i++)	
-		{
-			for (unsigned j = 0; j < 384; j++)
-			{
-				text<<result[i*384+j]<<", ";
-			}
-			text<<std::endl;
-		}
-		///////////////
+
 		return true;
 	}
 
+	//peak height ratio
+	bool ph_to_ph(double lb1, double rb1, double pos1, double lb2, double rb2, double pos2, T * result){
 
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the two peak band
+		height(lb1, rb1, pos1, p1);
+		height(lb2, rb2, pos2, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}
+	
+	//peak are to peak height ratio
+	bool pa_to_ph(double lb1, double rb1, double lab1, double rab1,
+					double lb2, double rb2, double pos, T* result){
+		
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the area and the peak band
+		area(lb1, rb1, lab1, rab1, p1);
+		height(lb2, rb2, pos, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}		
+	
+	//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, T* result){
+		
+		T* p1 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		T* p2 = (T*)malloc(R[0] * R[1] * sizeof(T));	
+		
+		//get the area and the peak band
+		area(lb1, rb1, lab1, rab1, p1);
+		area(lb2, rb2, lab2, rab2, p2);
+		//calculate the ratio in result
+		for(unsigned i = 0; i < R[0] * R[1]; i++){
+			if(p1[i] == 0 && p2[i] ==0)
+				result[i] = 1;
+			else
+				result[i] = p1[i] / p2[i];
+		}
+		return true;	
+	}		
 	//create mask file
 	bool mask(unsigned char* p, double mask_band, double threshold){
 
diff --git a/envi/envi.h b/envi/envi.h
index 6f10f80..a75bd77 100644
--- a/envi/envi.h
+++ b/envi/envi.h
@@ -310,31 +310,104 @@ public:
 		return false;
 	}
 
-	//do baseline correction and caculate the area between two bounds
-	bool area(double lb, double rb){
+	//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)->area(lb, rb);
+				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)->area(lb, rb);
+				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)->area(lb, rb);
+				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)->area(lb, rb);
+				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)->area(lb, rb);
+				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)->area(lb, rb);
+				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;
 		}
--
libgit2 0.21.4