wxSystemScreenType wxSystemSettings::GetScreenType()
{
if (ms_screen == wxSYS_SCREEN_NONE)
{
// wxUniv will be used on small devices, too.
int x = GetMetric( wxSYS_SCREEN_X );
ms_screen = wxSYS_SCREEN_DESKTOP;
if (x < 800)
ms_screen = wxSYS_SCREEN_SMALL;
if (x < 640)
ms_screen = wxSYS_SCREEN_PDA;
if (x < 200)
ms_screen = wxSYS_SCREEN_TINY;
// This is probably a bug, but VNC seems to report 0
if (x < 10)
ms_screen = wxSYS_SCREEN_DESKTOP;
}
return ms_screen;
}
void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(m_border_pen);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
wxRect rect = _rect;
int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
if (pane.IsToolbar())
{
for (i = 0; i < border_width; ++i)
{
dc.SetPen(*wxWHITE_PEN);
dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
dc.SetPen(m_border_pen);
dc.DrawLine(rect.x, rect.y+rect.height-1,
rect.x+rect.width, rect.y+rect.height-1);
dc.DrawLine(rect.x+rect.width-1, rect.y,
rect.x+rect.width-1, rect.y+rect.height);
rect.Deflate(1);
}
}
else
{
for (i = 0; i < border_width; ++i)
{
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
rect.Deflate(1);
}
}
}
void WriteCache(b2SimplexCache* cache) const
{
cache->metric = GetMetric();
cache->count = uint16(m_count);
const b2SimplexVertex* vertices = &m_v1;
for (int32 i = 0; i < m_count; ++i)
{
cache->indexA[i] = uint8(vertices[i].indexA);
cache->indexB[i] = uint8(vertices[i].indexB);
}
}
void ReadCache( const b2SimplexCache* cache,
const b2DistanceProxy* proxyA, const b2Transform& transformA,
const b2DistanceProxy* proxyB, const b2Transform& transformB)
{
b2Assert(cache->count <= 3);
// Copy data from cache.
m_count = cache->count;
b2SimplexVertex* vertices = &m_v1;
for (int32 i = 0; i < m_count; ++i)
{
b2SimplexVertex* v = vertices + i;
v->indexA = cache->indexA[i];
v->indexB = cache->indexB[i];
b2Vec2 wALocal = proxyA->GetVertex(v->indexA);
b2Vec2 wBLocal = proxyB->GetVertex(v->indexB);
v->wA = b2Mul(transformA, wALocal);
v->wB = b2Mul(transformB, wBLocal);
v->w = v->wB - v->wA;
v->a = 0.0f;
}
// Compute the new simplex metric, if it is substantially different than
// old metric then flush the simplex.
if (m_count > 1)
{
float32 metric1 = cache->metric;
float32 metric2 = GetMetric();
if (metric2 < 0.5f * metric1 || 2.0f * metric1 < metric2 || metric2 < b2_epsilon)
{
// Reset the simplex.
m_count = 0;
}
}
// If the cache is empty or invalid ...
if (m_count == 0)
{
b2SimplexVertex* v = vertices + 0;
v->indexA = 0;
v->indexB = 0;
b2Vec2 wALocal = proxyA->GetVertex(0);
b2Vec2 wBLocal = proxyB->GetVertex(0);
v->wA = b2Mul(transformA, wALocal);
v->wB = b2Mul(transformB, wBLocal);
v->w = v->wB - v->wA;
v->a = 1.0f;
m_count = 1;
}
}
void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow* window, const wxRect& _rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(m_borderPen);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
wxRect rect = _rect;
int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
if (pane.IsToolbar())
{
for (i = 0; i < border_width; ++i)
{
dc.SetPen(*wxWHITE_PEN);
dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
dc.SetPen(m_borderPen);
dc.DrawLine(rect.x, rect.y+rect.height-1,
rect.x+rect.width, rect.y+rect.height-1);
dc.DrawLine(rect.x+rect.width-1, rect.y,
rect.x+rect.width-1, rect.y+rect.height);
rect.Deflate(1);
}
}
else
{
// notebooks draw the border themselves, so they can use native rendering (e.g. tabartgtk)
wxAuiTabArt* art = 0;
wxAuiNotebook* nb = wxDynamicCast(window, wxAuiNotebook);
if (nb)
art = nb->GetArtProvider();
if (art)
art->DrawBorder(dc, window, rect);
else
{
for (i = 0; i < border_width; ++i)
{
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
rect.Deflate(1);
}
}
}
}
void EDA_DOCKART::DrawBorder( wxDC& aDC, wxWindow* aWindow, const wxRect& aRect,
wxAuiPaneInfo& aPane )
{
const wxRect& r = aRect;
aDC.SetPen( m_borderPen );
aDC.SetBrush( *wxTRANSPARENT_BRUSH );
// notebooks draw the border themselves, so they can use native rendering (e.g. tabartgtk)
wxAuiTabArt* art = nullptr;
wxAuiNotebook* nb = wxDynamicCast( aWindow, wxAuiNotebook );
if( nb )
art = nb->GetArtProvider();
if( art )
{
art->DrawBorder( aDC, aWindow, r );
}
else if( aPane.name == "DrawFrame" || aPane.name == "DrawFrameGal" )
{
// We don't want to re-write the layout manager, so we give the canvas a single-pixel
// border and then fill in the top and left with the canvas background colour.
//
// This achieves a right-bottom-bordered canvas, which works reasonably well with
// wxWidgets right-bottom bordered toolbars.
//wxWindow* window = reinterpret_cast<wxWindow*>( m_frame->GetCanvas() );
//wxSize scrollbarSize = window->GetSize() - window->GetClientSize();
// Not sure why it takes a pen twice as wide as the border to fill it in, but it does.
#if 0
int borderWidth = GetMetric( wxAUI_DOCKART_PANE_BORDER_SIZE ) * 2;
int borderAdjust = borderWidth;
aDC.SetPen( wxPen( m_frame->GetDrawBgColor().ToColour(), borderWidth ) );
// Yes, this leaves me scratching my head too.
if( m_frame->IsType( FRAME_PCB )
|| m_frame->IsType( FRAME_PCB_MODULE_EDITOR )
|| m_frame->IsType( FRAME_PCB_MODULE_VIEWER )
|| m_frame->IsType( FRAME_PCB_MODULE_VIEWER_MODAL )
|| m_frame->IsType( FRAME_GERBER ) )
{
borderAdjust += 1;
}
// left
aDC.DrawLine( r.x + 1, r.y, r.x + 1, r.y + r.height - borderAdjust - scrollbarSize.y );
// top
aDC.DrawLine( r.x + 1, r.y, r.x + r.width - borderAdjust - scrollbarSize.x, r.y );
aDC.SetPen( m_borderPen );
// finish off bottom of left side (at end of scrollbar)
aDC.DrawLine( r.x, r.y + r.height - 1 - scrollbarSize.y, r.x, r.y + r.height - 1 );
// right
aDC.DrawLine( r.x + r.width, r.y, r.x + r.width, r.y + r.height - 1 );
// bottom
aDC.DrawLine( r.x, r.y + r.height - 1, r.x + r.width - 1, r.y + r.height - 1 );
#endif
}
else
{
aDC.DrawRectangle( r );
}
}
int wxSystemSettings::GetSystemMetric(int index)
{
return GetMetric((wxSystemMetric)index);
}
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;
}
PLOTLIB_INLINE ClusterMapPlot &ClusterMapPlot::SetMetric( Metric metric )
{
mStream << ", metric=" << GetMetric( metric );
return *this;
}
