From 7f239efdc0820f5707d923a7ce873b0bec975bfb Mon Sep 17 00:00:00 2001
From: Davide Sapienza <sapienza.dav@gmail.com>
Date: Tue, 21 Jan 2020 12:50:18 +0100
Subject: [PATCH] Centernet: fix pooling problem, add centrnet demo

Signed-off-by: Micaela Verucchi <micaelaverucchi@gmail.com>
Signed-off-by: Davide Sapienza <sapienza.dav@gmail.com>
---
 CMakeLists.txt                                |   5 +-
 demo/demo/demo_centernet.cpp                  |  88 +++
 demo/demo/{demo.cpp => demo_yolo3.cpp}        |  50 +-
 include/tkDNN/CenternetDetection.h            |   3 +
 include/tkDNN/pluginsRT/ActivationSigmoidRT.h |  60 ++
 include/tkDNN/pluginsRT/DeformableConvRT.h    |   1 -
 src/CenternetDetection.cpp                    | 251 ++-----
 src/NetworkRT.cpp                             |   3 +-
 src/Pooling.cpp                               |   4 +-
 src/kernels/activation_sigmoid.cu             |  16 +-
 src/sorting.cu                                |   2 +-
 tests/resnet101_cnet/resnet101_cnet.cpp       | 681 +-----------------
 12 files changed, 229 insertions(+), 935 deletions(-)
 create mode 100644 demo/demo/demo_centernet.cpp
 rename demo/demo/{demo.cpp => demo_yolo3.cpp} (57%)
 create mode 100644 include/tkDNN/pluginsRT/ActivationSigmoidRT.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7af66c0..8b847d0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -105,9 +105,12 @@ target_link_libraries(test_resnet101_cnet tkDNN)
 add_executable(test_rtinference tests/test_rtinference/rtinference.cpp)
 target_link_libraries(test_rtinference tkDNN)
 
-add_executable(yolo3_demo demo/demo/demo.cpp)
+add_executable(yolo3_demo demo/demo/demo_yolo3.cpp)
 target_link_libraries(yolo3_demo tkDNN)
 
+add_executable(centernet_demo demo/demo/demo_centernet.cpp)
+target_link_libraries(centernet_demo tkDNN)
+
 
 #-------------------------------------------------------------------------------
 # Install
diff --git a/demo/demo/demo_centernet.cpp b/demo/demo/demo_centernet.cpp
new file mode 100644
index 0000000..0f9c86e
--- /dev/null
+++ b/demo/demo/demo_centernet.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <signal.h>
+#include <stdlib.h>     /* srand, rand */
+#include <unistd.h>
+#include <mutex>
+#include "utils.h"
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include "CenternetDetection.h"
+
+bool 			gRun;
+bool SAVE_RESULT = false;
+
+void sig_handler(int signo) {
+    std::cout<<"request gateway stop\n";
+    gRun = false;
+}
+
+int main(int argc, char *argv[]) {
+
+    std::cout<<"detection\n";
+    signal(SIGINT, sig_handler);
+
+
+    char *net = "resnet101_cnet.rt";
+    if(argc > 1)
+        net = argv[1]; 
+    char *input = "../demo/yolo_test.mp4";
+    if(argc > 2)
+        input = argv[2]; 
+
+    tk::dnn::CenternetDetection cnet;
+    cnet.init(net);
+
+    gRun = true;
+
+    cv::VideoCapture cap(input);
+    if(!cap.isOpened())
+        gRun = false; 
+    else
+        std::cout<<"camera started\n";
+
+
+    cv::VideoWriter resultVideo;
+    if(SAVE_RESULT) {
+        int w = cap.get(cv::CAP_PROP_FRAME_WIDTH);
+        int h = cap.get(cv::CAP_PROP_FRAME_HEIGHT);
+        resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','P','4','V'), 30, cv::Size(w, h));
+    }
+
+    cv::Mat frame;
+    cv::Mat dnn_input;
+    cv::namedWindow("detection", cv::WINDOW_NORMAL);
+    
+    while(gRun) {
+        cap >> frame; 
+        if(!frame.data) {
+            break;
+        }  
+ 
+        // this will be resized to the net format
+        dnn_input = frame.clone();
+        // TODO: async infer
+        cnet.update(dnn_input);
+        // draw dets
+        frame = cnet.draw(dnn_input);
+                
+        cv::imshow("detection", frame);
+        cv::waitKey(1);
+        if(SAVE_RESULT)
+            resultVideo << frame;
+    }
+
+    std::cout<<"detection end\n";   
+
+
+    std::cout<<COL_GREENB<<"\n\nTime stats:\n";
+    std::cout<<"Min: "<<*std::min_element(cnet.stats.begin(), cnet.stats.end())<<" ms\n";    
+    std::cout<<"Max: "<<*std::max_element(cnet.stats.begin(), cnet.stats.end())<<" ms\n";    
+    double mean = 0; for(int i=0; i<cnet.stats.size(); i++) mean += cnet.stats[i]; mean /= cnet.stats.size();
+    std::cout<<"Avg: "<<mean<<" ms\n"<<COL_END;    
+    return 0;
+}
+
diff --git a/demo/demo/demo.cpp b/demo/demo/demo_yolo3.cpp
similarity index 57%
rename from demo/demo/demo.cpp
rename to demo/demo/demo_yolo3.cpp
index ce51cdb..2b34386 100644
--- a/demo/demo/demo.cpp
+++ b/demo/demo/demo_yolo3.cpp
@@ -10,8 +10,7 @@
 #include <opencv2/videoio.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
 
-// #include "Yolo3Detection.h"
-#include "CenternetDetection.h"
+#include "Yolo3Detection.h"
 
 bool 			gRun;
 bool SAVE_RESULT = false;
@@ -27,15 +26,14 @@ int main(int argc, char *argv[]) {
     signal(SIGINT, sig_handler);
 
 
-    char *net = "resnet101_cnet.rt";
+    char *net = "yolo3_berkeley.rt";
     if(argc > 1)
         net = argv[1]; 
     char *input = "../demo/yolo_test.mp4";
     if(argc > 2)
         input = argv[2]; 
 
-    // tk::dnn::Yolo3Detection yolo;
-    tk::dnn::CenternetDetection yolo;
+    tk::dnn::Yolo3Detection yolo;
     yolo.init(net);
 
     gRun = true;
@@ -69,30 +67,28 @@ int main(int argc, char *argv[]) {
         // TODO: async infer
         yolo.update(dnn_input);
 
-        frame = yolo.draw(dnn_input);
-        // // draw dets
-        // for(int i=0; i<yolo.detected.size(); i++) {
-        //     tk::dnn::box b = yolo.detected[i];
-        //     int x0   				= b.x;
-        //     int x1   				= b.x + b.w;
-        //     int y0   				= b.y;
-        //     int y1   				= b.y + b.h;
-        //     std::string det_class 	= yolo.coco_class_name[b.cl];
-        //     // yolo.getYoloLayer()->classesNames[b.cl];
-        //     float prob 				= b.prob;
+        // draw dets
+        for(int i=0; i<yolo.detected.size(); i++) {
+            tk::dnn::box b = yolo.detected[i];
+            int x0   				= b.x;
+            int x1   				= b.x + b.w;
+            int y0   				= b.y;
+            int y1   				= b.y + b.h;
+            std::string det_class 	= yolo.getYoloLayer()->classesNames[b.cl];
+            float prob 				= b.prob;
 
-        //     // std::cout<<det_class<<" ("<<prob<<"): "<<x0<<" "<<y0<<" "<<x1<<" "<<y1<<"\n";
-		// 	// draw rectangle
-        //     cv::rectangle(frame, cv::Point(x0, y0), cv::Point(x1, y1), yolo.colors[b.cl], 2); 
+            // std::cout<<det_class<<" ("<<prob<<"): "<<x0<<" "<<y0<<" "<<x1<<" "<<y1<<"\n";
+			// draw rectangle
+            cv::rectangle(frame, cv::Point(x0, y0), cv::Point(x1, y1), yolo.colors[b.cl], 2); 
 
-	    //     // draw label
-        //     int baseline = 0;
-        //     float fontScale = 0.5;
-        //     int thickness = 2;
-        //     cv::Size textSize = getTextSize(det_class, cv::FONT_HERSHEY_SIMPLEX, fontScale, thickness, &baseline);
-        //     cv::rectangle(frame, cv::Point(x0, y0), cv::Point((x0 + textSize.width - 2), (y0 - textSize.height - 2)), yolo.colors[b.cl], -1);                      
-        //     cv::putText(frame, det_class, cv::Point(x0, (y0 - (baseline / 2))), cv::FONT_HERSHEY_SIMPLEX, fontScale, cv::Scalar(255, 255, 255), thickness);
-        // }
+	        // draw label
+            int baseline = 0;
+            float fontScale = 0.5;
+            int thickness = 2;
+            cv::Size textSize = getTextSize(det_class, cv::FONT_HERSHEY_SIMPLEX, fontScale, thickness, &baseline);
+            cv::rectangle(frame, cv::Point(x0, y0), cv::Point((x0 + textSize.width - 2), (y0 - textSize.height - 2)), yolo.colors[b.cl], -1);                      
+            cv::putText(frame, det_class, cv::Point(x0, (y0 - (baseline / 2))), cv::FONT_HERSHEY_SIMPLEX, fontScale, cv::Scalar(255, 255, 255), thickness);
+        }
         
         cv::imshow("detection", frame);
         cv::waitKey(1);
diff --git a/include/tkDNN/CenternetDetection.h b/include/tkDNN/CenternetDetection.h
index 8071112..46af73b 100644
--- a/include/tkDNN/CenternetDetection.h
+++ b/include/tkDNN/CenternetDetection.h
@@ -93,6 +93,9 @@ class CenternetDetection {
         // draw
         std::vector<std::string> coco_class_name;
 
+        // keep track of inference times (ms)
+        std::vector<double> stats;
+        
         CenternetDetection() {}
 
         virtual ~CenternetDetection() {}
diff --git a/include/tkDNN/pluginsRT/ActivationSigmoidRT.h b/include/tkDNN/pluginsRT/ActivationSigmoidRT.h
new file mode 100644
index 0000000..4435f08
--- /dev/null
+++ b/include/tkDNN/pluginsRT/ActivationSigmoidRT.h
@@ -0,0 +1,60 @@
+#include<cassert>
+#include "../kernels.h"
+
+class ActivationSigmoidRT : public IPlugin {
+
+public:
+	ActivationSigmoidRT() {
+
+
+	}
+
+	~ActivationSigmoidRT(){
+
+	}
+
+	int getNbOutputs() const override {
+		return 1;
+	}
+
+	Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override {
+		return inputs[0];
+	}
+
+	void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override {
+		size = 1;
+		for(int i=0; i<outputDims[0].nbDims; i++)
+			size *= outputDims[0].d[i];
+	}
+
+	int initialize() override {
+
+		return 0;
+	}
+
+	virtual void terminate() override {
+	}
+
+	virtual size_t getWorkspaceSize(int maxBatchSize) const override {
+		return 0;
+	}
+
+	virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override {
+
+		activationSIGMOIDForward((dnnType*)reinterpret_cast<const dnnType*>(inputs[0]), 
+											reinterpret_cast<dnnType*>(outputs[0]), size, stream);
+		return 0;
+	}
+
+
+	virtual size_t getSerializationSize() override {
+		return 1*sizeof(int);
+	}
+
+	virtual void serialize(void* buffer) override {
+		char *buf = reinterpret_cast<char*>(buffer);
+		tk::dnn::writeBUF(buf, size);
+	}
+
+	int size;
+};
diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h
index b236095..dca1020 100644
--- a/include/tkDNN/pluginsRT/DeformableConvRT.h
+++ b/include/tkDNN/pluginsRT/DeformableConvRT.h
@@ -90,7 +90,6 @@ public:
 	}
 
 	virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override {
-std::cout<<"LOL\n";
 		dnnType *srcData = (dnnType*)reinterpret_cast<const dnnType*>(inputs[0]);
 		dnnType *output_conv = (dnnType*)reinterpret_cast<const dnnType*>(inputs[1]);
 
diff --git a/src/CenternetDetection.cpp b/src/CenternetDetection.cpp
index 59bf827..fbc9832 100644
--- a/src/CenternetDetection.cpp
+++ b/src/CenternetDetection.cpp
@@ -229,58 +229,50 @@ void CenternetDetection::update(cv::Mat &imageORIG) {
     src.at<float>(2,1)=src.at<float>(1,1) + (src.at<float>(0,0)-src.at<float>(1,0) );
     dst.at<float>(2,0)=dst.at<float>(1,0) + (-dst.at<float>(0,1)+dst.at<float>(1,1) );
     dst.at<float>(2,1)=dst.at<float>(1,1) + (dst.at<float>(0,0)-dst.at<float>(1,0) );
-    // std::cout<<"src: "<<src<<std::endl;
-    // std::cout<<"dst: "<<dst<<std::endl;
+    
     cv::Mat trans = cv::getAffineTransform( src, dst );
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME getAffinetr : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME gett affine trans: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
+    
+
     resize(imageORIG, imageF, cv::Size(new_width, new_height));
     sz = imageF.size();
     std::cout<<"size: "<<sz.height<<" "<<sz.width<<" - "<<std::endl;
     end_t = std::chrono::steady_clock::now();
     std::cout << " TIME resize: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
-    cv::warpAffine(imageF, imageF, trans, cv::Size(inp_width, inp_height), cv::INTER_LINEAR );
     
+
+    cv::warpAffine(imageF, imageF, trans, cv::Size(inp_width, inp_height), cv::INTER_LINEAR );
     end_t = std::chrono::steady_clock::now();
     std::cout << " TIME warpAffine: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
+    
 
     sz = imageF.size();
     std::cout<<"size: "<<sz.height<<" "<<sz.width<<" - "<<std::endl;
     imageF.convertTo(imageF, CV_32FC3, 1/255.0); 
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME convert_to: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
-    std::cout<<"mean: "<<mean<<", std: "<<stddev<<std::endl;
-
-    dim2 = dim;
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME before split: " << std::chrono::duration_cast<std::chrono::microseconds>(end_t - step_t).count() << " us" << std::endl;
-    step_t = end_t;
-
-    //split channels
-    cv::split(imageF,bgr);//split source
     
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME split: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME convert: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
     
+    dim2 = dim;
+    
+    //split channels
+    cv::split(imageF,bgr);//split source
+    
     for(int i=0; i<3; i++){
         bgr[i] = bgr[i] - mean[i];
         bgr[i] = bgr[i] / stddev[i];
     }
 
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME mean std: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
-
     //write channels
     for(int i=0; i<dim2.c; i++) {
         int idx = i*imageF.rows*imageF.cols;
         int ch = dim2.c-3 +i;
-        std::cout<<"i: "<<i<<", idx: "<<idx<<", ch: "<<ch<<std::endl;
+        // std::cout<<"i: "<<i<<", idx: "<<idx<<", ch: "<<ch<<std::endl;
         memcpy((void*)&input[idx], (void*)bgr[ch].data, imageF.rows*imageF.cols*sizeof(dnnType));
     }
 
@@ -292,241 +284,85 @@ void CenternetDetection::update(cv::Mat &imageORIG) {
         netRT->infer(dim2, input_d);
         TIMER_STOP
         dim2.print();
+
+        stats.push_back(t_ns);
     }
     // checkResult(dim2.tot(), input_h, input);
-    std::cout<<" --- pre-process ---\n";
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
+    step_t = std::chrono::steady_clock::now();
+    
     // ------------------------------------ process --------------------------------------------
     
     rt_out[0] = (dnnType *)netRT->buffersRT[1];
     rt_out[1] = (dnnType *)netRT->buffersRT[2];
     rt_out[2] = (dnnType *)netRT->buffersRT[3]; 
     rt_out[3] = (dnnType *)netRT->buffersRT[4]; 
-
     activationSIGMOIDForward(rt_out[0], rt_out[0], dim_hm.tot());
     checkCuda( cudaDeviceSynchronize() );
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME sigmoid : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
 
     subtractWithThreshold(rt_out[0], rt_out[0] + dim_hm.tot(), rt_out[1], rt_out[0]);
 
-    float *prova;
-    checkCuda( cudaMallocHost(&prova, K*sizeof(float)) ); 
-    checkCuda( cudaMemcpy(prova, rt_out[0], K*sizeof(float), cudaMemcpyDeviceToHost) );
-    std::cout<<"heat:\n";
-    for(int i=0; i<K; i++)
-        std::cout<<prova[i]<<" ";
-    std::cout<<"\n\n\n";
-    // for(int i=0; i < dim_hm.tot(); i++){
-    //     if(hm_h[i]-hmax_h[i] > toll || hm_h[i]-hmax_h[i] < -toll){
-    //         hm_h[i] = 0.0f;
-    //     }
-    // }
-    // checkCuda( cudaFreeHost(hmax_h) );
-    std::cout<<" --- hmax ---\n";
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME threshold: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
     // ----------- nms end
     // ----------- topk  
       
-
-    // thrust::device_vector<int> ids_d;
-    // int ids[dim_hm.h * dim_hm.w];
-    // for(int i=0; i<dim_hm.h * dim_hm.w; i++){
-    //     ids[i]=i;
-    // }
-    // std::vector<int> ids2( dim_hm.h * dim_hm.w );
-    // for(int i=0; i<dim_hm.h * dim_hm.w; i++){
-    //     ids2[i]=i;
-    // }
-    // int ids2[dim_hm.h * dim_hm.w];
-    
-    // checkCuda( cudaMemcpy(ids2_d, ids2, dim_hm.h * dim_hm.w*sizeof(int), cudaMemcpyHostToDevice) );
     if(K > dim_hm.h * dim_hm.w){
         printf ("Error topk (K is too large)\n");
         return;
     }
-
     
     checkCuda( cudaMemcpy(ids_d, ids_, dim_hm.c * dim_hm.h * dim_hm.w*sizeof(int), cudaMemcpyHostToDevice) );    
-    // checkCuda( cudaMemcpy(ids_2d, ids_2, dim_hm.h * dim_hm.w*sizeof(int), cudaMemcpyHostToDevice) );    
-    
-    
-    // sortAndTopKonDevice(rt_out[0], ids_2d, topk_scores, topk_inds_ , topk_ys_ , topk_xs_ ,dim_hm.h * dim_hm.w, K, dim_hm.c);
-    // checkCuda( cudaDeviceSynchronize() );
 
-    // for(int i=0; i<dim_hm.c; i++){
-    //     // get the hm->output_dim.h * hm->output_dim.w elements for each channel and sort it. Then find the first 100 elements
-    //     // memcpy(ids2, ids, dim_hm.h * dim_hm.w);
-    //     sort(rt_out[0]+ i * dim_hm.h * dim_hm.w,
-    //             rt_out[0]+ i * dim_hm.h * dim_hm.w + dim_hm.h * dim_hm.w,
-    //             ids_d);
-    //     // end_t = std::chrono::steady_clock::now();
-    //     // std::cout << " TIME sort channel "<<i<<": " << std::chrono::duration_cast<std::chrono::microseconds>(end_t - step_t).count() << " ms" << std::endl;
-    //     // step_t = end_t;
-    //     topk(rt_out[0]+ i * dim_hm.h * dim_hm.w, ids_d, K, topk_scores + i*K,
-    //         topk_inds_ + i*K, topk_ys_ + i*K, topk_xs_ + i*K);
-    //     // checkCuda( cudaMemcpy(ids2, ids2_d, dim_hm.h * dim_hm.w*sizeof(int), cudaMemcpyDeviceToHost) );
-
-    //     // for (int j=0; j<dim_hm.h * dim_hm.w; j++) {
-    //     //     topk_scores[i*K + count] = hm_h[i * dim_hm.h * dim_hm.w + ids2[j]];
-    //     //     topk_inds_[i*K +count] = ids2[j];
-    //     //     topk_ys_[i*K +count] = (int)(ids2[j] / width);
-    //     //     topk_xs_[i*K +count] = (int)(ids2[j] % width);
-    //     //     if(++count == K)
-    //     //         break;
-    //     // }
-    //     // end_t = std::chrono::steady_clock::now();
-    //     // std::cout << " TIME topk channel "<<i<<": " << std::chrono::duration_cast<std::chrono::microseconds>(end_t - step_t).count() << " ms" << std::endl;
-    //     // step_t = end_t;
-    
-    // }
-    // checkCuda( cudaFree(ids_d ));
-    std::cout<<" --- a 100 ---\n";
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME sort topk on 80 channel: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
-    // final
-
-    // sort(topk_scores,
-    //     topk_scores +  dim_hm.c * K,
-    //     topk_inds_);
     sort(rt_out[0],
             rt_out[0]+dim_hm.tot(),
             ids_d);
     checkCuda( cudaDeviceSynchronize() );   
-    int *topk_inds;
-    checkCuda( cudaMallocHost(&topk_inds, K*sizeof(int)) ); 
-    // checkCuda( cudaMemcpy(topk_inds, ids_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    // for(int i=0; i<K; i++)
-    //     std::cout<<topk_inds[i]<<" ";
-    // std::cout<<"\n\n\n";
-
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME sort channel: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME sort: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
 
-    // topk(topk_scores, topk_inds_, K, scores_d,
-    //     topk_inds_d, topk_ys_d, topk_xs_d);
     topk(rt_out[0], ids_d, K, scores_d,
         topk_inds_d, topk_ys_d, topk_xs_d);
-    checkCuda( cudaDeviceSynchronize() );
+    checkCuda( cudaDeviceSynchronize() );    
+
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME topk channel: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME topk: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
-    
-    
-    checkCuda( cudaMemcpy(topk_inds, topk_inds_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    for(int i=0; i<K; i++)
-        std::cout<<topk_inds[i]<<" ";
-    std::cout<<std::endl;
-    
-    
+        
     checkCuda( cudaMemcpy(scores, scores_d, K *sizeof(float), cudaMemcpyDeviceToHost) );
-    std::cout<<"\n\nscores:\n";
-    for(int i=0; i<K;i++)
-        std::cout<<scores[i]<<" ";
-    std::cout<<std::endl;
-    
-    
-    std::cout<<"\n\n\n";
+
     topKxyclasses(topk_inds_d, topk_inds_d+K, K, width, dim_hm.w*dim_hm.h, clses_d, inttopk_xs_d, inttopk_ys_d);
+    end_t = std::chrono::steady_clock::now();
+    std::cout << " TIME topk x y clses 2: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    step_t = end_t;
+
     checkCuda( cudaMemcpy(topk_xs_d, (float *)inttopk_xs_d, K*sizeof(float), cudaMemcpyDeviceToDevice) );
     checkCuda( cudaMemcpy(topk_ys_d, (float *)inttopk_ys_d, K*sizeof(float), cudaMemcpyDeviceToDevice) );
     
     checkCuda( cudaMemcpy(clses, clses_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    std::cout<<"\ntopk_ids: \n";
-    checkCuda( cudaMemcpy(topk_inds, topk_inds_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    for(int i=0; i<K; i++)
-        std::cout<<topk_inds[i]<<" ";
-    std::cout<<std::endl;
-    std::cout<<"\ntopk_clses: \n";
-    checkCuda( cudaMemcpy(topk_inds, clses_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    for(int i=0; i<K; i++)
-        std::cout<<topk_inds[i]<<" ";
-    std::cout<<std::endl;
-    std::cout<<"\nxs: \n";
-    checkCuda( cudaMemcpy(topk_inds, topk_xs_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    for(int i=0; i<K; i++)
-        std::cout<<topk_inds[i]<<" ";
-    std::cout<<std::endl;
-    std::cout<<"\nys: \n";
-    checkCuda( cudaMemcpy(topk_inds, topk_ys_d, K*sizeof(int), cudaMemcpyDeviceToHost) );
-    for(int i=0; i<K; i++)
-        std::cout<<topk_inds[i]<<" ";
-    std::cout<<std::endl;
-    // return;
-
-    // checkCuda( cudaDeviceSynchronize() );
-    // checkCuda( cudaFree(topk_scores) );
-    // checkCuda( cudaFree(topk_inds_) );
-    // checkCuda( cudaFree(topk_ys_) );
-    // checkCuda( cudaFree(topk_xs_) );
-
-
-    // checkCuda( cudaFree(scores_d) );
-    // checkCuda( cudaFree(topk_inds_d) );
-
-
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME clses topk 1 time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
+    
     // ----------- topk end 
     
-    // dnnType *reg_aus;
-    // checkCuda( cudaMallocHost(&reg_aus, dim_reg.tot()*sizeof(dnnType)) ); 
-    // checkCuda( cudaMemcpy(reg_aus, rt_out[3], dim_reg.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );    
-
-    // for(int i = 0; i < K; i++){
-    //     topk_xs[i] = topk_xs[i] + reg_aus[topk_inds[i]];
-    //     topk_ys[i] = topk_ys[i] + reg_aus[topk_inds[i]+dim_reg.h*dim_reg.w];
-    // }
     topKxyAddOffset(topk_inds_d, K, dim_reg.h*dim_reg.w, inttopk_xs_d, inttopk_ys_d, topk_xs_d, topk_ys_d, rt_out[3]);
     // checkCuda( cudaDeviceSynchronize() );
+    
     end_t = std::chrono::steady_clock::now();
     std::cout << " TIME add offset: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
-    // checkCuda( cudaFreeHost(reg_aus) );
-
-    // dnnType *wh_aus;
     
-    // checkCuda( cudaMemcpy(wh_aus, rt_out[2], dim_wh.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );    
     bboxes(topk_inds_d, K, dim_wh.h*dim_wh.w, topk_xs_d, topk_ys_d, rt_out[2], bbx0_d, bbx1_d, bby0_d, bby1_d);
     // checkCuda( cudaDeviceSynchronize() );
+    
     checkCuda( cudaMemcpy(bbx0, bbx0_d, K * sizeof(float), cudaMemcpyDeviceToHost) ); 
     checkCuda( cudaMemcpy(bby0, bby0_d, K * sizeof(float), cudaMemcpyDeviceToHost) ); 
     checkCuda( cudaMemcpy(bbx1, bbx1_d, K * sizeof(float), cudaMemcpyDeviceToHost) ); 
     checkCuda( cudaMemcpy(bby1, bby1_d, K * sizeof(float), cudaMemcpyDeviceToHost) ); 
-    // for(int i = 0; i < K; i++){
-    //     bboxes[i * 4] = topk_xs[i] - wh_aus[topk_inds[i]] / 2;
-    //     bboxes[i * 4 + 1] = topk_ys[i] - wh_aus[topk_inds[i]+dim_reg.h*dim_reg.w] / 2;
-    //     bboxes[i * 4 + 2] = topk_xs[i] + wh_aus[topk_inds[i]] / 2;
-    //     bboxes[i * 4 + 3] = topk_ys[i] + wh_aus[topk_inds[i]+dim_reg.h*dim_reg.w] / 2;
-    // }
-    // for(int i = 0; i < K; i++){
-    //     std::cout<<"-----\n(x0, y0) = ("<<bbx0<<", "<<bby0<<")\n(x1,y1) = ("<<bbx1<<", "<<bby1<<")\n";
-        
-    // }
-
-    // checkCuda( cudaFreeHost(wh_aus) );
-    // checkCuda( cudaFreeHost(topk_inds) );
-    // checkCuda( cudaFreeHost(topk_ys) );
-    // checkCuda( cudaFreeHost(topk_xs) );
-    std::cout<<" --- bboxes ---\n";
+    
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME bboxes: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
-    // servono [bboxes, scores, clses]
-    // checkCuda( cudaDeviceSynchronize() );
 
-    std::cout<<" --- process ---\n";
-    end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
-    step_t = end_t;
     // ---------------------------------- post-process -----------------------------------------
     
     // --------- ctdet_post_process
@@ -548,12 +384,13 @@ void CenternetDetection::update(cv::Mat &imageORIG) {
     
     cv::Mat trans2(cv::Size(3,2), CV_32F);
     trans2 = cv::getAffineTransform( dst, src );
+
     end_t = std::chrono::steady_clock::now();
     std::cout << " TIME getAffineTrans 2: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
+
     cv::Mat new_pt1(cv::Size(1,2), CV_32F);
-    cv::Mat new_pt2(cv::Size(1,2), CV_32F);
- 
+    cv::Mat new_pt2(cv::Size(1,2), CV_32F); 
 
     for(int i = 0; i<K; i++){
         new_pt1.at<float>(0,0)=static_cast<float>(trans2.at<double>(0,0))*bbx0[i] +
@@ -570,23 +407,18 @@ void CenternetDetection::update(cv::Mat &imageORIG) {
                                 static_cast<float>(trans2.at<double>(1,1))*bby1[i] +
                                 static_cast<float>(trans2.at<double>(1,2))*1.0;
 
-        // std::cout<<"\n new: "<<new_pt1<<" - "<<new_pt2<<std::endl;
         target_coords[i*4] = new_pt1.at<float>(0,0);
         target_coords[i*4+1] = new_pt1.at<float>(0,1);
         target_coords[i*4+2] = new_pt2.at<float>(0,0);
         target_coords[i*4+3] = new_pt2.at<float>(0,1);
-        // std::cout<<new_pt1.at<float>(0,0)<<", "<<new_pt1.at<float>(0,1)<<", "<<new_pt2.at<float>(0,0)<<", "<<new_pt2.at<float>(0,1)<<std::endl;
-        // std::cout<<"target:cords "<<target_coords[i*4]<<" - "<<target_coords[i*4+1]<<std::endl; 
     }
-    
-    // int *classes;
-    
+        
     detected.clear();
     for(int i = 0; i<classes; i++){
         for(int j=0; j<K; j++)
             if(clses[j] == i){
                 if(scores[j] > thresh){
-                    std::cout<<"th: "<<scores[j]<<" - cl: "<<clses[j]<<" i: "<<i<<std::endl;
+                    // std::cout<<"th: "<<scores[j]<<" - cl: "<<clses[j]<<" i: "<<i<<std::endl;
                     //add coco bbox
                     //det[0:4], i, det[4]
                     int x0   = target_coords[j*4];
@@ -607,10 +439,11 @@ void CenternetDetection::update(cv::Mat &imageORIG) {
                 }
             }
     }
-    std::cout<<" --- post_process ---\n";
+    
     end_t = std::chrono::steady_clock::now();
-    std::cout << " TIME : " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
+    std::cout << " TIME detections: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_t - step_t).count() << " ms" << std::endl;
     step_t = end_t;
+
     std::cout<<"TOTAL: \n";
     TIMER_STOP
 }
diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp
index bec7b17..0f2d621 100644
--- a/src/NetworkRT.cpp
+++ b/src/NetworkRT.cpp
@@ -290,8 +290,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) {
     if(l->pool_mode == tkdnnPoolingMode_t::POOLING_AVERAGE_EXCLUDE_PADDING) ptype = PoolingType::kMAX_AVERAGE_BLEND;
 
 
-    // if(l->input_dim.h % 2 == 1 && l->input_dim.w % 2 == 1)
-    if(l->input_dim.h == l->output_dim.h && l->input_dim.w == l->output_dim.w)
+    if(l->paddingH == 0 && l->paddingW == 0  && l->input_dim.h == l->output_dim.h && l->input_dim.w == l->output_dim.w)
     {
       IPlugin *plugin = new ResizeLayerRT( l->output_dim.c,l->output_dim.h+1,l->output_dim.w+1 );
       IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin);
diff --git a/src/Pooling.cpp b/src/Pooling.cpp
index 1ad0664..cc498df 100644
--- a/src/Pooling.cpp
+++ b/src/Pooling.cpp
@@ -55,8 +55,8 @@ Pooling::Pooling( Network *net, int winH, int winW, int strideH, int strideW,
     int padW = paddingW == 0? winW -1 : paddingW;
     
     if(final){
-        h = (h + padH - winH)/strideH +1 +1;
-        w =  (w + padW - winW)/strideW +1 +1;
+        h = (h + 2*paddingH - winH)/strideH +1 ;
+        w =  (w + 2*paddingW - winW)/strideW +1;
     }
     else{
         h = (h + padH - winH)/strideH +1;
diff --git a/src/kernels/activation_sigmoid.cu b/src/kernels/activation_sigmoid.cu
index ba6c997..400a948 100644
--- a/src/kernels/activation_sigmoid.cu
+++ b/src/kernels/activation_sigmoid.cu
@@ -1,21 +1,13 @@
 #include "kernels.h"
-
-__device__ 
-__forceinline__ 
-double sigmoid (double a)
-{
-    return 1.0 / (1.0 + exp (-a));
-}
+#include <math.h>
 
 
 __global__
 void activation_sigmoid(dnnType *input, dnnType *output, int size) {
 
-    int stride = gridDim.x * blockDim.x;
-    int tid = blockDim.x * blockIdx.x + threadIdx.x;
-    for (int i = tid; i < size; i += stride) {
-        output[i] = sigmoid (input[i]);
-    }
+    int i = blockDim.x * blockIdx.x + threadIdx.x;
+    if(i < size)
+        output[i] = 1.0f / (1.0f + exp (-input[i]));
  }
 
 
diff --git a/src/sorting.cu b/src/sorting.cu
index e007be1..fd62cec 100644
--- a/src/sorting.cu
+++ b/src/sorting.cu
@@ -45,7 +45,7 @@ struct threshold : public thrust::binary_function<float,float,float>
 {
   __host__ __device__
   float operator()(float x, float y) { 
-    float toll = 1e-6; 
+    double toll = 1e-6; 
     if(fabsf(x-y)>toll) 
         return 0.0f; 
     else
diff --git a/tests/resnet101_cnet/resnet101_cnet.cpp b/tests/resnet101_cnet/resnet101_cnet.cpp
index 061e4b6..e05f517 100644
--- a/tests/resnet101_cnet/resnet101_cnet.cpp
+++ b/tests/resnet101_cnet/resnet101_cnet.cpp
@@ -183,53 +183,6 @@ const char *output_bin[]={
 "../tests/resnet101_cnet/debug/wh.bin",
 "../tests/resnet101_cnet/debug/reg.bin"};
 
-
-
-std::vector<size_t> sort_indexes(const std::vector<float> &v) {
-
-  // initialize original index locations
-  std::vector<size_t> idx(v.size());
-  iota(idx.begin(), idx.end(), 0);
-
-  // sort indexes based on comparing values in v
-  sort(idx.begin(), idx.end(),
-       [&v](size_t i1, size_t i2) {return v[i1] > v[i2];});
-
-  return idx;
-}
-
-float _colors[6][3] = { {1,0,1}, {0,0,1},{0,1,1},{0,1,0},{1,1,0},{1,0,0} };
-float get_color(int c, int x, int max)
-{
-    float ratio = ((float)x/max)*5;
-    int i = floor(ratio);
-    int j = ceil(ratio);
-    ratio -= i;
-    float r = (1-ratio) * _colors[i % 6][c % 3] + ratio*_colors[j % 6][c % 3];
-    //printf("%f\n", r);
-    return r;
-}
-
-int computeDetections(dnnType *hm_d, dnnType *wh_d, dnnType *reg_d, int hm_dim, int wh_dim, int reg_dim, bool cat_spec_wh, int k){
-    // _nms
-    int kernel = 3; 
-    int pad = (kernel - 1)/2;
-    std::cout<<"computeDetections\n";
-    // dnnType *hmax;
-    // tk::dnn::Pooling maxpool(&hmax, 3, 3, 2, 2, 1, 1, tk::dnn::POOLING_MAX)
-    // =  (dnnType *) 
-    
-    // net.functional.max_pool2d(
-    //     heat, (kernel, kernel), stride=1, padding=pad)
-    // keep = (hmax == heat).float()
-    // return heat * keep
-}
-
-int process(dnnType *hm_d, dnnType *wh_d, dnnType *reg_d, int hm_dim, int wh_dim, int reg_dim){
-    std::cout<<"process\n";
-    // computeDetections(hm_d, wh_d, reg_d, hm_dim, wh_dim, reg_dim, false, 100);
-}
-
 int main()
 {
 
@@ -450,637 +403,5 @@ int main()
         checkResult(odim, rt_out, out);
         std::cout << "CUDNN vs TRT    ";
         checkResult(odim, cudnn_out, rt_out);
-    }
-
-    TIMER_START
-
-    // -------- transofrm compose
-    cv::Mat imageOrig = cv::imread("/media/davide/DATA/shared_home/Projects/Professionale/repos/photo_2020-01-14_09-56-07.jpg");
-    cv::Mat imageF;
-    imageOrig.convertTo(imageF, CV_32FC3, 1/255.0); 
-    cv::Mat image;
-    cv::Size sz = imageF.size();
-    std::cout<<"image: "<<sz.width<<", "<<sz.height<<std::endl;
-    resize(imageF, image, cv::Size(256, 256));
-    const int cropSize = 224;
-    const int offsetW = (image.cols - cropSize) / 2;
-    const int offsetH = (image.rows - cropSize) / 2;
-    const cv::Rect roi(offsetW, offsetH, cropSize, cropSize);
-    image = image(roi).clone();
-    std::cout << "Cropped image dimension: " << image.cols << " X " << image.rows << std::endl;
-
-    cv::Scalar mean_; 
-    mean_ << 0.485, 0.456, 0.406;
-    cv::Scalar stddev_; 
-    stddev_ << 0.229, 0.224, 0.225;
-    cv::Size s_im = imageF.size();
-    std::cout<<"size: "<<s_im.height<<" "<<s_im.width<<" - "<<std::endl;
-    std::cout<<"mean: "<<mean_<<", std: "<<stddev_<<std::endl;
-    cv::add(image, -mean_, image);
-    cv::divide(image, stddev_, image);
-    cv::Mat bgr[3]; 
-    dnnType *input, *input_d;
-    dim2 = dim;
-    checkCuda(cudaMalloc(&input_d, sizeof(dnnType)*dim2.tot()));
-    checkCuda(cudaMallocHost(&input, sizeof(dnnType)*dim2.tot()));
-    image.convertTo(image, CV_32FC3, 1/255.0); 
-
-    //split channels
-    cv::split(image,bgr);//split source
-
-    //write channels
-    for(int i=0; i<dim2.c; i++) {
-        int idx = i*image.rows*image.cols;
-        int ch = dim2.c-1 -i;
-        memcpy((void*)&input[idx], (void*)bgr[ch].data, image.rows*image.cols*sizeof(dnnType));
-    }
-
-    checkCuda(cudaMemcpyAsync(input_d, input, dim2.tot()*sizeof(dnnType), cudaMemcpyHostToDevice));
-
-    printCenteredTitle(" TENSORRT inference ", '=', 30); {
-        dim2.print();
-        TIMER_START
-        netRT.infer(dim2, input_d);
-        TIMER_STOP
-        dim2.print();
-    }
-    checkResult(dim2.tot(), input_h, input);
-    checkCuda(cudaFree(input_d));
-    checkCuda(cudaFreeHost(input));
-    // -----------------------------------pre-process ------------------------------------------
-    // it will resize the images to `512 x 512` in GETTING_STARTED.md
-    
-    float scale = 1.0;
-    float new_height = sz.height * scale;
-    float new_width = sz.width * scale;
-    float inp_height = 224;//512;
-    float inp_width = 224;//512;
-    float c[] = {new_width / 2.0, new_height /2.0};
-    float s[2];
-    if(sz.width > sz.height){
-        s[0] = sz.width * 1.0;
-        s[1] = sz.width * 1.0;
-    }
-    else{
-        s[0] = sz.height * 1.0;    
-        s[1] = sz.height * 1.0;    
-    }
-    std::cout<<" "<<new_height<<" "<<new_width<<" "<<s[0]<<"-"<<s[1]<<" "<<c[0]<<"-"<<c[1]<<std::endl; 
-    // ----------- get_affine_transform
-    // rot_rad = pi * 0 / 100 --> 0
-    cv::Mat src(cv::Size(2,3), CV_32F);
-    cv::Mat dst(cv::Size(2,3), CV_32F);    
-    src.at<float>(0,0)=c[0];
-    src.at<float>(0,1)=c[1];
-    src.at<float>(1,0)=c[0];
-    src.at<float>(1,1)=c[1] + s[0] * -0.5;
-    dst.at<float>(0,0)=inp_width * 0.5;
-    dst.at<float>(0,1)=inp_height * 0.5;
-    dst.at<float>(1,0)=inp_width * 0.5;
-    dst.at<float>(1,1)=inp_height * 0.5 +  inp_width * -0.5; 
-    
-    src.at<float>(2,0)=src.at<float>(1,0) + (-src.at<float>(0,1)+src.at<float>(1,1) );
-    src.at<float>(2,1)=src.at<float>(1,1) + (src.at<float>(0,0)-src.at<float>(1,0) );
-    dst.at<float>(2,0)=dst.at<float>(1,0) + (-dst.at<float>(0,1)+dst.at<float>(1,1) );
-    dst.at<float>(2,1)=dst.at<float>(1,1) + (dst.at<float>(0,0)-dst.at<float>(1,0) );
-    std::cout<<"src: "<<src<<std::endl;
-    std::cout<<"dst: "<<dst<<std::endl;
-
-    cv::Mat trans = cv::getAffineTransform( src, dst );
-
-    resize(imageOrig, image, cv::Size(new_width, new_height));
-    s_im = image.size();
-    std::cout<<"size: "<<s_im.height<<" "<<s_im.width<<" - "<<std::endl;
-    
-
-    // image.convertTo(image, CV_32FC3, 1/255.0); 
-    cv::warpAffine(image, image, trans, cv::Size(inp_width, inp_height), cv::INTER_LINEAR );
-    // cv::Scalar mean, stddev;
-    s_im = image.size();
-    std::cout<<"size: "<<s_im.height<<" "<<s_im.width<<" - "<<std::endl;
-    
-    // for(int i=0; i<dim.tot(); i++ ){
-    //     std::cout<<(float)image.at<cv::Vec3b>(0,i)[0]<<" -  "<<(float)image.at<cv::Vec3b>(0,i)[1]<<" - "<<(float)image.at<cv::Vec3b>(0,i)[2]<<" - "<<std::endl;
-    //     if(i==10)
-    //         break;
-    // }
-    // return 0;
-    /////////////////////////////// ok fin qui
-
-
-    // cv::meanStdDev(image, mean, stddev );
-    // cv::Scalar mean(0.408, 0.447, 0.47); 
-    cv::Vec<float, 3> mean;
-    mean << 0.408, 0.447, 0.47;
-    // s_im = mean.size();
-    // std::cout<<"size: "<<s_im.height<<" "<<s_im.width<<" - "<<std::endl;
-    
-    cv::Vec<float, 3> stddev; 
-    stddev << 0.289, 0.274, 0.278;
-
-    cv::Size s_imag = image.size();
-    std::cout<<"size: "<<s_imag.height<<" "<<s_imag.width<<" - "<<std::endl;
-    image.convertTo(image, CV_32FC3, 1/255.0); 
-    
-    std::cout<<"mean: "<<mean<<", std: "<<stddev<<std::endl;
-    // cv::add(image, -mean, image);
-    // cv::divide(image, stddev, image);
-    cv::MatIterator_<cv::Vec<float, 3>> it;
-    for(it = image.begin<cv::Vec<float, 3>>(); it != image.end<cv::Vec<float, 3>>(); ++it)
-    {
-        (*it)[0] = (float)(*it)[0] - mean[0];
-        (*it)[1] = (float)(*it)[1] - mean[1];
-        (*it)[2] = (float)(*it)[2] - mean[2];
-        (*it)[0] = (float)(*it)[0] / stddev[0];
-        (*it)[1] = (float)(*it)[1] / stddev[1];
-        (*it)[2] = (float)(*it)[2] / stddev[2];
-    }
-
-    // for(int i=0; i<dim.tot(); i++ ){
-    //     std::cout<<(float)image.at<cv::Vec<float, 3>>(0,i)[0]<<" -  "<<(float)image.at<cv::Vec<float, 3>>(0,i)[1]<<" - "<<(float)image.at<cv::Vec<float, 3>>(0,i)[2]<<" - "<<std::endl;
-    //     if(i==10)
-    //         break;
-    // }
-    // return 0;
-    /////////////////////// ok fin qui
-    
-    
-    std::cout<<"size: "<<s_imag.height<<" "<<s_imag.width<<" - "<<std::endl;
-
-    cv::Mat bgr2[3]; 
-    dnnType *input2, *input_d2;
-    dim2 = dim;
-    checkCuda(cudaMalloc(&input_d2, sizeof(dnnType)*dim2.tot()));
-    checkCuda(cudaMallocHost(&input2, sizeof(dnnType)*dim2.tot()));
-    // image.convertTo(image, CV_32FC3, 1/255.0); 
-
-    //split channels
-    cv::split(image,bgr2);//split source
-    
-    // std::cout<<"ch:\n";
-    // for(int i=0; i<dim.tot(); i++ ){
-    //     std::cout<<(float)bgr2[0].at<cv::Vec<float, 3>>(0,i)[0]<<" - "<<(float)bgr2[0].at<cv::Vec<float, 3>>(0,i)[1]<<" - "<<(float)bgr2[0].at<cv::Vec<float, 3>>(0,i)[2]<<std::endl;
-    //     if(i==10)
-    //         break;
-    // }
-    // std::cout<<"ch:\n";
-    // for(int i=0; i<dim.tot(); i++ ){
-    //     std::cout<<(float)bgr2[1].at<float>(1,i)<<std::endl;
-    //     if(i==10)
-    //         break;
-    // }
-    // std::cout<<"ch:\n";
-    // for(int i=0; i<dim.tot(); i++ ){
-    //     std::cout<<(float)bgr2[2].at<float>(2,i)<<std::endl;
-    //     if(i==10)
-    //         break;
-    // }
-    // return 0;
-    ///////////////////// ok fin qui
-    std::cout<<"\n\n\ncome: \n"<<image.rows<<" - "<<image.cols<<std::endl;
-    std::cout<<"reprint shape dim2\n";
-    dim2.print();
-    std::cout<<std::endl;
-    //write channels
-    for(int i=0; i<dim2.c; i++) {
-        int idx = i*image.rows*image.cols;
-        int ch = dim2.c-3 +i;
-        std::cout<<"i: "<<i<<", idx: "<<idx<<", ch: "<<ch<<std::endl;
-        memcpy((void*)&input2[idx], (void*)bgr2[ch].data, image.rows*image.cols*sizeof(dnnType));
-    }
-    // int k100 = 0;
-    // for(int i=1; i<=image.rows*image.cols*dim2.c; i++ ){
-    //     std::cout<<input2[i]<<" ";
-    //     if (i % (image.rows*image.cols) == 0){
-    //         std::cout<<"\n\n";
-    //         k100 ++;
-    //     }
-            
-    // }
-    // std::cout<<std::endl;
-    // std::cout<<"ci sono "<<k100<<" r\n";
-    // return 0;
-    ///////////////////// pseudo ok
-
-    checkCuda(cudaMemcpyAsync(input_d2, input2, dim2.tot()*sizeof(dnnType), cudaMemcpyHostToDevice));
-
-    printCenteredTitle(" TENSORRT inference ", '=', 30); {
-        dim2.print();
-        TIMER_START
-        netRT.infer(dim2, input_d2);
-        TIMER_STOP
-        dim2.print();
-    }
-    checkResult(dim2.tot(), input_h, input2);
-    for(int i=0; i<dim.tot(); i++ ){
-        std::cout<<input_h[i]<<" "<<input2[i]<<std::endl;
-        if(i==10)
-            break;
-    }
-    // for(int i=0; i<dim.tot(); i++ ){
-    //     std::cout<<input2[i]<<" ";
-    // }
-    // std::cout<<std::endl;
-    // return 0;
-    checkCuda(cudaFree(input_d2));
-    checkCuda(cudaFreeHost(input2));
-    // ------------------------------------ process --------------------------------------------
-    dnnType *hm_h;
-    checkCuda( cudaMallocHost(&hm_h, hm->output_dim.tot()*sizeof(dnnType)) );
-
-    dnnType *rt_out[4];
-    rt_out[0] = (dnnType *)netRT.buffersRT[1];
-    rt_out[1] = (dnnType *)netRT.buffersRT[2];
-    rt_out[2] = (dnnType *)netRT.buffersRT[3]; 
-    rt_out[3] = (dnnType *)netRT.buffersRT[4]; 
-    
-    // checkCuda( cudaMemcpy(hm_h, rt_out[0], hm->output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );
-    std::cout<<"hm\n";
-    hm->output_dim.print();
-    // for(int i=0; i<hm->output_dim.tot(); i++ ){
-    //     std::cout<<hm_h[i]<<" ";
-    //     if(i==100)
-    //         break;
-    // }
-    // std::cout<<"\n";
-
-
-    activationSIGMOIDForward(rt_out[0], rt_out[0], hm->output_dim.tot());
-    checkCuda( cudaDeviceSynchronize() );
-    
-    
-    checkCuda( cudaMemcpy(hm_h, rt_out[0], hm->output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );
-    std::cout<<"hm\n";
-    hm->output_dim.print();
-    // for(int i=0; i<hm->output_dim.tot(); i++ ){
-    //     std::cout<<hm_h[i]<<" ";
-    //     if(i==100)
-    //         break;
-    // }
-    // std::cout<<"\n";
-    // return 0;
-    //////////////////////////// ok
-    // ----------- ctdet_decode
-    // perform nms on heatmaps
-    // tk::dnn::Layer    *route_hm_layers[1]   = { hm };
-    // tk::dnn::Route    *route_hm             = new tk::dnn::Route(&net, route_hm_layers, 1);
-    
-    // ----------- nms
-    // int kernel = 3; 
-    // int pad = (kernel - 1)/2;
-    // tk::dnn::Pooling  *hmax                 = new tk::dnn::Pooling(&net, kernel, kernel, 1, 1, pad, pad, tk::dnn::POOLING_MAX);
-    
-    // hmax_d = hmax->infer(hmax->input_dim.tot(), rt_out[0]);
-    // keep = (hmax == heat).float()
-    // return heat * keep
-    
-    dnnType *hmax_h;
-    checkCuda( cudaMallocHost(&hmax_h, hmax->output_dim.tot()*sizeof(dnnType)) );
-    checkCuda( cudaMemcpy(hmax_h, rt_out[1], hmax->output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );
-
-    std::cout<<"hmax\n";
-    hmax->output_dim.print();
-    // for(int i=0; i<hmax->output_dim.tot(); i++ ){
-    //     std::cout<<hmax_h[i]<<" ";
-    //     if(i==100)
-    //         break;
-    // }
-    // std::cout<<"\n";
-    // return 0;
-    // hm = hm * ( hmax == hm );
-    std::cout<<"hm:\n";
-    hm->output_dim.print();
-    std::cout<<"hmax:\n";
-    hmax->output_dim.print();
-    // return 0;
-    float toll = 0.000001;
-    for(int i=0; i < hm->output_dim.tot(); i++){
-        if(hm_h[i]-hmax_h[i] > toll || hm_h[i]-hmax_h[i] < -toll){
-            hm_h[i] = 0.0f;
-        }
-    }
-    // std::cout<<"\n";
-    // for(int i=0; i<hm->output_dim.tot(); i++ ){
-    //     std::cout<<hm_h[i]<<" ";
-    //     if(i==100)
-    //         break;
-    // }
-    // std::cout<<"\n";
-    // return 0;
-    // checkCuda( cudaMemcpy(hm->dstData, hm_h, hm->output_dim.tot()*sizeof(dnnType), cudaMemcpyHostToDevice) );
-    checkCuda( cudaFreeHost(hmax_h) );
-    // ----------- nms end
-    // ----------- topk
-    int K = 100;
-    int width = 56;        // TODO
-    float *topk_scores;
-    int *topk_inds_;
-    float *topk_ys_;
-    float *topk_xs_;
-    std::cout<<"mah: "<<hm->output_dim.c * K<<std::endl;
-    checkCuda( cudaMallocHost(&topk_scores, hm->output_dim.c * K *sizeof(float)) );
-    checkCuda( cudaMallocHost(&topk_inds_, hm->output_dim.c * K *sizeof(int)) );      
-    checkCuda( cudaMallocHost(&topk_ys_, hm->output_dim.c * K *sizeof(float)) );      
-    checkCuda( cudaMallocHost(&topk_xs_, hm->output_dim.c * K *sizeof(float)) );      
-    std::cout<<"1\n";
-    dnnType *hm_aus;
-    checkCuda( cudaMallocHost(&hm_aus, hm->output_dim.h * hm->output_dim.w *sizeof(dnnType)) );     
-    std::cout<<"2\n";
-    int count;
-    std::vector<float> v = {2.0, 3.0, 9.0};
-    for (auto i: sort_indexes(v)) {
-        std::cout << i<< "--" <<v[i] << std::endl;
-    }
-    for(int i=0; i<hm->output_dim.c; i++){
-        count = 0;
-        // get the hm->output_dim.h * hm->output_dim.w elements for each channel and sort it. Then find the first 100 elements
-        checkCuda( cudaMemcpy(hm_aus, hm_h + i * hm->output_dim.h * hm->output_dim.w, 
-                    hm->output_dim.h * hm->output_dim.w * sizeof(dnnType), cudaMemcpyHostToHost) );
-        // std::cout<<"top scores: "<<hm->output_dim.h * hm->output_dim.w<<"\n";
-        // for(int k=0; k<hm->output_dim.h * hm->output_dim.w; k++)
-        //     std::cout<<hm_aus[k]<<" ";
-        // std::cout<<std::endl;
-        // std::vector<float> my_vector {arr, arr + arr_length}
-        std::vector<float> my_vector{hm_aus, hm_aus +  hm->output_dim.h * hm->output_dim.w};
-        for (auto j: sort_indexes(my_vector)) {
-            // std::cout <<"j: "<<j<<" -> "<< hm_aus[j] << std::endl;
-            topk_scores[i*K + count] = hm_aus[j];
-            topk_inds_[i*K +count] = j;
-            topk_ys_[i*K +count] = (int)(j / width);
-            topk_xs_[i*K +count] = (int)(j % width);
-            if(++count == K)
-                break;
-        }
-    }
-    std::cout<<"topk_xs_[0]: "<<topk_xs_[0]<<std::endl;
-    for(int i = 0; i< hm->output_dim.c * K; i++)
-        std::cout<<topk_xs_[i]<<" ";
-    std::cout<<"\n3\n";
-    // final
-    float *scores;
-    int *clses; 
-    int *topk_inds;
-    float *topk_ys; 
-    float *topk_xs;
-    checkCuda( cudaMallocHost(&scores, K *sizeof(float)) );
-    checkCuda( cudaMallocHost(&clses, K *sizeof(int)) );
-    checkCuda( cudaMallocHost(&topk_inds, K *sizeof(int)) );
-    checkCuda( cudaMallocHost(&topk_ys, K *sizeof(float)) );     
-    checkCuda( cudaMallocHost(&topk_xs, K *sizeof(float)) ); 
-    std::cout<<"4\n";     
-    count = 0;
-    std::vector<float> my_vector{topk_scores, topk_scores +  hm->output_dim.c * K };
-    for (auto j: sort_indexes(my_vector)) {
-        // std::cout <<"j: "<<j<<" -> "<< hm_aus[j] << std::endl;
-        scores[count] = topk_scores[j];
-        clses[count] = (int)(j / K);
-        topk_inds[count] = topk_inds_[j];
-        topk_ys[count] = topk_ys_[j];
-        topk_xs[count] = topk_xs_[j];
-        if(++count == K)
-            break;
-    }
-    checkCuda( cudaFreeHost(topk_scores) );
-    checkCuda( cudaFreeHost(topk_inds_) );
-    checkCuda( cudaFreeHost(topk_ys_) );
-    checkCuda( cudaFreeHost(topk_xs_) );
-    std::cout<<"5\n";
-    // ----------- topk end 
-    std::cout<<"topk_xs[0]: "<<topk_xs[0]<<std::endl;
-    for(int i = 0; i< K; i++)
-        std::cout<<topk_xs[i]<<" ";
-    std::cout<<std::endl;
-    /////////////////////////////// fin qui ok
-    dnnType *reg_aus;
-    checkCuda( cudaMallocHost(&reg_aus, reg->output_dim.tot()*sizeof(dnnType)) ); 
-    checkCuda( cudaMemcpy(reg_aus, rt_out[3], reg->output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );
-    std::cout<<"reg:\n";
-    reg->output_dim.print();
-    // for(int i=0; i<reg->output_dim.tot(); i++ ){
-    //     std::cout<<reg_aus[i]<<" ";
-    //     if(i==100)
-    //         break;
-    // }
-    // std::cout<<"\n";
-    // return 0;
-    /////////////// ok    
-    // for(int i=0; i<K; i++ ){
-    //     std::cout<<reg_aus[topk_inds[i]]<<" "<<reg_aus[topk_inds[i]+56*56]<<std::endl;
-    // }
-    // std::cout<<"\n";
-    // return 0;
-    ///////////////////// ok fin qui
-    
-
-    for(int i = 0; i < K; i++){
-        topk_xs[i] = topk_xs[i] + reg_aus[topk_inds[i]];
-        topk_ys[i] = topk_ys[i] + reg_aus[topk_inds[i]+reg->output_dim.h*reg->output_dim.w];
-    }
-    std::cout<<"topk_xs[0]: "<<topk_xs[0]<<std::endl;
-    checkCuda( cudaFreeHost(reg_aus) );
-    std::cout<<"6\n";
-    dnnType *wh_aus;
-    float *bboxes;
-
-    checkCuda( cudaMallocHost(&wh_aus, wh->output_dim.tot()*sizeof(dnnType)) ); 
-    checkCuda( cudaMallocHost(&bboxes, 4 * K *sizeof(dnnType)) ); 
-    checkCuda( cudaMemcpy(wh_aus, rt_out[2], wh->output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost) );    
-    std::cout<<"7\n";
-    for(int i = 0; i< K; i++)
-        std::cout<<topk_xs[i]<<" ";
-    std::cout<<std::endl;
-
-    std::cout<<topk_xs[0]<<std::endl;
-    std::cout<<topk_inds[0]<<std::endl;
-    std::cout<<wh_aus[topk_inds[0]*2]<<std::endl;
-    for(int i = 0; i < K; i++){
-        bboxes[i * 4] = topk_xs[i] - wh_aus[topk_inds[i]] / 2;
-        bboxes[i * 4 + 1] = topk_ys[i] - wh_aus[topk_inds[i]+reg->output_dim.h*reg->output_dim.w] / 2;
-        bboxes[i * 4 + 2] = topk_xs[i] + wh_aus[topk_inds[i]] / 2;
-        bboxes[i * 4 + 3] = topk_ys[i] + wh_aus[topk_inds[i]+reg->output_dim.h*reg->output_dim.w] / 2;
-    }
-    ////////////////// fin qui ok 
-
-    checkCuda( cudaFreeHost(wh_aus) );
-    checkCuda( cudaFreeHost(topk_inds) );
-    checkCuda( cudaFreeHost(topk_ys) );
-    checkCuda( cudaFreeHost(topk_xs) );
-
-    std::cout<<"8\n";
-    float *detections;
-    std::cout<<"bboxes:\n";
-    for(int i = 0; i < K+1; i++){
-        std::cout<<bboxes[i]<<" ";
-    }
-    std::cout<<std::endl;
-    checkCuda( cudaMallocHost(&detections, 6 * K *sizeof(dnnType)) ); 
-    checkCuda( cudaMemcpy(detections, bboxes,  4 * K *sizeof(dnnType), cudaMemcpyHostToHost) );
-    checkCuda( cudaMemcpy(detections + 4 * K *sizeof(dnnType), scores,  K *sizeof(dnnType), cudaMemcpyHostToHost) );
-    checkCuda( cudaMemcpy(detections + 5 * K *sizeof(dnnType), clses,  K *sizeof(dnnType), cudaMemcpyHostToHost) );
-    checkCuda( cudaFreeHost(bboxes) );
-    // checkCuda( cudaFreeHost(scores) );
-    // checkCuda( cudaFreeHost(clses) );
-    // servono [bboxes, scores, clses]
-    checkCuda( cudaDeviceSynchronize() );
-    // ---------------------------------- post-process -----------------------------------------
-    
-    // --------- ctdet_post_process
-    //for 1
-    // float *dets;
-    // checkCuda( cudaMallocHost(&dets, 2 * K *sizeof(float)) ); 
-    // checkCuda( cudaMemcpy(dets, detections,  2 * K *sizeof(float), cudaMemcpyHostToHost) );
-    // --------- transform_preds
-    float *target_coords;
-    checkCuda( cudaMallocHost(&target_coords, 4 * K *sizeof(float)) ); 
-    src.at<float>(0,0)=c[0];
-    src.at<float>(0,1)=c[1];
-    src.at<float>(1,0)=c[0];
-    src.at<float>(1,1)=c[1] + s[0] * -0.5;
-    dst.at<float>(0,0)=width * 0.5;
-    dst.at<float>(0,1)=width * 0.5;
-    dst.at<float>(1,0)=width * 0.5;
-    dst.at<float>(1,1)=width * 0.5 +  width * -0.5; 
-    
-    src.at<float>(2,0)=src.at<float>(1,0) + (-src.at<float>(0,1)+src.at<float>(1,1) );
-    src.at<float>(2,1)=src.at<float>(1,1) + (src.at<float>(0,0)-src.at<float>(1,0) );
-    dst.at<float>(2,0)=dst.at<float>(1,0) + (-dst.at<float>(0,1)+dst.at<float>(1,1) );
-    dst.at<float>(2,1)=dst.at<float>(1,1) + (dst.at<float>(0,0)-dst.at<float>(1,0) );
-    std::cout<<"src: "<<src<<std::endl;
-    std::cout<<"dst: "<<dst<<std::endl;
-    cv::Size s_aus;
-    cv::Mat trans2(cv::Size(3,2), CV_32F);
-    trans2 = cv::getAffineTransform( dst, src );
-    s_aus = trans2.size();
-    std::cout<<"trnas2: "<<trans2<<std::endl;
-    std::cout<<trans2.at<double>(0,0)<<" - "<<trans2.at<double>(0,1)<<" - "<<trans2.at<double>(0,2)<<"\n"<<trans2.at<double>(1,0)<<" - "<<trans2.at<double>(1,1)<<" - "<<trans2.at<double>(1,2)<<std::endl;
-    std::cout<<"size: "<<s_aus.height<<" "<<s_aus.width<<" - "<<std::endl;
-
-    cv::Mat new_pt1(cv::Size(1,2), CV_32F);
-    cv::Mat new_pt2(cv::Size(1,2), CV_32F);
-    for(int i = 0; i<K; i++){
-        // new_pt1.at<float>(0,0)=detections[i*4];
-        // new_pt1.at<float>(0,1)=detections[i*4+1];
-        // new_pt1.at<float>(0,2)=1.0;
-        // new_pt1 << detections[i], detections[i+K], 1.0;
-        // std::cout<<"----\ni: "<<i<<std::endl;//<<" newpt: "<<new_pt1<<std::endl;
-        // std::cout<<"origi: "<<detections[i*4]<<", "<<detections[i*4+1]<<", "<<1.0<<std::endl;
-        s_aus = new_pt1.size();
-    
-        // std::cout<<"size: "<<s_aus.height<<" "<<s_aus.width<<" - "<<std::endl;
-        // new_pt2 = trans2.dot(new_pt1);
-        new_pt1.at<float>(0,0)=static_cast<float>(trans2.at<double>(0,0))*detections[i*4] +
-                                static_cast<float>(trans2.at<double>(0,1))*detections[i*4+1] +
-                                static_cast<float>(trans2.at<double>(0,2))*1.0;
-        new_pt1.at<float>(0,1)=static_cast<float>(trans2.at<double>(1,0))*detections[i*4] +
-                                static_cast<float>(trans2.at<double>(1,1))*detections[i*4+1] +
-                                static_cast<float>(trans2.at<double>(1,2))*1.0;
-
-        new_pt2.at<float>(0,0)=static_cast<float>(trans2.at<double>(0,0))*detections[i*4+2] +
-                                static_cast<float>(trans2.at<double>(0,1))*detections[i*4+3] +
-                                static_cast<float>(trans2.at<double>(0,2))*1.0;
-        new_pt2.at<float>(0,1)=static_cast<float>(trans2.at<double>(1,0))*detections[i*4+2] +
-                                static_cast<float>(trans2.at<double>(1,1))*detections[i*4+3] +
-                                static_cast<float>(trans2.at<double>(1,2))*1.0;
-
-                                
-        // std::cout<<"\n new: "<<new_pt1<<" - "<<new_pt2<<std::endl;
-        target_coords[i*4] = new_pt1.at<float>(0,0);
-        target_coords[i*4+1] = new_pt1.at<float>(0,1);
-        target_coords[i*4+2] = new_pt2.at<float>(0,0);
-        target_coords[i*4+3] = new_pt2.at<float>(0,1);
-        // std::cout<<new_pt1.at<float>(0,0)<<", "<<new_pt1.at<float>(0,1)<<", "<<new_pt2.at<float>(0,0)<<", "<<new_pt2.at<float>(0,1)<<std::endl;
-
-    }
-    // return 0;
-    // /////////////// ok fin qui
-    const char *coco_class_name_ [] = {"person", "bicycle", "car", "motorcycle", "airplane", 
-     "bus", "train", "truck", "boat", "traffic light", "fire hydrant",
-     "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse",
-     "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack",
-     "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis",
-     "snowboard", "sports ball", "kite", "baseball bat", "baseball glove",
-     "skateboard", "surfboard", "tennis racket", "bottle", "wine glass",
-     "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich",
-     "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake",
-     "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv",
-     "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
-     "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
-     "scissors", "teddy bear", "hair drier", "toothbrush"};
-
-    std::vector<std::string> coco_class_name(coco_class_name_, std::end( coco_class_name_ ));
-    int num_classes = 80;
-    float vis_threshold = 0.3;
-    // int *classes;
-    std::vector<tk::dnn::box> detected;
-    // checkCuda( cudaMallocHost(&classes, K *sizeof(int)) );
-    // checkCuda( cudaMemcpy(classes, detections + 5 * K *sizeof(dnnType),  K *sizeof(dnnType), cudaMemcpyHostToHost) );
-    for(int i = 0; i<num_classes; i++){
-        for(int j=0; j<K; j++)
-            if(clses[j] == i){
-                //TODO recupera detections[j +0 +1 +2 +3 +4(+5 è la classes, già presa)]
-                // queste compongono un ogg assegnato alla classe i (0, 79) --> i+1 (1:80);
-                
-                if(scores[j] > vis_threshold){
-                    std::cout<<"th: "<<scores[j]<<" - cl: "<<clses[j]<<" i: "<<i<<std::endl;
-                    //add coco bbox
-                    //det[0:4], i, det[4]
-                    int x0   = target_coords[j*4];
-                    int y0   = target_coords[j*4+1];
-                    int x1   = target_coords[j*4+2];
-                    int y1   = target_coords[j*4+3];
-                    int obj_class = clses[j];
-                    float prob = scores[j];
-                    std::cout<<"("<<x0<<", "<<y0<<"),("<<x1<<", "<<y1<<")"<<std::endl;
-                    tk::dnn::box res;
-                    res.cl = obj_class;
-                    res.prob = prob;
-                    res.x = x0;
-                    res.y = y0;
-                    res.w = x1 - x0;
-                    res.h = y1 - y0;
-                    detected.push_back(res);
-                }
-            }
-    }
-    tk::dnn::box b;
-    int x0, w, x1, y0, h, y1;
-    int objClass;
-    std::string det_class;
-    ;
-    
-    
-    int baseline = 0;
-    float fontScale = 0.5;
-    int thickness = 2;
-    cv::Scalar colors[256];
-    for(int c=0; c<num_classes; c++) {
-        int offset = c*123457 % num_classes;
-        float r = get_color(2, offset, num_classes);
-        float g = get_color(1, offset, num_classes);
-        float b = get_color(0, offset, num_classes);
-        colors[c] = cv::Scalar(int(255.0*b), int(255.0*g), int(255.0*r));
-    }
-    int num_detected = detected.size();
-    for (int i = 0; i < num_detected; i++){
-        b = detected[i];
-        x0 = b.x;
-        w = b.w;
-        x1 = b.x + w;
-        y0 = b.y;
-        h = b.h;
-        y1 = b.y + h;
-        objClass = b.cl;
-        det_class = coco_class_name[objClass];
-        cv::rectangle(imageOrig, cv::Point(x0, y0), cv::Point(x1, y1), colors[objClass], 2);
-        // draw label
-        cv::Size textSize = getTextSize(det_class, cv::FONT_HERSHEY_SIMPLEX, fontScale, thickness, &baseline);
-        cv::rectangle(imageOrig, cv::Point(x0, y0), cv::Point((x0 + textSize.width - 2), (y0 - textSize.height - 2)), colors[b.cl], -1);
-        cv::putText(imageOrig, det_class, cv::Point(x0, (y0 - (baseline / 2))), cv::FONT_HERSHEY_SIMPLEX, fontScale, cv::Scalar(255, 255, 255), thickness);
-        
-    }
-    cv::namedWindow("cnet", cv::WINDOW_NORMAL);
-    cv::imshow("cnet", imageOrig);
-    cv::waitKey(10000);
-    TIMER_STOP
-    return 0;
+    }    
 }