sequence_res.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <math.h>
#include <string>
#include <vector>
#include <cv.h>
#include <highgui.h>

using namespace std;

struct Sbox_det
{
        cv::Rect box;
        float score;
        Sbox_det() :  box(0,0,0,0) , score(0) { }
        Sbox_det( cv::Rect box_ , float score_ )  :  box(box_) , score(score_) { }
};

void read_boxes_gt( string fileString , vector<vector<cv::Rect> >& boxes , int image_scale);
void read_boxes_det( string fileString , vector<vector<Sbox_det> >& boxes );
void viz_boxes( string imageString , vector<cv::Rect> detections , vector<cv::Rect> gt , vector<cv::Rect> accepted );
string convertInt(int number);

int main(int argc, char *argv[])
{
        //reading input arguments -> detection file to be opened ---------------------------------------
        string res_filename;
        float threshold_max, threshold_min, threshold_step;
        if (argc == 5)
        {
                res_filename = argv[1]; //example: resFILTr_mydb_tD_0.2_mT_-0.5.txt
                threshold_min = atof(argv[2]);
                threshold_max = atof(argv[3]); 
                threshold_step = atof(argv[4]);
                printf("************* Sequence results analysis ***************\n\n");
                printf( "overall results are stored on global_results_%s file\n" ,  argv[1] );
                printf( "frame per frame results on frame_results_<thrhold>_%s file\n\n" ,  argv[1] );
                
        }
        else
        {
                printf("Incorred usage: seq_res <file name> <threshold_min> <threshold_max> <threshold_step>\n");
                return -1;
        }
        
        //reading the ground truth boxes ----------------------------------------------------------------
        string homepath = getenv("HOME");
        string fileString = homepath + "/Desktop/laser_vision_pr/annotations/annotations_test.txt";
        vector<vector<cv::Rect> > boxes_gt;
        read_boxes_gt( fileString , boxes_gt , 2);
        printf("size ground truth=  %d\n" , boxes_gt.size() );
        
        //reading result detections boxes with associated scores ----------------------------------------------
        fileString = homepath + "/Desktop/laser_vision_pr/test/" + res_filename ;
        vector<vector<cv::Rect> > boxes_det;
        vector<cv::Rect> frame_boxes;
        vector<vector<Sbox_det> > boxes_det_score;
        read_boxes_det(fileString , boxes_det_score );
        cv::Rect image_box(0,0,512,384);
        
        //creates an empty file and its header for the global results
        fileString = homepath + "/Desktop/laser_vision_pr/test/global_results_"  + res_filename;
        FILE * file_out;
        file_out = fopen (  fileString.c_str() , "w");
        fprintf(  file_out , "threshold TPR   FPR  sum_TP sum_TN sum_FP sum_FN");
        fclose(file_out);
        
        float threshold = threshold_min;
        while( threshold < threshold_max )
        {
                //copying detection boxes that satisfy a certain threshold
                boxes_det.clear();
                for (unsigned int i = 0; i < boxes_det_score.size() ; i++)
                {
                        frame_boxes.clear();
                        for( unsigned int j = 0; j < boxes_det_score[i].size() ; j++)
                        {
                                if ( boxes_det_score[i][j].score > threshold )
                                        frame_boxes.push_back( image_box & boxes_det_score[i][j].box ); //adds new box, limited to image box to the detections 
                        }
                        boxes_det.push_back( frame_boxes );
                }
                printf("size detections at threshold %f = %d\n" , threshold,  boxes_det_score.size() );
                
                //setting positives and negatives detections ----------------------------------------------------------
                vector<vector<cv::Rect> > tp_boxes;
                vector<cv::Rect> tp_boxes_frame;
                stringstream threshold_string;
                threshold_string << threshold;
                fileString = homepath + "/Desktop/laser_vision_pr/test/frame_results_" + threshold_string.str() + "_"  + res_filename;
                file_out = fopen (  fileString.c_str() , "w");
                fprintf ( file_out , "TP   TN   FP   FN"  );
                vector<int> TP, TN, FP, FN;
                //      printf("boxes size = %d" , boxes_det.size() );
                TP.reserve( boxes_det.size() );
                TN.reserve( boxes_det.size() );
                FP.reserve( boxes_det.size() );
                FN.reserve( boxes_det.size() );
                cv::Rect box_inters;
                int N;
                boxes_det.size() > boxes_gt.size() ? N =  boxes_gt.size() : N =  boxes_det.size() ;
                printf("%d\n", N);
                for( unsigned int i = 0; i < N ; i++)
                {
                        TP.push_back( 0);
                        TN.push_back( 0);
                        FP.push_back( 0);
                        FN.push_back( 0);
                        tp_boxes_frame.clear();
                        //printf("-------------     frame %d       ----------------------------------\n", i);
                        for (unsigned int j = 0; j < boxes_det[i].size() ; j++)
                        {
                                for ( unsigned int k = 0; k < boxes_gt[i].size(); k++)
                                {
                                        //True Positives
                                        box_inters = boxes_det[i][j] & boxes_gt[i][k];
                                        int box_inters_area = box_inters.width * box_inters.height;
                                        int box_union_area = boxes_gt[i][k].width * boxes_gt[i][k].height +
                                                                                                boxes_det[i][j].width * boxes_det[i][j].height -
                                                                                                box_inters_area;
        //                              printf( "detection %d -> %d  and gt %d -> %d is %d and union %d -> \n" , j, boxes_det[i][j].width * boxes_det[i][j].height,  
        //                                                                      k, boxes_gt[i][k].width * boxes_gt[i][k].height, box_inters_area , box_union_area );
                                        if ( box_inters_area * 2  >  box_union_area )
                                        {
                                                TP[i] += 1;
                                                tp_boxes_frame.push_back( boxes_det[i][j] );
                                                //printf("At frame %d : detection at box_det = %d and box_gt = %d\n" , i , j , k );
                                                break;
                                        }
                                }
                        }
                        tp_boxes.push_back(tp_boxes_frame);
                        //False negatives
                        if ( TP[i] < boxes_gt[i].size() )
                                FN[i] =  boxes_gt[i].size() - TP[i] ;
                        //False Positives
                        if ( TP[i] < boxes_det[i].size() )
                                FP[i] =  boxes_det[i].size() - TP[i] ;
                        //True Negatives
                        if ( boxes_gt[i].size() == 0 & TP[i] == 0 )
                                TN[i] = 1;
                        fprintf( file_out , "\n %d %d %d %d", TP[i], TN[i] , FP[i] , FN[i]);
                        fileString =  homepath + "/Desktop/laser_vision_pr/test/camera/frame" + convertInt(i+1) + ".jpg";
            
            // To see the frame uncomment next two lines                        
           //printf("         *******  frame %d  ******\n" ,i);
                   //viz_boxes( fileString , boxes_det[i] , boxes_gt[i] , tp_boxes[i] );
                        
                }
                fclose(file_out);
                
                //true and false rates calculation ----------------------------------------------------------------------------------------
                int sum_TP(0), sum_TN(0), sum_FP(0), sum_FN(0);
                for ( unsigned int i = 0; i < TP.size(); i++ )
                {
                        sum_TP += TP[i];
                        sum_TN += TN[i];
                        sum_FP += FP[i];
                        sum_FN += FN[i];
                }
                //True positive rate
                float TPR = (float) sum_TP / (float) ( sum_TP + sum_FN );
                //false positive rate
                float FPR = (float) sum_FP / (float) ( sum_FP + sum_TN );

                //Final results calculations TPR and FPR -------------------------------------------------------------------------------------
        //      printf(  "sum_TP = %d, sum_TN = %d, sum_FP = %d, sum_FN = %d \n" , sum_TP, sum_TN, sum_FP, sum_FN );
        //      printf (  "TPR = %f, FPR = %f \n ",  TPR, FPR);
                fileString = homepath + "/Desktop/laser_vision_pr/test/global_results_"  + res_filename;
                file_out = fopen (  fileString.c_str() , "a");
                fprintf(  file_out , "\n%f %f %f %d %d %d %d" , threshold, TPR, FPR, sum_TP, sum_TN, sum_FP, sum_FN );
                fclose(file_out);
        
                //updating threshold value
                threshold += threshold_step;
        }
        
        return 0;
}

void read_boxes_gt( string fileString , vector<vector<cv::Rect> >& boxes , int image_scale) 
{
        int num_det, x, y, w, h;
        vector<cv::Rect> instant_detections;
        char c[256];
        FILE * file_out;
        file_out = fopen (  fileString.c_str() , "r");
        fscanf(file_out, "%s " , c);
        bool eof_flag = 1;
        //while(  !feof(file_out) ){
        while( eof_flag )
        {
                fscanf (file_out, "%d", &num_det);
                instant_detections.clear();
                for( int i =0 ; i < num_det; i++)
                {
                        fscanf(file_out, " %d %d %d %d", &x , &y, &w, &h);
                        instant_detections.push_back( cv::Rect(x/image_scale,y/image_scale,w/image_scale,h/image_scale) );
                }
                boxes.push_back( instant_detections );
                fscanf(file_out, "\n%s " , c);
                if ( feof(file_out) ) eof_flag = 0;
        }
        fclose(file_out);       
}

void read_boxes_det( string fileString , vector<vector<Sbox_det> >& boxes ) 
{
        int num_det, x, y, w, h;
        float score;
        vector<Sbox_det> instant_detections;
        char c[256];
        FILE * file_out;
        file_out = fopen (  fileString.c_str() , "r");
        fscanf(file_out, "%s " , c);
        bool eof_flag = 1;
        //while(  !feof(file_out) ){
        while( eof_flag )
        {
                fscanf (file_out, "%d", &num_det);
                instant_detections.clear();
                for( int i =0 ; i < num_det; i++)
                {
                        fscanf(file_out, " %d %d %d %d %f", &x , &y, &w, &h , &score);
                        instant_detections.push_back( Sbox_det ( cv::Rect(x,y,w,h) , score  ) );
                }
                boxes.push_back( instant_detections );
                fscanf(file_out, "\n%s " , c);
                if ( feof(file_out) ) 
                        eof_flag = 0;
        }
        fclose(file_out);       
}


void viz_boxes( string imageString , vector<cv::Rect> detections , vector<cv::Rect> gt , vector<cv::Rect> accepted )
{
        cv::Mat inIm = cv::imread( imageString.c_str(), 1 );
        
        for (unsigned int i = 0; i< detections.size(); i++)
        {
                cv::rectangle( inIm ,  detections[i].tl(), detections[i].br(), cv::Scalar(0,0,255), 2  );
                printf( "Detection Box %d : x = %d, y = %d, w = %d, h = %d\n" , i, detections[i].x,detections[i].y,detections[i].width,detections[i].height );
        }
        for (unsigned int i = 0; i< gt.size(); i++)
        {
                        cv::rectangle( inIm ,  gt[i].tl(), gt[i].br(), cv::Scalar(255,0,0), 2  );
        }
        for (unsigned int i = 0; i< accepted.size(); i++)
        {
                        cv::rectangle( inIm ,  accepted[i].tl(), accepted[i].br(), cv::Scalar(0,255,0), 2  );
                        printf( "Accepted Box %d : x = %d, y = %d, w = %d, h = %d\n" , i, accepted[i].x,accepted[i].y,accepted[i].width,accepted[i].height );
        }
        cv::namedWindow("My Image" , CV_WINDOW_AUTOSIZE);
        cv::imshow("My Image",inIm);
        cv::waitKey(0);
        
}

string convertInt(int number)
{
        stringstream ss;//create a stringstream
        ss << number;//add number to the stream
        switch((int) log10( (float) number))
        {
                case 0 :
                        return "000" + ss.str();
                case 1 :
                        return "00" + ss.str();
                case 2 :
                        return "0" + ss.str();
                case 3 :
                        return ss.str();
        }

        return ss.str();//return a string with the contents of the stream
}