void CPMPDatView::OnInitialUpdate()
{
CView::OnInitialUpdate();
// TODO: Add your specialized code here and/or call the base class
CPMPDatDoc* pDoc = GetDocument();
GetParent()->SetWindowTextA(GetDocument()->GetTitle()+_T("-Vector"));
m_visualizer.PMPVisualizeVector3D(filename,m_pvtkRenderer);
ExecutePipeline();
}
void CvtkMDIView::OnInitialUpdate()
{
CView::OnInitialUpdate();
this->pvtkMFCWindow = new vtkMFCWindow(this);
this->pvtkMFCWindow->GetRenderWindow()->AddRenderer(this->pvtkRenderer);
// execute object pipeline
ExecutePipeline();
}
void CPMPScalarDatGridView::OnInitialUpdate()
{
CView::OnInitialUpdate();
CPMPScalarDatDoc* pDoc = GetDocument();
GetParent()->SetWindowTextA(GetDocument()->GetTitle()+_T("-Volume"));
m_visualizer.PMPVisualizeVolumn(filename,m_pvtkRenderer);
//pmpvisualizationgrid(filename);
// TODO: Add your specialized code here and/or call the base class
ExecutePipeline();
}
BOOL CvtkSDIDoc::OnNewDocument()
{
if (!CDocument::OnNewDocument())
return FALSE;
// remove old actors
RemoveActors();
// execute object pipeline
ExecutePipeline();
return TRUE;
}
BOOL CvtkSDIDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
if (!CDocument::OnOpenDocument(lpszPathName))
return FALSE;
// remove old actors
RemoveActors();
// create new data reader
this->pvtkDataSetReader = vtkDataSetReader::New();
this->pvtkDataSetReader->SetFileName(lpszPathName);
// execute object pipeline
ExecutePipeline();
return TRUE;
}
int CVolumeViewer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: on_pushButtonDisplayVolume_clicked(); break;
case 1: on_pushButtonBrowse_clicked(); break;
case 2: on_pushButtonSaveToVTK_clicked(); break;
case 3: on_pushButtonSaveToVol_clicked(); break;
case 4: on_pushButtonReset_clicked(); break;
case 5: ExecutePipeline(); break;
case 6: RedoIndexes(); break;
}
_id -= 7;
}
return _id;
}
int DisparityOpenCV()
{
VisCortx_SetSetting(DEPTHMAP_USE_OPENCV,1);
VisCortx_SetSetting(USE_OPENCV,1);
VisCortx_FullDepthMap(0);
ExecutePipeline();
VisCortX_SaveVideoRegisterToFile(DEPTH_LEFT_VIDEO,opencv_filename);
VisCortx_PrepareCleanSobeledGaussianAndDerivative(DEPTH_LEFT_VIDEO,GENERAL_4,GENERAL_5,30,255);
VisCortX_SaveVideoRegisterToFile(GENERAL_4,opencv_filenamedepthedges);
opencv_depth_edges = VisCortx_CountEdges(GENERAL_4,0,0,VisCortx_GetMetric(LEFT_EYE),VisCortx_GetMetric(RIGHT_EYE));
VisCortx_SetSetting(DEPTHMAP_USE_OPENCV,0);
VisCortx_SetSetting(USE_OPENCV,0);
return 1;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int main (int argc, char* argv[])
{
// Instantiate the QCoreApplication that we need to get the current path and load plugins.
QCoreApplication app(argc, argv);
QCoreApplication::setOrganizationName("BlueQuartz Software");
QCoreApplication::setOrganizationDomain("bluequartz.net");
QCoreApplication::setApplicationName("PipelineRunnerTest");
// We need to change our working directory into the "DREAM3D_Data" directory because all the pipelines use relative paths
QDir dataDir = QDir(getDream3dDataDir());
#ifdef _MSC_VER
_chdir(dataDir.absolutePath().toLatin1().constData());
#else
chdir(dataDir.absolutePath().toLatin1().constData());
#endif
// Register all the filters including trying to load those from Plugins
FilterManager* fm = FilterManager::Instance();
SIMPLibPluginLoader::LoadPluginFilters(fm);
// Send progress messages from PipelineBuilder to this object for display
QMetaObjectUtilities::RegisterMetaTypes();
int err = 0;
// Read in the contents of the PipelineList file which contains all the Pipelines that we want
// to execute
QString contents;
{
// Read the Source File
QFileInfo fi(getPipelineListFile());
QFile source(getPipelineListFile());
source.open(QFile::ReadOnly);
contents = source.readAll();
source.close();
}
// Split the file into tokens using the newline character
QStringList list = contents.split(QRegExp("\\n"));
QStringListIterator sourceLines(list);
// Iterate over all the entries in the file and process each pipeline. Note that the order of the
// pipelines will probably matter
int testNum = 0;
while (sourceLines.hasNext())
{
QString pipelineFile = sourceLines.next();
pipelineFile = pipelineFile.trimmed();
if(pipelineFile.isEmpty()) { continue; }
try
{
QFileInfo fi(pipelineFile);
pipelineFile = AdjustOutputDirectory(pipelineFile);
DREAM3D::unittest::CurrentMethod = fi.fileName().toStdString();
DREAM3D::unittest::numTests++;
std::cout << "\"" << testNum++ << "\": {" << std::endl;
ExecutePipeline(pipelineFile);
TestPassed(fi.fileName().toStdString());
std::cout << "}," << std::endl;
DREAM3D::unittest::CurrentMethod = "";
}
catch (TestException& e)
{
TestFailed(DREAM3D::unittest::CurrentMethod);
std::cout << e.what() << std::endl;
err = EXIT_FAILURE;
}
}
QDir tempDir(getTestTempDirectory());
tempDir.removeRecursively();
return err;
}
int main(int argc, const char* argv[])
{
printf("Visual Cortex %s !\n",VisCortx_Version());
if ( argc > 3 )
{
strcpy(filename0,argv[1]);
strcpy(filename1,argv[2]);
strcpy(out_filename,argv[3]); strcat(out_filename2nd,(char*)"_gddg_2nd");
strcpy(out_filename2nd,argv[3]); strcat(out_filename2nd,(char*)"_gddg_2nd");
strcpy(out_filenameedges,argv[3]); strcat(out_filenameedges,(char*)"_gddg_edges");
strcpy(out_filenamedepthedges,argv[3]); strcat(out_filenamedepthedges,(char*)"_gddg_edges_depth");
strcpy(opencv_filename,argv[3]); strcat(opencv_filename,(char*)"_opencv");
strcpy(opencv_filenamedepthedges,argv[3]); strcat(opencv_filenamedepthedges,(char*)"_opencv_edges_depth");
if ( argc >= 4 )
{
strcpy(disparity_ground_truth_filename,argv[4]); we_have_a_disparity_ground_truth=1;
printf("Ground Truth file is %s \n",disparity_ground_truth_filename);
}
} else
{
fprintf(stderr,"Usage : VisCortx_Tester RESOLUTIONX RESOLUTIONY left_image.ppm right_image.ppm output.ppm\n");
fprintf(stderr,"ie : VisCortx_Tester imageLEFT.ppm imageRIGHT.ppm depth.ppm\n");
return 1;
}
vid0 = LoadRegisterFromFileInternal(filename0,&resolution_width,&resolution_height);
if (vid0==0) { fprintf(stderr,"Could not load image %s ",filename0); return 1; }
vid1 = LoadRegisterFromFileInternal(filename1,&resolution_width,&resolution_height);
if (vid1==0) { fprintf(stderr,"Could not load image %s ",filename1); return 1; }
if (we_have_a_disparity_ground_truth)
{ ground =LoadRegisterFromFileInternal(disparity_ground_truth_filename,&resolution_width,&resolution_height); }
if (ground==0) { fprintf(stderr,"Could not load a ground truth image\n"); }
VisCortx_Start(resolution_width,resolution_height,"./");
//DISABLE STUFF THAT ARE NOT NEEDED FOR DISPARITY MAPPING..
VisCortx_SetSetting(PASS_TO_FACE_DETECTOR,0);
VisCortx_SetSetting(PASS_TO_FEATURE_DETECTOR,0);
VisCortx_SetSetting(DEPTHMAP_USE_OPENCV,0);
VisCortx_SetSetting(USE_OPENCV,0);
VisCortx_SetSetting(DEPTHMAP_OPENCV_LIKE_OUTPUT,1);
VisCortx_SetSetting(CALCULATE_MOVEMENT_FLOW,0);
VisCortx_SetSetting(DEPTHMAP_VERT_SHIFT_UP,0);
VisCortx_SetSetting(DEPTHMAP_VERT_SHIFT_DOWN,0);
VisCortx_SetSetting(DEPTHMAP_VERT_OFFSET_UP,0);
VisCortx_SetSetting(DEPTHMAP_VERT_OFFSET_DOWN,0);
VisCortx_SetTime(10);
VisCortX_NewFrame(LEFT_EYE,resolution_width,resolution_height,3,(unsigned char * ) vid0);
VisCortX_NewFrame(RIGHT_EYE,resolution_width,resolution_height,3,(unsigned char * ) vid1);
//Fire Depth map one time to get edges .. etc
VisCortx_FullDepthMap(0);
ExecutePipeline();
VisCortX_SaveVideoRegisterToFile(DEPTH_LEFT_VIDEO,out_filename);
//Store edge count
rgb_edges = VisCortx_CountEdges(EDGES_LEFT,0,0,VisCortx_GetMetric(LEFT_EYE),VisCortx_GetMetric(RIGHT_EYE));
//Frames Are loaded and ready for our processing ..
DisparityOpenCV(); //This is used as a guide
DisparityMappingSettingsBenchmark();
//Our processing is done ....
VisCortx_Stop();
free(vid0);
free(vid1);
return 0;
}
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;
}
