[Resample] CPU versoin added + correlation[subtract] fix

ovoronkov · ovoronkov · commit f89f7b50d5db · 2018-09-13T18:00:05.000+03:00
diff --git a/src/caffe/layers/correlation_layer.cpp b/src/caffe/layers/correlation_layer.cpp
@@ -57,7 +57,7 @@ void CorrelateData(int num, int topwidth, int topheight, int topchannels, int to
                 // Compute correlation
                 for (int top_channel = 0; top_channel < topchannels; top_channel++)
                 {
-                    double sum = 0;
+                    Dtype sum = 0;
 
                     int s2o = (top_channel % neighborhood_grid_width - neighborhood_grid_radius) * stride2;
                     int s2p = (top_channel / neighborhood_grid_width - neighborhood_grid_radius) * stride2;
@@ -94,12 +94,12 @@ void CorrelateData(int num, int topwidth, int topheight, int topchannels, int to
 }
 
 template <typename Dtype>
-void CorrelateDataSubtract(int num, int item, int topwidth, int topheight, int topchannels, int topcount,
+void CorrelateDataSubtract(const int nthreads, int num, int item, int topwidth, int topheight, int topchannels, int topcount,
                            int max_displacement, int neighborhood_grid_radius, int neighborhood_grid_width, int kernel_radius, int stride1, int stride2,
                            int bottomwidth, int bottomheight, int bottomchannels,
                            const Dtype *bottom0, const Dtype *bottom1, Dtype *top)
 {
-    for (int index = 0; index < topcount; index++)
+    for (int index = 0; index < nthreads; index++)
     {
         int x = index % topwidth; //w-pos
         int y = (index / topwidth) % topheight; //h-pos
@@ -130,7 +130,7 @@ void CorrelateDataSubtract(int num, int item, int topwidth, int topheight, int t
                     int idx2 = ((item * bottomheight + y2 + j) * bottomwidth + x2 + i) * bottomchannels + l;
 
                     // Do the correlation:
-                    sum += abs(bottom0[idx1] - bottom1[idx2]);
+                    sum += fabs(bottom0[idx1] - bottom1[idx2]);
                 }
             }
         }
@@ -228,6 +228,9 @@ void CorrelationLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
     const int topcount = top_width_ * top_height_ * top_channels_;
     const int pheight = bheight + 2 * pad_size_;
     const int pwidth = bwidth + 2 * pad_size_;
+    
+    memset(rbot1_->mutable_cpu_data(), 0, sizeof(Dtype) * rbot1_->count());
+    memset(rbot2_->mutable_cpu_data(), 0, sizeof(Dtype) * rbot2_->count());
 
     blob_rearrange_kernel2<Dtype>(rbot1_->mutable_cpu_data(), bottom[0]->cpu_data(), bnum, bchannels, bheight, bwidth, pheight, pwidth, pad_size_);
     blob_rearrange_kernel2<Dtype>(rbot2_->mutable_cpu_data(), bottom[1]->cpu_data(), bnum, bchannels, bheight, bwidth, pheight, pwidth, pad_size_);
@@ -252,8 +255,9 @@ void CorrelationLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
         // CorrelationLayer
         for(int n = 0; n < num; n++) {
             
+            int topThreadCount = topcount;
             CorrelateDataSubtract<Dtype>(
-                num, n, top_width_, top_height_, top_channels_, topcount,
+                topThreadCount, num, n, top_width_, top_height_, top_channels_, topcount,
                 max_displacement_, neighborhood_grid_radius_, neighborhood_grid_width_, kernel_radius_,
                 stride1_, stride2_,
                 width, height, channels,
diff --git a/src/caffe/layers/resample_layer.cpp b/src/caffe/layers/resample_layer.cpp
@@ -10,6 +10,119 @@
 
 namespace caffe {
 
+static float bicubicCoeff(float x_)
+{
+    float x = fabs(x_);
+    if (x <= 1.0f)     return x * x * (1.5f * x - 2.5f) + 1.0f;
+    else if (x < 2.0f) return x * (x * (-0.5f * x + 2.5f) - 4.0f) + 2.0f;
+    else               return 0.0f;
+}
+
+static float boxCoeff(float x)
+{
+    if (-0.5 <= x  && x<0.5) return 1.0;
+    return 0;
+}
+
+static float triangleCoeff(float x)
+{
+    if (-1<=x && x<0) return x+1;
+    if (0<=x && x<=1) return 1-x;
+    return 0;
+}
+
+#define FILTER_BICUBIC 0
+#define FILTER_BOX 1
+#define FILTER_TRIANGLE 2
+
+template <typename Dtype>
+void InterpolationKernel(
+                         const int nthreads,
+                         const int in_channelsize,
+                         const int out_channelsize,
+                         const Dtype* in_ptr,
+                         const int in_width,
+                         const int in_height,
+                         const float fx,
+                         const float fy,
+                         Dtype* out_ptr,
+                         const int out_width,
+                         const int out_height,
+                         int filter_type,
+                         int kernel_width,
+                         const bool antialias)
+{
+    for (int index = 0; index < nthreads; ++index)
+    {
+        int c = index / out_channelsize;
+        int x_out = (index % out_channelsize) % out_width;
+        int y_out = (index % out_channelsize) / out_width;
+
+        float x_in = x_out * fx + fy / 2.0f - 0.5f;
+        float y_in = y_out * fy + fx / 2.0f - 0.5f;
+
+        int x_in_round = round(x_in);
+        int y_in_round = round(y_in);
+
+        Dtype sum = 0;
+        Dtype wsum = 0;
+
+        float ax = 1.0f / (antialias ? fx : 1.0f);
+        float ay = 1.0f / (antialias ? fy : 1.0f);
+        int rx = (fx < 1.0f) ? 2 : ceil(float(kernel_width) / ax);
+        int ry = (fy < 1.0f) ? 2 : ceil(float(kernel_width) / ay);
+
+        for (int y = y_in_round - ry; y <= y_in_round + ry; y++)
+            for (int x = x_in_round - rx; x <= x_in_round + rx; x++)
+            {
+                if (y < 0 || x < 0) continue;
+                if (y >= in_height || x >= in_width) continue;
+
+                float dx = x_in - x;
+                float dy = y_in - y;
+
+                float w;
+                if (filter_type == FILTER_BICUBIC) w = ax * bicubicCoeff(ax * dx) * ay * bicubicCoeff(ay * dy);
+                else if (filter_type == FILTER_BOX) w = ax * boxCoeff(ax * dx) * ay * boxCoeff(ay * dy);
+                else w = ax * triangleCoeff(ax * dx) * ay * triangleCoeff(ay * dy);
+                sum += w * in_ptr[c * in_channelsize + y * in_width + x];
+                wsum += w;
+            }
+
+        out_ptr[index] = (!wsum) ? 0 : (sum / wsum);
+    }
+}
+
+template <typename Dtype>
+void NearestNeighborKernel(
+                           const int nthreads,
+                           const int in_channelsize,
+                           const int out_channelsize,
+                           const Dtype* in_ptr,
+                           const int in_width,
+                           const int in_height,
+                           const float fx,
+                           const float fy,
+                           Dtype* out_ptr,
+                           const int out_width,
+                           const int out_height)
+{
+    for (int index = 0; index < nthreads; ++index)
+    {
+        int c = index / out_channelsize;
+        int x_out = (index % out_channelsize) % out_width;
+        int y_out = (index % out_channelsize) / out_width;
+
+        float x_in = x_out * fx + fy / 2.0f - 0.5f;
+        float y_in = y_out * fy + fx / 2.0f - 0.5f;
+
+        int x_in_round = round(x_in);
+        int y_in_round = round(y_in);
+
+        out_ptr[index] = in_ptr[c * in_channelsize + y_in_round * in_width + x_in_round];
+    }
+}
+
 template <typename Dtype>
 void ResampleLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top) {
@@ -56,9 +169,82 @@ void ResampleLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
 
 template <typename Dtype>
 void ResampleLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
-      const vector<Blob<Dtype>*>& top)
+                                       const vector<Blob<Dtype>*>& top)
 {
-	NOT_IMPLEMENTED;
+
+    Dtype* top_data = top[0]->mutable_cpu_data(); // dest
+    int topwidth = top[0]->width();
+    int topheight = top[0]->height();
+    int topchannels = top[0]->channels();
+//    int topcount = top[0]->count();
+
+    Dtype* bottom_data = bottom[0]->mutable_cpu_data(); // source
+    int bottomnum = (bottom)[0]->num();
+    int bottomchannels = (bottom)[0]->channels();
+    int bottomwidth = (bottom)[0]->width();
+    int bottomheight = (bottom)[0]->height();
+//    int bottomcount = (bottom)[0]->count();
+
+    CHECK_EQ(topchannels, bottomchannels) << "ResampleLayer top channel count must match bottom channel count";
+
+    float fx = float(bottomwidth) / float(topwidth);
+    float fy = float(bottomheight) / float(topheight);
+
+    //int botsize = bottomwidth*bottomheight*bottomchannels*bottomnum;
+    int topsize = topwidth * topheight * topchannels*bottomnum;
+    int topchannelsize = topwidth*topheight;
+    int botchannelsize = bottomwidth*bottomheight;
+
+    if (this->layer_param().resample_param().type() == ResampleParameter_ResampleType_NEAREST)
+    {
+        NearestNeighborKernel<Dtype>(
+                topsize,
+                botchannelsize,
+                topchannelsize,
+                (Dtype*) bottom_data,
+                bottomwidth,
+                bottomheight,
+                fx,
+                fy,
+                (Dtype*) top_data,
+                topwidth,
+                topheight
+                );
+    }
+    else if (this->layer_param().resample_param().type() == ResampleParameter_ResampleType_CUBIC || this->layer_param().resample_param().type() == ResampleParameter_ResampleType_LINEAR)
+    {
+        int filter_type;
+        if (this->layer_param().resample_param().type() == ResampleParameter_ResampleType_CUBIC)
+            filter_type = FILTER_BICUBIC;
+        else if (this->layer_param().resample_param().type() == ResampleParameter_ResampleType_LINEAR)
+            filter_type = FILTER_TRIANGLE;
+
+        bool isDownsample = (fx > 1) || (fy > 1);
+        bool antialias = isDownsample && this->layer_param_.resample_param().antialias();
+
+        int kernel_width;
+        if (filter_type == FILTER_BICUBIC) kernel_width = 4;
+        else if (filter_type == FILTER_BOX) kernel_width = 1;
+        else kernel_width = 2;
+
+        InterpolationKernel<Dtype>(
+                topsize,
+                botchannelsize,
+                topchannelsize,
+                (Dtype*) bottom_data,
+                bottomwidth,
+                bottomheight,
+                fx,
+                fy,
+                (Dtype*) top_data,
+                topwidth,
+                topheight,
+                filter_type,
+                kernel_width,
+                antialias);
+    }
+    else
+        LOG(FATAL) << "unsupported downsampling type";
 }
 
 template <typename Dtype>
