C++中使用OPENCV对深度学习的特征图进行可视化

//需要先在运行目录下创建文件夹opencv_layers
#include <iostream>
#include <unistd.h>
#include <opencv4/opencv2/opencv.hpp>
#include <opencv4/opencv2/dnn.hpp>
#include <opencv4/opencv2/dnn/dnn.hpp>

using namespace std;

/*
equal list

opencv_conv*relu = pycaffe_conv*

*/

int main(int argc, char *argv[])
{
    //// SHOULD BE 4.*.*
    cerr<<"WORKING IN OPENCV_VERSION "<<CV_VERSION<<'\n';
    cv::Mat src = cv::imread("src.jpg");

    string cfg     ="deploy.prototxt";
    string weights ="net_iter_25000.caffemodel";
    cv::dnn::Net net = cv::dnn::readNetFromCaffe(cfg,weights);

    if(net.empty()){
        cerr<<"loaded net failed.\n";
        return -;
    }

    cv::Mat inputBlob = cv::dnn::blobFromImage(src, /.F, cv::Size(, ), cv::Scalar(), false, false);
    net.setInput(inputBlob,"data");

    vector<cv::String> outputname=net.getLayerNames();
    outputname.insert(outputname.begin(),"data");
    cv::dnn::MatShape netInputSize = {,,,};
    vector<cv::dnn::MatShape> netlastSize;
    vector<vector<cv::dnn::MatShape> >layerSizes;
    for(size_t i=;i<outputname.size();++i){
        vector<cv::dnn::MatShape>inputLayerSize;
        vector<cv::dnn::MatShape>outputLayerSize;
        net.getLayerShapes(netInputSize,i,inputLayerSize,outputLayerSize);
        cerr<<"layer <<"<<outputname[i]<<">> size [\n";
        for(size_t j=;j<inputLayerSize.size();++j){
            cerr<<"\t["<<inputLayerSize[j][];for(size_t k=;k<inputLayerSize[j].size();++k)cerr<<" x "<<inputLayerSize[j][k];cerr<<"]\n";
        }
        cerr<<"\tto\n";
        for(size_t j=;j<outputLayerSize.size();++j){
            cerr<<"\t["<<outputLayerSize[j][];for(size_t k=;k<outputLayerSize[j].size();++k)cerr<<" x "<<outputLayerSize[j][k];cerr<<"]\n";
        }
        cerr<<"]\n";
        layerSizes.push_back(outputLayerSize);
        netlastSize=inputLayerSize;
    }

    vector<vector<cv::Mat> > outputBlob;
    try{
        cerr<<"\nNet forward ";
        net.forward(outputBlob, outputname);
        cerr<<"done\n\n";
    }catch(exception e){
        cerr << e.what() << '\n';
    }

    string selectLayer="conv4";

    for(size_t i=;i<outputname.size();++i){

        for(size_t j=;j<outputBlob[i].size();++j){
            try{

                cv::Mat blob;
                cv::normalize(outputBlob[i][j], blob, , , cv::NORM_MINMAX);

                cerr<<"blob dim = "<<blob.size.dims()<<" with type "<<blob.type()<<'\n';
                //b * c * w * h
                //b * w * h
                //b * w
                cerr<<"blob shape ["<<blob.size.p[];for(size_t k=;k<blob.size.dims();++k)cerr<<" x "<<blob.size.p[k];cerr<<"]\n";
                cerr<<"real shape ["<<layerSizes[i][j][];for(size_t k=;k<layerSizes[i][j].size();++k)cerr<<" x "<<layerSizes[i][j][k];cerr<<"]\n";

                cv::Mat saveimg;
                float* data=(float*)blob.data;
                string savepath;
                int s[]={};

                switch(blob.size.dims()){
                case :
                    saveimg.create(layerSizes[i][j][],,CV_8UC1);
                    for(size_t pi=; pi<layerSizes[i][j][]; ++pi){
                        saveimg.data[pi]=data[pi];
                    }
                    savepath = "opencv_layers/layer_"+strip(outputname[i],"/")+".jpg";
                    cv::imwrite(savepath,saveimg);
                    saveimg.release();
                    break;
                case :
                    s[]=layerSizes[i][j][];
                    s[]=layerSizes[i][j][];
                    saveimg.create(layerSizes[i][j][],layerSizes[i][j][],CV_8UC1);
                    for(size_t pi=; pi<s[]*s[]; ++pi){
                        saveimg.data[pi]=(uchar)data[pi];
                    }
                    savepath = "opencv_layers/layer_"+strip(outputname[i],"/")+".jpg";
                    cv::imwrite(savepath,saveimg);
                    saveimg.release();
                    break;
                case :
                    s[]=layerSizes[i][j][];
                    s[]=layerSizes[i][j][];
                    s[]=s[]*s[];
                    s[]=ceil(sqrt(layerSizes[i][j][]));
                    s[]=;
                    saveimg=cv::Mat::zeros((s[]+)*s[],(s[]+)*s[],CV_8UC1);
                    fprintf(stderr,"saveimg <%d,%d> for %d\n",saveimg.rows,saveimg.cols,layerSizes[i][j][]);
                    for(size_t wy=; wy<s[]; ++wy){
                        for(size_t wx=; wx<s[]; ++wx){
                            if(s[]>=layerSizes[i][j][])break;
                            s[]=;
                            for(size_t py=; py<s[]; ++py){
                                for(size_t px=; px<s[]; ++px){
                                    saveimg.data[(wy*(s[]+)+py)*s[]*(s[]+)+wx*(s[]+)+px]=(uchar)data[s[]*s[]+s[]];
                                    ++s[];
                                }
                            }
                            ++s[];
                        }
                    }

                    savepath = "opencv_layers/layer_"+strip(outputname[i],"/")+".jpg";
                    cv::imwrite(savepath,saveimg);
                    saveimg.release();
                    break;
                default:
                    cerr<<" exordinary dim\n";
                    break;
                }
                cerr<<"save to "<<savepath<<'\n';

                blob.release();
            }catch(exception e){
                cerr<<" escape beacuse "<<e.what()<<'\n';
            }
        }
    }

    fprintf(stderr, "float %d, double %d\n",sizeof(float),sizeof(double));
    //blob <CV_32FC1,5> float
    fprintf(stderr, "type list : <CV_8UC1,%d> <CV_8UC3,%d> <CV_16FC1,%d> <CV_16FC3,%d> <CV_16SC1,%d> <CV_16SC3,%d> <CV_32FC1,%d> <CV_32SC1,%d> ",
            CV_8UC1,CV_8UC3,CV_16FC1,CV_16FC3,CV_16SC1,CV_16SC3,CV_32FC1,CV_32SC1);
    return ;
}