Commit a43c4fe1a8ecec4fdc99cfcd4b4518d2ab512be1
1 parent
84a4e0f1
Added crop in envi class
Showing
4 changed files
with
447 additions
and
0 deletions
Show diff stats
envi/bil.h
@@ -727,6 +727,130 @@ public: | @@ -727,6 +727,130 @@ public: | ||
727 | return true; | 727 | return true; |
728 | } | 728 | } |
729 | 729 | ||
730 | + //calculate the average band value | ||
731 | + bool band_avg(T* p){ | ||
732 | + unsigned long long XZ = R[0] * R[2]; | ||
733 | + T* temp = (T*)malloc(sizeof(T) * XZ); | ||
734 | + T* line = (T*)malloc(sizeof(T) * R[0]); | ||
735 | + | ||
736 | + for (unsigned i = 0; i < R[1]; i++){ | ||
737 | + getY(temp, i); | ||
738 | + //initialize x-line | ||
739 | + for (unsigned j = 0; j < R[0]; j++){ | ||
740 | + line[j] = 0; | ||
741 | + } | ||
742 | + unsigned c = 0; | ||
743 | + for (unsigned j = 0; j < R[2]; j++){ | ||
744 | + for (unsigned k = 0; k < R[0]; k++){ | ||
745 | + line[k] += temp[c] / (T)R[2]; | ||
746 | + c++; | ||
747 | + } | ||
748 | + } | ||
749 | + for (unsigned j = 0; j < R[0]; j++){ | ||
750 | + p[j + i * R[0]] = line[j]; | ||
751 | + } | ||
752 | + } | ||
753 | + free(temp); | ||
754 | + return true; | ||
755 | + } | ||
756 | + | ||
757 | + //calculate the average number of every band | ||
758 | + bool avg_band(T*p, unsigned char* mask){ | ||
759 | + unsigned long long XZ = R[0] * R[2]; | ||
760 | + unsigned long long XY = R[0] * R[1]; | ||
761 | + T* temp = (T*)malloc(sizeof(T) * XZ); | ||
762 | + for (unsigned j = 0; j < R[2]; j++){ | ||
763 | + p[j] = 0; | ||
764 | + } | ||
765 | + //calculate vaild number in a band | ||
766 | + unsigned count = 0; | ||
767 | + for (unsigned j = 0; j < XY; j++){ | ||
768 | + if (mask[j] != 0){ | ||
769 | + count++; | ||
770 | + } | ||
771 | + } | ||
772 | + for (unsigned k = 0; k < R[1]; k++){ | ||
773 | + getY(temp, k); | ||
774 | + unsigned kx = k * R[0]; | ||
775 | + for (unsigned i = 0; i < R[0]; i++){ | ||
776 | + if (mask[kx + i] != 0){ | ||
777 | + for (unsigned j = 0; j < R[2]; j++){ | ||
778 | + p[j] += temp[j * R[0] + i] / (T)count; | ||
779 | + } | ||
780 | + } | ||
781 | + } | ||
782 | + } | ||
783 | + free(temp); | ||
784 | + return true; | ||
785 | + } | ||
786 | + | ||
787 | + //calculate correlation coefficient matrix | ||
788 | + bool co_matrix(T* co, T* avg, unsigned char *mask){ | ||
789 | + //memory allocation | ||
790 | + unsigned long long xy = R[0] * R[1]; | ||
791 | + unsigned int B = R[2]; | ||
792 | + T* temp = (T*)malloc(sizeof(T) * B); | ||
793 | + //count vaild pixels in a band | ||
794 | + unsigned count = 0; | ||
795 | + for (unsigned j = 0; j < xy; j++){ | ||
796 | + if (mask[j] != 0){ | ||
797 | + count++; | ||
798 | + } | ||
799 | + } | ||
800 | + //initialize correlation matrix | ||
801 | + for (unsigned i = 0; i < B; i++){ | ||
802 | + for (unsigned k = 0; k < B; k++){ | ||
803 | + co[i * B + k] = 0; | ||
804 | + } | ||
805 | + } | ||
806 | + //calculate correlation coefficient matrix | ||
807 | + for (unsigned j = 0; j < xy; j++){ | ||
808 | + if (mask[j] != 0){ | ||
809 | + pixel(temp, j); | ||
810 | + for (unsigned i = 0; i < B; i++){ | ||
811 | + for (unsigned k = i; k < B; k++){ | ||
812 | + co[i * B + k] += (temp[i] - avg[i]) * (temp[k] - avg[k]) / count; | ||
813 | + } | ||
814 | + } | ||
815 | + } | ||
816 | + } | ||
817 | + //because correlation matrix is symmetric | ||
818 | + for (unsigned i = 0; i < B; i++){ | ||
819 | + for (unsigned k = i + 1; k < B; k++){ | ||
820 | + co[k * B + i] = co[i * B + k]; | ||
821 | + } | ||
822 | + } | ||
823 | + | ||
824 | + free(temp); | ||
825 | + return true; | ||
826 | + } | ||
827 | + | ||
828 | + //crop specified area the of the original file | ||
829 | + bool crop(std::string outfile, unsigned x0, unsigned y0, unsigned x1, unsigned y1){ | ||
830 | + | ||
831 | + //calculate the new number of samples and lines | ||
832 | + unsigned long long sam = x1 - x0; //samples | ||
833 | + unsigned long long lin = y1 - y0; //lines | ||
834 | + unsigned long long L = sam * R[2] * sizeof(T); | ||
835 | + //get specified band and save | ||
836 | + T* temp = (T*)malloc(L); | ||
837 | + std::ofstream out(outfile.c_str(), std::ios::binary); | ||
838 | + unsigned long long jumpb = (R[0] - sam) * sizeof(T); //jump pointer to the next band | ||
839 | + //get start | ||
840 | + file.seekg((y0 * R[0] * R[2] + x0) * sizeof(T), std::ios::beg); | ||
841 | + for (unsigned i = 0; i < lin; i++) | ||
842 | + { | ||
843 | + for (unsigned j = 0; j < R[2]; j++) | ||
844 | + { | ||
845 | + file.read((char *)(temp + j * sam), sizeof(T) * sam); | ||
846 | + file.seekg(jumpb, std::ios::cur); //go to the next band | ||
847 | + } | ||
848 | + out.write(reinterpret_cast<const char*>(temp), L); //write slice data into target file | ||
849 | + } | ||
850 | + free(temp); | ||
851 | + return true; | ||
852 | + } | ||
853 | + | ||
730 | //close the file | 854 | //close the file |
731 | bool close(){ | 855 | bool close(){ |
732 | file.close(); | 856 | file.close(); |
envi/bip.h
@@ -821,6 +821,117 @@ public: | @@ -821,6 +821,117 @@ public: | ||
821 | return true; | 821 | return true; |
822 | } | 822 | } |
823 | 823 | ||
824 | + //calculate the average band of the file | ||
825 | + bool band_avg(T* p){ | ||
826 | + unsigned long long XY = R[0] * R[1]; | ||
827 | + //get every pixel and calculate average value | ||
828 | + T* temp = (T*)malloc(sizeof(T) * R[2]); | ||
829 | + T sum; | ||
830 | + for (unsigned i = 0; i < XY; i++){ | ||
831 | + pixel(temp, i); | ||
832 | + //calculate the sum value of every value | ||
833 | + sum = 0; //initialize sum value | ||
834 | + for (unsigned j = 0; j < R[2]; j++){ | ||
835 | + sum += temp[j]/(T)R[2]; | ||
836 | + } | ||
837 | + p[i] = sum; | ||
838 | + } | ||
839 | + free(temp); | ||
840 | + return true; | ||
841 | + } | ||
842 | + | ||
843 | + //calculate the average number of every band | ||
844 | + bool avg_band(T*p, unsigned char* mask){ | ||
845 | + unsigned long long XY = R[0] * R[1]; | ||
846 | + T* temp = (T*)malloc(sizeof(T) * R[2]); | ||
847 | + //Iinitialize | ||
848 | + for (unsigned j = 0; j < R[2]; j++){ | ||
849 | + p[j] = 0; | ||
850 | + } | ||
851 | + //calculate vaild number in a band | ||
852 | + unsigned count = 0; | ||
853 | + for (unsigned j = 0; j < XY; j++){ | ||
854 | + if (mask[j] != 0){ | ||
855 | + count++; | ||
856 | + } | ||
857 | + } | ||
858 | + //calculate average number of a band | ||
859 | + for (unsigned i = 0; i < XY; i++){ | ||
860 | + if (mask[i] != 0){ | ||
861 | + pixel(temp, i); | ||
862 | + for (unsigned j = 0; j < R[2]; j++){ | ||
863 | + p[j] += temp[j] / (T)count; | ||
864 | + } | ||
865 | + } | ||
866 | + } | ||
867 | + free(temp); | ||
868 | + return true; | ||
869 | + } | ||
870 | + //calculate correlation coefficient matrix | ||
871 | + bool co_matrix(T* co, T* avg, unsigned char *mask){ | ||
872 | + //memory allocation | ||
873 | + unsigned long long xy = R[0] * R[1]; | ||
874 | + unsigned int B = R[2]; | ||
875 | + T* temp = (T*)malloc(sizeof(T) * B); | ||
876 | + //count vaild pixels in a band | ||
877 | + unsigned count = 0; | ||
878 | + for (unsigned j = 0; j < xy; j++){ | ||
879 | + if (mask[j] != 0){ | ||
880 | + count++; | ||
881 | + } | ||
882 | + } | ||
883 | + //initialize correlation matrix | ||
884 | + for (unsigned i = 0; i < B; i++){ | ||
885 | + for (unsigned k = 0; k < B; k++){ | ||
886 | + co[i * B + k] = 0; | ||
887 | + } | ||
888 | + } | ||
889 | + //calculate correlation coefficient matrix | ||
890 | + for (unsigned j = 0; j < xy; j++){ | ||
891 | + if (mask[j] != 0){ | ||
892 | + pixel(temp, j); | ||
893 | + for (unsigned i = 0; i < B; i++){ | ||
894 | + for (unsigned k = i; k < B; k++){ | ||
895 | + co[i * B + k] += (temp[i] - avg[i]) * (temp[k] - avg[k]) / count; | ||
896 | + } | ||
897 | + } | ||
898 | + } | ||
899 | + } | ||
900 | + //because correlation matrix is symmetric | ||
901 | + for (unsigned i = 0; i < B; i++){ | ||
902 | + for (unsigned k = i + 1; k < B; k++){ | ||
903 | + co[k * B + i] = co[i * B + k]; | ||
904 | + } | ||
905 | + } | ||
906 | + | ||
907 | + free(temp); | ||
908 | + return true; | ||
909 | + } | ||
910 | + | ||
911 | + //crop specified area the of the original file | ||
912 | + bool crop(std::string outfile, unsigned x0, unsigned y0, unsigned x1, unsigned y1){ | ||
913 | + | ||
914 | + //calculate the new number of samples and lines | ||
915 | + unsigned long long sam = x1 - x0; //samples | ||
916 | + unsigned long long lin = y1 - y0; //lines | ||
917 | + unsigned long long L = R[2] * sizeof(T); | ||
918 | + //get specified band and save | ||
919 | + T* temp = (T*)malloc(L); | ||
920 | + std::ofstream out(outfile.c_str(), std::ios::binary); | ||
921 | + //get start | ||
922 | + unsigned long long sp = y0 * R[0] + x0; //start pixel | ||
923 | + for (unsigned i = 0; i < lin; i++) | ||
924 | + { | ||
925 | + for (unsigned j = 0; j < sam; j++) | ||
926 | + { | ||
927 | + pixel(temp, sp + j + i * R[0]); | ||
928 | + out.write(reinterpret_cast<const char*>(temp), L); //write slice data into target file | ||
929 | + } | ||
930 | + } | ||
931 | + free(temp); | ||
932 | + return true; | ||
933 | + } | ||
934 | + | ||
824 | //close the file | 935 | //close the file |
825 | bool close(){ | 936 | bool close(){ |
826 | file.close(); | 937 | file.close(); |
envi/bsq.h
@@ -663,6 +663,115 @@ public: | @@ -663,6 +663,115 @@ public: | ||
663 | return true; | 663 | return true; |
664 | } | 664 | } |
665 | 665 | ||
666 | + //calculate the average band | ||
667 | + bool band_avg(T* p){ | ||
668 | + unsigned long long XY = R[0] * R[1]; | ||
669 | + T* temp = (T*)malloc(sizeof(T) * XY); | ||
670 | + //initialize p | ||
671 | + band_index(p, 0); | ||
672 | + for (unsigned j = 0; j < XY; j++){ | ||
673 | + p[j] /= (T)R[2]; | ||
674 | + } | ||
675 | + //get every band and add them all | ||
676 | + for (unsigned i = 1; i < R[2]; i++){ | ||
677 | + band_index(temp, i); | ||
678 | + for (unsigned j = 0; j < XY; j++){ | ||
679 | + p[j] += temp[j]/(T)R[2]; | ||
680 | + } | ||
681 | + } | ||
682 | + free(temp); | ||
683 | + return true; | ||
684 | + } | ||
685 | + | ||
686 | + //calculate the average number of every band | ||
687 | + bool avg_band(T*p, unsigned char* mask){ | ||
688 | + unsigned long long XY = R[0] * R[1]; | ||
689 | + unsigned count = 0; //number of vaild pixel in a band | ||
690 | + T* temp = (T*)malloc(sizeof(T) * XY); | ||
691 | + //calculate valid pixel number | ||
692 | + for (unsigned j = 0; j < XY; j++){ | ||
693 | + if (mask[j] != 0){ | ||
694 | + count++; | ||
695 | + } | ||
696 | + } | ||
697 | + //calculate average of a band | ||
698 | + for (unsigned i = 0; i < R[2]; i++){ | ||
699 | + p[i] = 0; | ||
700 | + band_index(temp, i); | ||
701 | + for (unsigned j = 0; j < XY; j++){ | ||
702 | + if (mask[j] != 0){ | ||
703 | + p[i] += temp[j] / (T)count; | ||
704 | + } | ||
705 | + } | ||
706 | + } | ||
707 | + free(temp); | ||
708 | + return true; | ||
709 | + } | ||
710 | + | ||
711 | + //calculate correlated matrix | ||
712 | + bool co_matrix(T* co, T* avg, unsigned char *mask){ | ||
713 | + //memory allocation | ||
714 | + unsigned long long xy = R[0] * R[1]; | ||
715 | + unsigned int B = R[2]; | ||
716 | + T* bandi = (T*)malloc(sizeof(T) * xy); | ||
717 | + T* bandj = (T*)malloc(sizeof(T) * xy); | ||
718 | + | ||
719 | + //count vaild pixels in a band | ||
720 | + unsigned count = 0; | ||
721 | + for (unsigned j = 0; j < xy; j++){ | ||
722 | + if (mask[j] != 0){ | ||
723 | + count++; | ||
724 | + } | ||
725 | + } | ||
726 | + //calculate correlation coefficient matrix | ||
727 | + for (unsigned i = 0; i < B; i++) | ||
728 | + { | ||
729 | + band_index(bandi, i); | ||
730 | + for (unsigned j = i; j < B; j++){ | ||
731 | + band_index(bandj, j); | ||
732 | + T numerator = 0; //to calculate element in correlation coefficient matrix, numerator part | ||
733 | + //calculate the R(i,j) in correlation coeffient matrix | ||
734 | + for (unsigned k = 0; k < xy; k++){ | ||
735 | + if (mask[k] != 0){ | ||
736 | + numerator += (bandi[k] - avg[i]) * (bandj[k] - avg[j]) / count; | ||
737 | + } | ||
738 | + } | ||
739 | + co[i*B + j] = numerator; | ||
740 | + co[j*B + i] = numerator; //because correlated matrix is a symmetric matrix | ||
741 | + } | ||
742 | + } | ||
743 | + free(bandi); | ||
744 | + free(bandj); | ||
745 | + return true; | ||
746 | + } | ||
747 | + | ||
748 | + //crop specified area the of the original file | ||
749 | + bool crop(std::string outfile, unsigned x0, unsigned y0, unsigned x1, unsigned y1){ | ||
750 | + | ||
751 | + //calculate the new number of samples and lines | ||
752 | + unsigned long long sam = x1 - x0; //samples | ||
753 | + unsigned long long lin = y1 - y0; //lines | ||
754 | + unsigned long long L = sam * lin * sizeof(T); | ||
755 | + //get specified band and save | ||
756 | + T* temp = (T*)malloc(L); | ||
757 | + std::ofstream out(outfile.c_str(), std::ios::binary); | ||
758 | + unsigned long long jumpb = R[0] * (R[1] - lin) * sizeof(T); //jump pointer to the next band | ||
759 | + unsigned long long jumpl = (R[0] - sam) * sizeof(T); //jump pointer to the next line | ||
760 | + //get start | ||
761 | + file.seekg((y0 * R[0] + x0) * sizeof(T), std::ios::beg); | ||
762 | + for (unsigned i = 0; i < R[2]; i++) | ||
763 | + { | ||
764 | + for (unsigned j = 0; j < lin; j++) | ||
765 | + { | ||
766 | + file.read((char *)(temp + j * sam), sizeof(T) * sam); | ||
767 | + file.seekg(jumpl, std::ios::cur); //go to the next band | ||
768 | + } | ||
769 | + out.write(reinterpret_cast<const char*>(temp), L); //write slice data into target file | ||
770 | + file.seekg(jumpb, std::ios::cur); | ||
771 | + } | ||
772 | + free(temp); | ||
773 | + return true; | ||
774 | + } | ||
666 | 775 | ||
667 | //close the file | 776 | //close the file |
668 | bool close(){ | 777 | bool close(){ |
envi/envi.h
@@ -642,8 +642,111 @@ public: | @@ -642,8 +642,111 @@ public: | ||
642 | return true; | 642 | return true; |
643 | } | 643 | } |
644 | 644 | ||
645 | + //calculate band average | ||
646 | + bool avg_band(void * p, unsigned char* mask){ | ||
647 | + if (header.interleave == envi_header::BSQ){ | ||
648 | + if (header.data_type == envi_header::float32) | ||
649 | + return ((bsq<float>*)file)->avg_band((float*)p, mask); | ||
650 | + else if (header.data_type == envi_header::float64) | ||
651 | + return ((bsq<double>*)file)->avg_band((double*)p, mask); | ||
652 | + else{ | ||
653 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
654 | + exit(1); | ||
655 | + } | ||
656 | + } | ||
657 | + else if (header.interleave == envi_header::BIL){ | ||
658 | + if (header.data_type == envi_header::float32) | ||
659 | + return ((bil<float>*)file)->avg_band((float*)p, mask); | ||
660 | + else if (header.data_type == envi_header::float64) | ||
661 | + return ((bil<double>*)file)->avg_band((double*)p, mask); | ||
662 | + else{ | ||
663 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
664 | + exit(1); | ||
665 | + } | ||
666 | + } | ||
667 | + else if (header.interleave == envi_header::BIP){ | ||
668 | + if (header.data_type == envi_header::float32) | ||
669 | + return ((bip<float>*)file)->avg_band((float*)p, mask); | ||
670 | + else if (header.data_type == envi_header::float64) | ||
671 | + return ((bip<double>*)file)->avg_band((double*)p, mask); | ||
672 | + else{ | ||
673 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
674 | + exit(1); | ||
675 | + } | ||
676 | + } | ||
677 | + return false; | ||
678 | + } | ||
645 | 679 | ||
680 | + //calculate correlation coefficient matrix with mask | ||
681 | + bool co_matrix(void* co, void* avg, unsigned char* mask){ | ||
682 | + if (header.interleave == envi_header::BSQ){ | ||
683 | + if (header.data_type == envi_header::float32) | ||
684 | + return ((bsq<float>*)file)->co_matrix((float*)co, (float*)avg, mask); | ||
685 | + else if (header.data_type == envi_header::float64) | ||
686 | + return ((bsq<double>*)file)->co_matrix((double*)co, (double*)avg, mask); | ||
687 | + else{ | ||
688 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
689 | + exit(1); | ||
690 | + } | ||
691 | + } | ||
692 | + else if (header.interleave == envi_header::BIL){ | ||
693 | + if (header.data_type == envi_header::float32) | ||
694 | + return ((bil<float>*)file)->co_matrix((float*)co, (float*)avg, mask); | ||
695 | + else if (header.data_type == envi_header::float64) | ||
696 | + return ((bil<double>*)file)->co_matrix((double*)co, (double*)avg, mask); | ||
697 | + else{ | ||
698 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
699 | + exit(1); | ||
700 | + } | ||
701 | + } | ||
702 | + else if (header.interleave == envi_header::BIP){ | ||
703 | + if (header.data_type == envi_header::float32) | ||
704 | + return ((bip<float>*)file)->co_matrix((float*)co, (float*)avg, mask); | ||
705 | + else if (header.data_type == envi_header::float64) | ||
706 | + return ((bip<double>*)file)->co_matrix((double*)co, (double*)avg, mask); | ||
707 | + else{ | ||
708 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
709 | + exit(1); | ||
710 | + } | ||
711 | + } | ||
712 | + return false; | ||
713 | + } | ||
646 | 714 | ||
715 | + //crop specified area the of the original file | ||
716 | + bool crop(std::string outfile,unsigned x0, unsigned y0, unsigned x1, unsigned y1){ | ||
717 | + | ||
718 | + if (header.interleave == envi_header::BSQ){ | ||
719 | + if (header.data_type == envi_header::float32) | ||
720 | + return ((bsq<float>*)file)->crop(outfile, x0, y0, x1, y1); | ||
721 | + else if (header.data_type == envi_header::float64) | ||
722 | + return ((bsq<double>*)file)->crop(outfile, x0, y0, x1, y1); | ||
723 | + else{ | ||
724 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
725 | + exit(1); | ||
726 | + } | ||
727 | + } | ||
728 | + else if (header.interleave == envi_header::BIL){ | ||
729 | + if (header.data_type == envi_header::float32) | ||
730 | + return ((bil<float>*)file)->crop(outfile, x0, y0, x1, y1); | ||
731 | + else if (header.data_type == envi_header::float64) | ||
732 | + return ((bil<double>*)file)->crop(outfile, x0, y0, x1, y1); | ||
733 | + else{ | ||
734 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
735 | + exit(1); | ||
736 | + } | ||
737 | + } | ||
738 | + else if (header.interleave == envi_header::BIP){ | ||
739 | + if (header.data_type == envi_header::float32) | ||
740 | + return ((bip<float>*)file)->crop(outfile, x0, y0, x1, y1); | ||
741 | + else if (header.data_type == envi_header::float64) | ||
742 | + return ((bip<double>*)file)->crop(outfile, x0, y0, x1, y1); | ||
743 | + else{ | ||
744 | + std::cout << "ERROR: unidentified data type" << std::endl; | ||
745 | + exit(1); | ||
746 | + } | ||
747 | + } | ||
748 | + return false; | ||
749 | + } | ||
647 | }; | 750 | }; |
648 | 751 | ||
649 | } //end namespace rts | 752 | } //end namespace rts |