コード例 #1
0
ファイル: main.c プロジェクト: AmmarkoV/RoboVision
int DisparityMappingSettingsBenchmark()
{

    unsigned int locsettings[SETTINGS_COUNT];
    unsigned int locminsettings[SETTINGS_COUNT];
    unsigned int locmaxsettings[SETTINGS_COUNT];
    unsigned int locbestsettings[SETTINGS_COUNT];

    unsigned int locmetrics[METRICS_COUNT];
    unsigned int locminmetrics[METRICS_COUNT];
    unsigned int locmaxmetrics[METRICS_COUNT];
    unsigned int locbestmetrics[METRICS_COUNT];

    unsigned int best_edge_count = VisCortx_GetMetric(RESOLUTION_MEMORY_LIMIT_1BYTE) , edge_count = 0;
    unsigned int delay  = VisCortx_GetMetric(DEPTHMAP_DELAY_MICROSECONDS);
    unsigned int coverage  = VisCortx_GetMetric(LAST_DEPTH_MAP_COVERAGE);
    unsigned int too_close  = VisCortx_GetMetric(LAST_DEPTH_MAP_TOO_CLOSE_COVERAGE);

    unsigned int wndx=VisCortx_GetMetric(HORIZONTAL_BUFFER);
    unsigned int wndy=VisCortx_GetMetric(VERTICAL_BUFFER);
    unsigned int wndx_l=VisCortx_GetMetric(HORIZONTAL_BUFFER_LARGE);
    unsigned int wndy_l=VisCortx_GetMetric(VERTICAL_BUFFER_LARGE);
    unsigned int wndx_xl=VisCortx_GetMetric(HORIZONTAL_BUFFER_EXTRALARGE);
    unsigned int wndy_xl=VisCortx_GetMetric(VERTICAL_BUFFER_EXTRALARGE);

    int processed = 0;

locbestsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]=VisCortx_GetSetting(DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT);
locminsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]=6;
locmaxsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]=6;

//locbestsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN]=VisCortx_GetSetting(DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN);
//locminsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN]=9;
//locmaxsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN]=12;

locbestsettings[DEPTHMAP_DETAIL]=VisCortx_GetSetting(DEPTHMAP_DETAIL);
locminsettings[DEPTHMAP_DETAIL]=6;
locmaxsettings[DEPTHMAP_DETAIL]=6;


locbestsettings[PATCH_HIST_THRESHOLD_R]=VisCortx_GetSetting(PATCH_HIST_THRESHOLD_R);
locminsettings[PATCH_HIST_THRESHOLD_R]=7;
locmaxsettings[PATCH_HIST_THRESHOLD_R]=7;


locbestsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]=VisCortx_GetSetting(PATCH_COMPARISON_EDGES_PERCENT_REQUIRED);
locminsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]=13;
locmaxsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]=13;


locbestmetrics[HORIZONTAL_BUFFER]=VisCortx_GetMetric(HORIZONTAL_BUFFER);
locminmetrics[HORIZONTAL_BUFFER]=8;
locmaxmetrics[HORIZONTAL_BUFFER]=8;



locbestsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]=VisCortx_GetSetting(DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE);
locminsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]=5;
locmaxsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]=5;


//locbestmetrics[VERTICAL_BUFFER]=VisCortx_GetMetric(VERTICAL_BUFFER);
//locminmetrics[VERTICAL_BUFFER]=7;
//locmaxmetrics[VERTICAL_BUFFER]=10;

VisCortx_SetSetting(PATCH_COMPARISON_LEVELS,2);



unsigned int totalloops =  1;
totalloops *=   1+( locmaxmetrics[HORIZONTAL_BUFFER] - locminmetrics[HORIZONTAL_BUFFER] );
totalloops *=   1+( locmaxsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE] - locminsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE] );
totalloops *=   1+( locmaxsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED] - locminsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED] );
totalloops *=   1+( locmaxsettings[PATCH_HIST_THRESHOLD_R] - locminsettings[PATCH_HIST_THRESHOLD_R] );
totalloops *=   1+( locmaxsettings[DEPTHMAP_DETAIL] - locminsettings[DEPTHMAP_DETAIL] );
totalloops *=   1+( locmaxsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT] - locminsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT] );

fprintf(stderr,"\n\n\n\nWill Perform a total of %u loops , assuming 1second per loop we will wait for %u seconds or %0.2f minutes\n\n\n\n",totalloops,totalloops,(float) totalloops/60);


//THE MAIN LOOP
for ( locsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]=locminsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE];
      locsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]<=locmaxsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE];
      locsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]++ )
{

for ( locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]=locminsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT];
      locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]<=locmaxsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT];
      locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]++ )
{
for ( locsettings[PATCH_HIST_THRESHOLD_R]=locminsettings[PATCH_HIST_THRESHOLD_R];
       locsettings[PATCH_HIST_THRESHOLD_R]<=locmaxsettings[PATCH_HIST_THRESHOLD_R];
       locsettings[PATCH_HIST_THRESHOLD_R]++)
 {
for ( locsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]=locminsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED];
       locsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]<=locmaxsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED];
       locsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]++)
{
 for ( locsettings[DEPTHMAP_DETAIL]=locminsettings[DEPTHMAP_DETAIL];
       locsettings[DEPTHMAP_DETAIL]<=locmaxsettings[DEPTHMAP_DETAIL];
       locsettings[DEPTHMAP_DETAIL]++)
   {
    for ( locmetrics[HORIZONTAL_BUFFER]=locminmetrics[HORIZONTAL_BUFFER];
          locmetrics[HORIZONTAL_BUFFER]<=locmaxmetrics[HORIZONTAL_BUFFER];
          locmetrics[HORIZONTAL_BUFFER]++)
     {


        VisCortx_SetMetric(HORIZONTAL_BUFFER,locmetrics[HORIZONTAL_BUFFER]);               VisCortx_SetMetric(VERTICAL_BUFFER,locmetrics[HORIZONTAL_BUFFER]);
        VisCortx_SetMetric(HORIZONTAL_BUFFER_LARGE,2*locmetrics[HORIZONTAL_BUFFER]);       VisCortx_SetMetric(VERTICAL_BUFFER_LARGE,2*locmetrics[HORIZONTAL_BUFFER]);
        VisCortx_SetMetric(HORIZONTAL_BUFFER_EXTRALARGE,3*locmetrics[HORIZONTAL_BUFFER]);  VisCortx_SetMetric(VERTICAL_BUFFER_EXTRALARGE,3*locmetrics[HORIZONTAL_BUFFER]);

        VisCortx_SetSetting(DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE,locsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]);
        VisCortx_SetSetting(DEPTHMAP_DETAIL,locsettings[DEPTHMAP_DETAIL]);
        VisCortx_SetSetting(PATCH_COMPARISON_EDGES_PERCENT_REQUIRED,locsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]);
        VisCortx_SetSetting(PATCH_COMPARISON_EDGES_PERCENT_REQUIRED_LARGE_PATCH,locsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]*2);
        VisCortx_SetSetting(PATCH_COMPARISON_EDGES_PERCENT_REQUIRED_EXTRALARGE_PATCH,locsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]*3);


        locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN] = locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT] * 2;
        VisCortx_SetSetting(DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT,locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]);
        VisCortx_SetSetting(DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN,locsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN]);


        VisCortx_SetSetting(PATCH_HIST_THRESHOLD_R,locbestsettings[PATCH_HIST_THRESHOLD_R]);     VisCortx_SetSetting(PATCH_HIST_THRESHOLD_R,locbestsettings[PATCH_HIST_THRESHOLD_R]);     VisCortx_SetSetting(PATCH_HIST_THRESHOLD_R,locbestsettings[PATCH_HIST_THRESHOLD_R]);

        VisCortx_FullDepthMap(0);



        ExecutePipeline();
        ++processed;


        VisCortx_PrepareCleanSobeledGaussianAndDerivative(DEPTH_LEFT_VIDEO,GENERAL_4,GENERAL_5,30,255);
        edge_count = VisCortx_CountEdges(GENERAL_4,0,0,VisCortx_GetMetric(LEFT_EYE),VisCortx_GetMetric(RIGHT_EYE));

        if ( (we_have_a_disparity_ground_truth)&&(ground!=0) )
         {
           unsigned char * depth_video = VisCortx_ReadFromVideoRegister(DEPTH_LEFT_VIDEO,GetMetric(RESOLUTION_X),GetMetric(RESOLUTION_Y),3);
           unsigned long diff=AbsDifferenceTotalRGBAsMono(ground,depth_video,GetMetric(RESOLUTION_X)*GetMetric(RESOLUTION_Y)*3);
           fprintf(stderr,"DIFFERENCE WITH GROUND TRUTH IS %u \n",diff);
         }

        if (processed % 10 == 0) {  fprintf(stderr,"\n\n DONE WITH %u/%u \n\n",processed,totalloops); printf("\n\n DONE WITH %u/%u \n\n",processed,totalloops); }

        if (
                 ( delay <= VisCortx_GetMetric(DEPTHMAP_DELAY_MICROSECONDS) )
              && ( coverage <= VisCortx_GetMetric(LAST_DEPTH_MAP_COVERAGE) )
              && ( edge_count <= best_edge_count )
              //&& ( too_close <= VisCortx_GetMetric(LAST_DEPTH_MAP_TOO_CLOSE_COVERAGE) )
            )
            {
                VisCortX_SaveVideoRegisterToFile(DEPTH_LEFT_VIDEO,out_filename);

                VisCortX_SaveVideoRegisterToFile(EDGES_LEFT,out_filenameedges);
                VisCortX_SaveVideoRegisterToFile(SECOND_DERIVATIVE_LEFT,out_filename2nd);
                VisCortX_SaveVideoRegisterToFile(GENERAL_4,out_filenamedepthedges);

                best_edge_count = edge_count;
                delay  = VisCortx_GetMetric(DEPTHMAP_DELAY_MICROSECONDS);
                coverage  = VisCortx_GetMetric(LAST_DEPTH_MAP_COVERAGE);
                too_close  = VisCortx_GetMetric(LAST_DEPTH_MAP_TOO_CLOSE_COVERAGE);

                locbestsettings[PATCH_HIST_THRESHOLD_R]=VisCortx_GetSetting(PATCH_HIST_THRESHOLD_R);
                locbestsettings[PATCH_HIST_THRESHOLD_G]=locbestsettings[PATCH_HIST_THRESHOLD_R];
                locbestsettings[PATCH_HIST_THRESHOLD_B]=locbestsettings[PATCH_HIST_THRESHOLD_R];

                locbestsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]=VisCortx_GetSetting(DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE);

                locbestsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN]=VisCortx_GetSetting(DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN);
                locbestsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]=VisCortx_GetSetting(DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT);


                locbestsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]=VisCortx_GetSetting(PATCH_COMPARISON_EDGES_PERCENT_REQUIRED);

                locbestsettings[DEPTHMAP_DETAIL]=VisCortx_GetSetting(DEPTHMAP_DETAIL);


                locbestmetrics[HORIZONTAL_BUFFER]=VisCortx_GetMetric(HORIZONTAL_BUFFER);
                locbestmetrics[VERTICAL_BUFFER]=VisCortx_GetMetric(VERTICAL_BUFFER);
            }
     }
   }
}
 }
}
}


  VisCortx_GetHyperVisorStatus(1,0,0);

  fprintf(stderr,"\n\n\n\n\n\n");
  fprintf(stderr,"Best DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT = %u \n",locbestsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_RIGHT]);
  fprintf(stderr,"Best DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN = %u \n",locbestsettings[DEPTHMAP_COMPARISON_DECIDES_FOR_MORE_PIXELS_DOWN]);
  fprintf(stderr,"Best Histogram Threshold = %u \n",locbestsettings[PATCH_HIST_THRESHOLD_R]);
  fprintf(stderr,"Best Edges Percent = %u \n",locbestsettings[PATCH_COMPARISON_EDGES_PERCENT_REQUIRED]);
  fprintf(stderr,"Best Detail = %u \n",locbestsettings[DEPTHMAP_DETAIL]);
  fprintf(stderr,"Best Previous PATCH anchor  size = %u \n",locbestsettings[DEPTHMAP_PREVIOUS_PATCH_SIZE_MAX_DISTANCE]);
  fprintf(stderr,"Best Window size = %u x %u \n",locbestmetrics[HORIZONTAL_BUFFER],locbestmetrics[VERTICAL_BUFFER]);
  fprintf(stderr,"Best Edge Count = %u , OpenCV count = %u , RGB count = %u \n",best_edge_count,opencv_depth_edges,rgb_edges);
  fprintf(stderr,"Best output delay %u ms , coverage %u %% , too close %u %%\n",delay,coverage,too_close);


 return 1;
}
コード例 #2
0
int SnapWebCams()
{

 if (has_init==0) { fprintf(stderr,"!"); VideoFeedsNotAccessible=1; return 0; }

 if ( (!VisCortx_VideoRegistersSynced(LEFT_EYE,CALIBRATED_LEFT_EYE)) ||
      (!VisCortx_VideoRegistersSynced(RIGHT_EYE,CALIBRATED_RIGHT_EYE))
     )
  {
       fprintf(stderr,"Feeds not synchronized , not copying frame \n");
       return 0;
  }

if (USE_VIS_CORTEX_LOCKS)
{
 unsigned int wait_time=0 , MAX_WAIT = 1000;
 while ( wait_time < MAX_WAIT )
 {
   if ( ! VisCortx_CheckTheFramesLeftRightForLock() )
   {
       break;
   }
   ++wait_time;
   wxMilliSleep(10);
 }
 if ( wait_time >= MAX_WAIT )
  {
      fprintf(stderr,"Feeds locked , not copying frame \n");
      return 0;
  }

 VisCortx_OperationLockFramesLeftRight();
}

 if (last_viscrtx_pass==VisCortx_GetTime()) { return 0; }
 last_viscrtx_pass=VisCortx_GetTime();

 VideoFeedsNotAccessible=0;

 if ( live_feeds[0].bmp_allocated ) { live_feeds[0].bmp_allocated = false; delete live_feeds[0].bmp;  live_feeds[0].bmp=0; }
 if ( live_feeds[1].bmp_allocated ) { live_feeds[1].bmp_allocated = false; delete live_feeds[1].bmp;  live_feeds[1].bmp=0; }


 if ( GetVideoRegister(CALIBRATED_LEFT_EYE) != 0)
 {                                                //
    live_feeds[0].img.SetData(GetVideoRegister(CALIBRATED_LEFT_EYE),GetCortexMetric(RESOLUTION_X),GetCortexMetric(RESOLUTION_Y),true);
    if ( resc_width != GetCortexMetric(RESOLUTION_X) ) { live_feeds[0].img.Rescale(resc_width,resc_height); }
    live_feeds[0].bmp= new wxBitmap(live_feeds[0].img);
    live_feeds[0].bmp_allocated = true;
 }

 if ( GetVideoRegister(CALIBRATED_RIGHT_EYE) != 0)
 {                                               //
  live_feeds[1].img.SetData(GetVideoRegister(CALIBRATED_RIGHT_EYE),GetCortexMetric(RESOLUTION_X),GetCortexMetric(RESOLUTION_Y),true);
  if ( resc_width != GetCortexMetric(RESOLUTION_X) ) { live_feeds[1].img.Rescale(resc_width,resc_height); }
  live_feeds[1].bmp= new wxBitmap(live_feeds[1].img);
  live_feeds[1].bmp_allocated = true;
 }




if ( last_time_of_left_operation != VisCortx_GetVideoRegisterData(LAST_LEFT_OPERATION,0) )
    {
         last_time_of_left_operation= VisCortx_GetVideoRegisterData(LAST_LEFT_OPERATION,0);
         PassVideoRegisterToFeed ( 2 , VisCortx_ReadFromVideoRegister(LAST_LEFT_OPERATION,GetCortexMetric(RESOLUTION_X),GetCortexMetric(RESOLUTION_Y),3),3 );
    } else
  if ( last_time_of_left_depth_map != VisCortx_GetVideoRegisterData(DEPTH_LEFT_VIDEO,0) )
    {
         last_time_of_left_depth_map= VisCortx_GetVideoRegisterData(DEPTH_LEFT_VIDEO,0);
         PassVideoRegisterToFeed ( 2 , VisCortx_ReadFromVideoRegister(DEPTH_LEFT_VIDEO,GetCortexMetric(RESOLUTION_X),GetCortexMetric(RESOLUTION_Y),3),3 );
    }


  if ( last_time_of_right_operation != VisCortx_GetVideoRegisterData(LAST_RIGHT_OPERATION,0) )
    {
         last_time_of_right_operation= VisCortx_GetVideoRegisterData(LAST_RIGHT_OPERATION,0);
         PassVideoRegisterToFeed ( 3 , VisCortx_ReadFromVideoRegister(LAST_RIGHT_OPERATION,GetCortexMetric(RESOLUTION_X),GetCortexMetric(RESOLUTION_Y),3),3 );
    } else
    if ( last_time_of_right_depth_map != VisCortx_GetVideoRegisterData(DEPTH_RIGHT_VIDEO,0) )
    {
         last_time_of_right_depth_map= VisCortx_GetVideoRegisterData(DEPTH_RIGHT_VIDEO,0);
         PassVideoRegisterToFeed ( 3 , VisCortx_ReadFromVideoRegister(DEPTH_RIGHT_VIDEO,GetCortexMetric(RESOLUTION_X),GetCortexMetric(RESOLUTION_Y),3),3 );
    }

  if (USE_VIS_CORTEX_LOCKS)
  {
    VisCortx_OperationUnLockFramesLeftRight();
  }


  return 1 ;
}