//需要先在运行目录下创建文件夹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 ;

}