├── .gitignore
├── README.md
├── debug
    ├── OpenCV_test
    └── Prb.csv
├── imgs
    ├── Bilinear_example.png
    ├── Bilnear_dst.bmp
    ├── GBTF_dst.bmp
    ├── GBTF_example.png
    └── bayer_pattern_img.bmp
└── src
    ├── GBTF.cpp
    ├── GBTF.hpp
    └── main.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | *.DS_Store


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | I have introduced the basic color interpolation algorithm in my "Basic_Color_Interpolation" reop. But simple color interpolation method will cause a lot of artifacts, such as false color, decreasing resolution, aliasing... <br />
 2 | These artifacts usually due to we simply interpolate the missing pixel value with its neighbor pixel value and forget to consider the relationship of R,G and B. <br />
 3 | We should consider the directional color difference or gradients of every pixel and using this correction to interpolate the missing color value. <br />
 4 | 
 5 | This repo is the implementing of "Gradient Based Threshold Free CFA Interpolation" algorithm. It first interpolates the green channels of image using directional weighting by estimating the color difference and gradients information of image.<br />
 6 | Then it interpolates the Red and Blue channels by a filter comes from "Spatially adaptive color filter array interpolation for noiseless and noisy data" paper and bilinear method.<br />
 7 | <br />
 8 | This is the bayer image from my "Basic_Color_Interpolation" reop which the bayer pattern is GRBG.<br />
 9 | ![alt text](https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/master/imgs/bayer_pattern_img.bmp)
10 | 
11 | This is the result from bilinear method which we can see a lot of false color effect.<br />
12 | ![alt text](https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/master/imgs/Bilinear_example.png)
13 | 
14 | This is the result from GBTF method and it reduces the artifacts very effectively.<br />
15 | ![alt text](https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/master/imgs/GBTF_example.png)
16 | <br />
17 | <br />
18 | reference:<br />
19 | 1.https://ieeexplore.ieee.org/document/5654327 (GRADIENT BASED THRESHOLD FREE COLOR FILTER ARRAY INTERPOLATION)<br />
20 | 2.https://onlinelibrary.wiley.com/doi/abs/10.1002/ima.20109 (Spatially adaptive color filter array interpolation for noiseless and noisy data)<br />


--------------------------------------------------------------------------------
/debug/OpenCV_test:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/8a3faa7a57a181a4c7bee99ab365198dff293f71/debug/OpenCV_test


--------------------------------------------------------------------------------
/debug/Prb.csv:
--------------------------------------------------------------------------------
1 | 0,0,-0.0313,0,-0.0313,0,0
2 | 0,0,0,0,0,0,0
3 | -0.0313,0,0.3125,0,0.3125,0,-0.0313
4 | 0,0,0,0,0,0,0
5 | -0.0313,0,0.3125,0,0.3125,0,-0.0313
6 | 0,0,0,0,0,0,0
7 | 0,0,-0.0313,0,-0.0313,0,0


--------------------------------------------------------------------------------
/imgs/Bilinear_example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/8a3faa7a57a181a4c7bee99ab365198dff293f71/imgs/Bilinear_example.png


--------------------------------------------------------------------------------
/imgs/Bilnear_dst.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/8a3faa7a57a181a4c7bee99ab365198dff293f71/imgs/Bilnear_dst.bmp


--------------------------------------------------------------------------------
/imgs/GBTF_dst.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/8a3faa7a57a181a4c7bee99ab365198dff293f71/imgs/GBTF_dst.bmp


--------------------------------------------------------------------------------
/imgs/GBTF_example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/8a3faa7a57a181a4c7bee99ab365198dff293f71/imgs/GBTF_example.png


--------------------------------------------------------------------------------
/imgs/bayer_pattern_img.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayXie29/GBTF_Color_Interpolation/8a3faa7a57a181a4c7bee99ab365198dff293f71/imgs/bayer_pattern_img.bmp


--------------------------------------------------------------------------------
/src/GBTF.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "GBTF.hpp"
  3 | #include <opencv2/opencv.hpp>
  4 | #include <fstream>
  5 | 
  6 | 
  7 | void to_SingleChannel(cv::Mat &src,cv::Mat &dst)
  8 | {
  9 |     dst = cv::Mat(src.size(),CV_8UC1,cv::Scalar(0));
 10 |     for(int i=0;i<src.rows;++i)
 11 |     {
 12 |         uchar *sptr = src.ptr<uchar>(i);
 13 |         uchar *dptr = dst.ptr<uchar>(i);
 14 |         for(int j=0;j<src.cols;++j)
 15 |         {
 16 |             int baseJ = j*3;
 17 |             dptr[j] = sptr[baseJ] + sptr[baseJ+1] + sptr[baseJ+2];
 18 |         }
 19 |     }
 20 | }
 21 | 
 22 | void CalHVcolordiff(cv::Mat &src1ch,cv::Mat &HCDMap,cv::Mat &VCDMap)
 23 | {
 24 |     float vhkenel[5] = {-0.25,0.5,0.5,0.5,-0.25};
 25 |     
 26 |     cv::Mat HK(1,5,CV_32F,vhkenel);
 27 |     cv::Mat VK(5,1,CV_32F,vhkenel);
 28 |     src1ch.convertTo(src1ch, CV_32F);
 29 |     HCDMap = cv::Mat(src1ch.size(),CV_32F);
 30 |     VCDMap = cv::Mat(src1ch.size(),CV_32F);
 31 |     
 32 |     cv::filter2D(src1ch, HCDMap, -1, HK);
 33 |     cv::filter2D(src1ch, VCDMap, -1, VK);
 34 |     
 35 |     float tempArr[2][2] = {{1,-1},{-1,1}};
 36 |     cv::Mat tempMat(2,2,CV_32F,tempArr);
 37 |     cv::copyMakeBorder(tempMat, tempMat, 0, src1ch.rows-2, 0, src1ch.cols-2, cv::BORDER_REFLECT_101);
 38 |     
 39 |     src1ch = src1ch.mul(tempMat);
 40 |     tempMat *= -1;
 41 |     HCDMap = HCDMap.mul(tempMat);
 42 |     VCDMap = VCDMap.mul(tempMat);
 43 |     
 44 |     cv::add(HCDMap,src1ch,HCDMap);
 45 |     cv::add(VCDMap,src1ch,VCDMap);
 46 | }
 47 | 
 48 | void CalHVcolordiffGrad(cv::Mat &HCDMap,cv::Mat &VCDMap,cv::Mat &HGradientMap, cv::Mat &VGradientMap)
 49 | {
 50 |     float vhkenel2[3] = {-1,0,1};
 51 |     cv::Mat HK(1,3,CV_32F,vhkenel2);
 52 |     cv::Mat VK(3,1,CV_32F,vhkenel2);
 53 |     
 54 |     cv::filter2D(HCDMap, HGradientMap, -1, HK);
 55 |     cv::filter2D(VCDMap, VGradientMap, -1, VK);
 56 |     HGradientMap = cv::abs(HGradientMap);
 57 |     VGradientMap = cv::abs(VGradientMap);
 58 | }
 59 | 
 60 | void CalWeightingTable(std::vector<float> &WeightTable,cv::Mat &HGradientMap, cv::Mat &VGradientMap)
 61 | {
 62 |     int i,j,k;
 63 |     int NSEW[4][2] = { {-4,-2}, {0,-2} , {-2,-4}, {-2,0} };
 64 |     for (i = 5, k = 0; i < HGradientMap.rows - 5; ++i)
 65 |     {
 66 |         j = i%2? 6 : 5;
 67 |         for (; j < HGradientMap.cols - 5; j+=2)
 68 |         {
 69 |             //R & B pixel location
 70 |             for(int dir=0;dir<4;++dir,++k)
 71 |             {
 72 |                 for(int a=i+NSEW[dir][0] ; a<=i+NSEW[dir][0]+4 ; ++a)
 73 |                 {
 74 |                     float *VGMPtr = VGradientMap.ptr<float>(a);
 75 |                     float *HGMPtr = HGradientMap.ptr<float>(a);
 76 |                     for(int b=j+NSEW[dir][1]; b<=j+NSEW[dir][1]+4 ;++b)
 77 |                     {
 78 |                         if(dir<2) { WeightTable[k] += VGMPtr[b]; }
 79 |                         else { WeightTable[k] += HGMPtr[b]; }
 80 |                     }
 81 |                 }
 82 |                 if(WeightTable[k]) { WeightTable[k] = 1.0 / (WeightTable[k]*WeightTable[k]); }
 83 |             }
 84 |         }
 85 |     }
 86 | }
 87 | 
 88 | void PrbMat(cv::Mat &Prb)
 89 | {
 90 |     std::fstream infile("./Prb.csv", std::ios::in);
 91 |     if (!infile)
 92 |     {
 93 |         std::cerr << "Open the file error" << std::endl;
 94 |         exit(EXIT_FAILURE);
 95 |     }
 96 |     std::string line;
 97 |     int i = 0, j = 0;
 98 |     while (getline(infile, line))
 99 |     {
100 |         float *PrbP = Prb.ptr<float>(i++);
101 |         j = 0;
102 |         std::istringstream templine(line);
103 |         std::string data;
104 |         while (getline(templine, data, ',')) { PrbP[j++] = atof(data.c_str()); }
105 |     }
106 |     infile.close();
107 | }
108 | 
109 | void GBTF_CFAInterpolation(cv::Mat &Bayer,cv::Mat &Dst,int BayerPatternFlag = 0)
110 | {
111 |     cv::Mat Src = Bayer.clone();
112 |     if (BayerPatternFlag == 1) { cv::copyMakeBorder(Src, Src, 0, 0, 1, 1, cv::BORDER_REFLECT_101); }
113 |     else if (BayerPatternFlag == 2) { cv::copyMakeBorder(Src, Src, 1, 1, 1, 1, cv::BORDER_REFLECT_101); }
114 |     else if (BayerPatternFlag == 3) { cv::copyMakeBorder(Src, Src, 1, 1, 0, 0, cv::BORDER_REFLECT_101); }
115 |     else if (BayerPatternFlag)
116 |     {
117 |         std::cerr << "Please select the right Bayer Pattern ,  default(0) ->GRBG , 1->RGGB , 2->GBRG , 3->BGGR" << std::endl;
118 |         return;
119 |     }
120 |     
121 |     Dst = Src.clone();
122 |     cv::Mat src1ch;
123 |     to_SingleChannel(Src, src1ch);
124 |     int i,j,k;
125 |     int channels = 3;
126 |     int width = Src.cols, height = Src.rows;
127 |     
128 |     
129 |     //Calculate Horizontal and vertical color difference maps
130 |     cv::Mat HCDMap,VCDMap;
131 |     CalHVcolordiff(src1ch, HCDMap, VCDMap);
132 |     
133 |     //Calculate Horizontal and vertical color difference gradients
134 |     cv::copyMakeBorder(HCDMap, HCDMap, 5, 5, 5, 5, cv::BORDER_CONSTANT, cv::Scalar(0));
135 |     cv::copyMakeBorder(VCDMap, VCDMap, 5, 5, 5, 5, cv::BORDER_CONSTANT, cv::Scalar(0));
136 |     
137 |     cv::Mat HGradientMap,VGradientMap;
138 |     CalHVcolordiffGrad(HCDMap, VCDMap, HGradientMap, VGradientMap);
139 |     
140 |     //weight table calculation
141 |     int WeightTableSize = height*(int)(width / 2);
142 |     std::vector<float> WeightTable(WeightTableSize * 4);
143 |     CalWeightingTable(WeightTable, HGradientMap, VGradientMap);
144 |     
145 |     //Target Pixel Gradient Map
146 |     cv::Mat TPdiff(height, width, CV_32FC1, cv::Scalar(0));
147 |     
148 |     //Interpolate green value at blue and red pixel location
149 |     for(i=5, k=0; i<HCDMap.rows-5;++i)
150 |     {
151 |         j = i%2? 6 : 5;
152 |         float *TPPtr = TPdiff.ptr<float>(i-5);
153 |         uchar *DstPtr = Dst.ptr<uchar>(i-5);
154 |         for(;j<HCDMap.cols-5; j+=2, k+=4 )
155 |         {
156 |             float N = WeightTable[k], S = WeightTable[k+1], E = WeightTable[k+2] , W = WeightTable[k+3] ;
157 |             float totalWeight = N+S+E+W;
158 |             if(!totalWeight) { TPPtr[j-5] = 0; }
159 |             else
160 |             {
161 |                 float NSKernel[9][9] = { 0 };
162 |                 NSKernel[4][4] = (N+S)*0.2;
163 |                 NSKernel[0][4] = NSKernel[1][4] = NSKernel[2][4] = NSKernel[3][4] = 0.2*N;
164 |                 NSKernel[5][4] = NSKernel[6][4] = NSKernel[7][4] = NSKernel[8][4] = 0.2*S;
165 |      
166 |                 float WEKernel[9][9] = { 0 };
167 |                 WEKernel[4][4] = (W+E)*0.2;
168 |                 WEKernel[4][0] = WEKernel[4][1] = WEKernel[4][2] = WEKernel[4][3] = E*0.2;
169 |                 WEKernel[4][5] = WEKernel[4][6] = WEKernel[4][7] = WEKernel[4][8] = W*0.2;
170 |      
171 |                 cv::Mat Vroi = VCDMap(cv::Rect(j-4,i-4,9,9));
172 |                 cv::Mat Hroi = HCDMap(cv::Rect(j-4,i-4,9,9));
173 |                 
174 |                 for(int idx=0;idx<9;++idx)
175 |                 {
176 |                     TPPtr[j-5] += WEKernel[4][idx] * Hroi.at<float>(4,idx) + NSKernel[idx][4] * Vroi.at<float>(idx,4);
177 |                 }
178 |                 TPPtr[j-5] /= totalWeight;
179 |             }
180 |             DstPtr[(j-5)*channels+1]= cv::saturate_cast<uchar>(DstPtr[(j-5)*channels+i%2+!(j%2)] + TPPtr[j-5]);
181 |         }
182 |     }
183 |     
184 |     // Prb.csv reading
185 |     cv::Mat Prb(7, 7, CV_32FC1, cv::Scalar(0));
186 |     PrbMat(Prb);
187 |     
188 |     cv::copyMakeBorder(TPdiff, TPdiff, 3, 3, 3, 3, cv::BORDER_CONSTANT, cv::Scalar(0));
189 |     
190 |     //Interpolate R,B channel in blue and red pixel locations
191 |     for(i=3;i<TPdiff.rows-3;++i)
192 |     {
193 |         j = i%2?4:3;
194 |         uchar *DPtr = Dst.ptr<uchar>(i-3);
195 |         for(;j<TPdiff.cols-3;j+=2)
196 |         {
197 |             float sum = 0;
198 |             cv::Mat TProi = TPdiff(cv::Rect(j-3,i-3,7,7));
199 |             
200 |             for(int x=0;x<7;x+=2)
201 |             {
202 |                 float *PrbPtr = Prb.ptr<float>(x);
203 |                 float *TProiPtr = TProi.ptr<float>(x);
204 |                 for(int y=0;y<7;y+=2) { sum += PrbPtr[y]* TProiPtr[y]; }
205 |             }
206 |             DPtr[(j-3)*channels + !(i%2)+j%2 ] = cv::saturate_cast<uchar>(DPtr[(j-3)*channels + 1 ] - sum);
207 |         }
208 |     }
209 |     
210 |     
211 |     //Interpolate R,B channel on G pixel
212 |     int NSEW[4][2] = { {-1,0} , {1,0}, {0,-1}, {0,1} };
213 |     for(i=0;i<height;++i)
214 |     {
215 |         uchar *DstPtr = Dst.ptr<uchar>(i);
216 |         j = i%2?1:0;
217 |         for(;j<width;j+=2)
218 |         {
219 |             uchar G = DstPtr[j*channels+1];
220 |             float GBdiff=0,GRdiff=0;
221 |             for(int dir = 0; dir<4;++dir)
222 |             {
223 |                 int x = i+NSEW[dir][0];
224 |                 int y = j+NSEW[dir][1];
225 |                 if(x>=0 && x<height && y>=0 && y<width)
226 |                 {
227 |                     GBdiff += Dst.at<cv::Vec3b>(x,y)[1] - Dst.at<cv::Vec3b>(x,y)[0];
228 |                     GRdiff += Dst.at<cv::Vec3b>(x,y)[1] - Dst.at<cv::Vec3b>(x,y)[2];
229 |                 }
230 |             }
231 |             DstPtr[j*channels+2] = cv::saturate_cast<uchar>(G - GRdiff/4);
232 |             DstPtr[j*channels] = cv::saturate_cast<uchar>(G-GBdiff/4);
233 |         }
234 |     }
235 |     
236 |     if (BayerPatternFlag == 1){ Dst = Dst(cv::Rect(1, 0, width - 2, height));   }
237 |     else if (BayerPatternFlag == 2) {   Dst = Dst(cv::Rect(1, 1, width - 2, height - 2)); }
238 |     else if (BayerPatternFlag == 3) {   Dst = Dst(cv::Rect(0, 1, width, height - 2)); }
239 | }
240 | 
241 | 


--------------------------------------------------------------------------------
/src/GBTF.hpp:
--------------------------------------------------------------------------------
1 | 
2 | #ifndef GBTF_hpp
3 | #define GBTF_hpp
4 | 
5 | #include <opencv2/opencv.hpp>
6 | void GBTF_CFAInterpolation(cv::Mat &Bayer,cv::Mat &Dst,int BayerPatternFlag);
7 | 
8 | #endif /* GBTF_hpp */
9 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <opencv2/opencv.hpp>
 3 | /****************************************************/
 4 | #include "GBTF.hpp"
 5 | using namespace std;
 6 | 
 7 | int main(int argc, const char * argv[]) {
 8 |         
 9 |     cv::Mat img = cv::imread("./imgs/bayer_pattern_img.bmp",cv::IMREAD_COLOR);
10 |     cv::Mat dst;
11 |     
12 |     GBTF_CFAInterpolation(img, dst, 0);
13 |     
14 |     
15 |     cv::imshow("bayer_pattern_img.bmp",img);
16 |     cv::imshow("GBTF_dst.bmp",dst);
17 | 
18 |     cv::waitKey(0);
19 |     cv::destroyAllWindows();
20 |     cv::imwrite("GBTF_dst.bmp",dst);
21 | }
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------