MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
connect(ui->openButton, SIGNAL(clicked()), this, SLOT(Open()));
connect(ui->saveButton, SIGNAL(clicked()), this, SLOT(SaveImage()));
connect(ui->SSDButton, SIGNAL(clicked()), this, SLOT(SSD()));
connect(ui->SADButton, SIGNAL(clicked()), this, SLOT(SAD()));
connect(ui->NCCButton, SIGNAL(clicked()), this, SLOT(NCC()));
connect(ui->GTCheckBox, SIGNAL(clicked()), this, SLOT(GTOnOff()));
connect(ui->gaussianButton, SIGNAL(clicked()), this, SLOT(Gaussian()));
connect(ui->maxButton, SIGNAL(clicked()), this, SLOT(FindBestDisparity()));
connect(ui->bilateralButton, SIGNAL(clicked()), this, SLOT(Bilateral()));
connect(ui->segmentButton, SIGNAL(clicked()), this, SLOT(Segment()));
connect(ui->renderButton, SIGNAL(clicked()), this, SLOT(Render()));
connect(ui->renderSlider, SIGNAL(valueChanged(int)), this, SLOT(RenderSlider(int)));
connect(ui->magicButton, SIGNAL(clicked()), this, SLOT(MagicStereo(int)));
ui->GTCheckBox->setChecked(true);
ui->pixelErrorLabel->setText("");
ui->gaussianSigmaSpinBox->setValue(1.0);
ui->biSigmaSSpinBox->setValue(1.0);
ui->biSigmaISpinBox->setValue(20.0);
ui->renderSlider->setValue(100);
ui->SADOffsetBox->setValue(2);
ui->SSDOffsetBox->setValue(2);
ui->NCCOffsetBox->setValue(2);
ui->segmentGridBox->setValue(20);
ui->segmentColorSpinBox->setValue(20.0);
ui->segmentSpatialSpinBox->setValue(6.0);
ui->segmentIterBox->setValue(4);
m_Image1Display.setParent(ui->tab);
m_Image2Display.setParent(ui->tab_2);
m_GTDisplay.setParent(ui->tab_4);
m_DisparityDisplay.setParent(ui->tab_3);
m_ErrorDisplay.setParent(ui->tab_5);
m_RenderDisplay.setParent(ui->tab_6);
m_SegmentDisplay.setParent(ui->tab_7);
m_Image1Display.window = this;
m_Image2Display.window = this;
m_GTDisplay.window = this;
m_DisparityDisplay.window = this;
m_ErrorDisplay.window = this;
m_RenderDisplay.window = this;
m_SegmentDisplay.window = this;
ui->tabWidget->setCurrentIndex(0);
m_LastRow = 0;
m_SegmentIteration = 0;
m_MatchCost = NULL;
}
uint64_t x264_pixel_ssd_wxh( x264_pixel_function_t *pf, pixel *pix1, intptr_t i_pix1,
pixel *pix2, intptr_t i_pix2, int i_width, int i_height )
{
uint64_t i_ssd = 0;
int y;
int align = !(((intptr_t)pix1 | (intptr_t)pix2 | i_pix1 | i_pix2) & 15);
#define SSD(size) i_ssd += pf->ssd[size]( pix1 + y*i_pix1 + x, i_pix1, \
pix2 + y*i_pix2 + x, i_pix2 );
for( y = 0; y < i_height-15; y += 16 )
{
int x = 0;
if( align )
for( ; x < i_width-15; x += 16 )
SSD(PIXEL_16x16);
for( ; x < i_width-7; x += 8 )
SSD(PIXEL_8x16);
}
if( y < i_height-7 )
for( int x = 0; x < i_width-7; x += 8 )
SSD(PIXEL_8x8);
#undef SSD
#define SSD1 { int d = pix1[y*i_pix1+x] - pix2[y*i_pix2+x]; i_ssd += d*d; }
if( i_width & 7 )
{
for( y = 0; y < (i_height & ~7); y++ )
for( int x = i_width & ~7; x < i_width; x++ )
SSD1;
}
if( i_height & 7 )
{
for( y = i_height & ~7; y < i_height; y++ )
for( int x = 0; x < i_width; x++ )
SSD1;
}
#undef SSD1
return i_ssd;
}
int64_t x264_pixel_ssd_wxh( x264_pixel_function_t *pf, uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2, int i_width, int i_height )
{
int64_t i_ssd = 0;
int x, y;
#define SSD(size) i_ssd += pf->ssd[size]( pix1 + y*i_pix1 + x, i_pix1, \
pix2 + y*i_pix2 + x, i_pix2 );
for( y = 0; y < i_height-15; y += 16 )
{
for( x = 0; x < i_width-15; x += 16 )
SSD(PIXEL_16x16);
if( x < i_width-7 )
SSD(PIXEL_8x16);
}
if( y < i_height-7 )
for( x = 0; x < i_width-7; x += 8 )
SSD(PIXEL_8x8);
#undef SSD
#define SSD1 { int d = pix1[y*i_pix1+x] - pix2[y*i_pix2+x]; i_ssd += d*d; }
if( i_width % 8 != 0 )
{
for( y = 0; y < (i_height & ~7); y++ )
for( x = i_width & ~7; x < i_width; x++ )
SSD1;
}
if( i_height % 8 != 0 )
{
for( y = i_height & ~7; y < i_height; y++ )
for( x = 0; x < i_width; x++ )
SSD1;
}
#undef SSD1
return i_ssd;
}
static ::libmaus2::autoarray::AutoArray < ::libmaus2::graph::TripleEdge > decompatDecompacterSingle(
stream_type & stream,
uint64_t const numtotaledges,
uint64_t const srcbase
)
{
SingleStreamDecompacter<stream_type> SSD(stream,srcbase);
::libmaus2::autoarray::AutoArray< ::libmaus2::graph::TripleEdge > edges(numtotaledges,false);
for ( uint64_t i = 0; i < numtotaledges; ++i )
{
bool const ok = SSD.getNext(edges[i]);
assert ( ok );
}
return edges;
}
double TransformErrFunction::getErr(const Transform * T1, const Transform * T2, int inlierCount)
{
double projErr = 0;
for(TPointVec::iterator pPoint = pointVec_.begin(); pPoint != pointVec_.end(); pPoint++)
{
CvPoint2D64f point = *pPoint;
CvPoint2D64f transformedPoint1 = T1->applyToPoint(point);
CvPoint2D64f transformedPoint2 = T2->applyToPoint(point);
projErr += SSD(transformedPoint1, transformedPoint2);
}
if(eWeightByInlierCountSquared_ == eWeightByInlierCount)
{
projErr *= (double)(inlierCount);
}
else if(eWeightByInlierCountSquared_ == eWeightByInlierCountSquared)
{
projErr *= (double)(inlierCount*inlierCount);
}
return projErr;
}
int main()
{
//initiation
const char* imgname[4]={"Tsukuba","Venus","Teddy","Cones"};
int MAX_Disp[4]={16,20,60,60};
int scale[4]={16,8,4,4};
char imL[30],imR[30],imDisp[30],truedisp[30],non_occ[30];
IplImage *pImgl,*pImgr,*pDisp,*pTruedisp,*pNon_occ;
int w,h,step; //width,height,widthStep
unsigned char *left,*right,*disp,*groundtruth,*nonocc;
float time,err_nonocc;
for(int i=0;i<4;i++)
{
sprintf(imL,"img/%s/imL.png",imgname[i]);
sprintf(imR,"img/%s/imR.png",imgname[i]);
sprintf(truedisp,"img/%s/groundtruth.png",imgname[i]);
sprintf(non_occ,"img/%s/nonocc.png",imgname[i]);
printf("loading %s\n",imgname[i]);
pImgl = cvLoadImage(imL,0);
if(pImgl == NULL) printf("cannot open imgl!\n");
pImgr = cvLoadImage(imR,0);
if(pImgr == NULL) printf("cannot open imgr!\n");
pTruedisp = cvLoadImage(truedisp,0);
if(pTruedisp == NULL) printf("cannot open truedisp!\n");
pNon_occ = cvLoadImage(non_occ,0);
if(pNon_occ == NULL) printf("cannot open non_occ!\n");
pDisp = cvCreateImage(cvGetSize(pImgl),pImgl->depth,pImgl->nChannels);
w=pImgl->width;
h=pImgl->height;
step=pImgl->widthStep;
left = new unsigned char[w*h];
right = new unsigned char[w*h];
disp = new unsigned char[w*h];
groundtruth = new unsigned char[w*h];
nonocc = new unsigned char[w*h];
for(int y=0;y<h;y++)
for(int x=0;x<w;x++)
{
left[y*w+x] =(unsigned char) pImgl->imageData[y*step+x];
right[y*w+x] =(unsigned char) pImgr->imageData[y*step+x];
groundtruth[y*w+x] =(unsigned char) pTruedisp->imageData[y*step+x];
nonocc[y*w+x] =(unsigned char) pNon_occ->imageData[y*step+x];
}
//SAD
time=SAD(left,right,disp,w,h,MAX_Disp[i],scale[i]);
err_nonocc = eval_nonocc(groundtruth,disp,nonocc,w,h,scale[i]);
for(int y=0;y<h;y++)
for(int x=0;x<w;x++)
pDisp->imageData[y*step+x] = (char)disp[y*w+x];
sprintf(imDisp,"img/%s/disp_SAD.png",imgname[i]);
cvSaveImage(imDisp,pDisp);
printf("SAD algorithm\n");
printf("proccessing time:\t%6.3fms\n",time);
printf("Percentage of Bad Matching pixels:\t%6.3f%%\n",err_nonocc*100);
//SSD
time=SSD(left,right,disp,w,h,MAX_Disp[i],scale[i]);
err_nonocc = eval_nonocc(groundtruth,disp,nonocc,w,h,scale[i]);
for(int y=0;y<h;y++)
for(int x=0;x<w;x++)
pDisp->imageData[y*step+x] = (char)disp[y*w+x];
sprintf(imDisp,"img/%s/disp_SSD.png",imgname[i]);
cvSaveImage(imDisp,pDisp);
printf("SSD algorithm\n");
printf("proccessing time:\t%6.3fms\n",time);
printf("Percentage of Bad Matching pixels:\t%6.3f%%\n",err_nonocc*100);
//cudaSSD
time = cudaSSD(left,right,disp,w,h,MAX_Disp[i],scale[i]);
err_nonocc = eval_nonocc(groundtruth,disp,nonocc,w,h,scale[i]);
for(int y=0;y<h;y++)
for(int x=0;x<w;x++)
pDisp->imageData[y*step+x] = (char)disp[y*w+x];
sprintf(imDisp,"img/%s/disp_cudaSSD.png",imgname[i]);
cvSaveImage(imDisp,pDisp);
printf("cudaSSD algorithm\n");
printf("proccessing time:\t%6.3fms\n",time);
printf("Percentage of Bad Matching pixels:\t%6.3f%%\n",err_nonocc*100);
/* //cudaSAD
time = cudaSAD(left,right,disp,w,h,MAX_Disp[i],scale[i]);
err_nonocc = eval_nonocc(groundtruth,disp,nonocc,w,h,scale[i]);
for(int y=0;y<h;y++)
for(int x=0;x<w;x++)
pDisp->imageData[y*step+x] = (char)disp[y*w+x];
sprintf(imDisp,"img/%s/disp_cudaSAD.png",imgname[i]);
cvSaveImage(imDisp,pDisp);
printf("cudaSAD algorithm\n");
printf("proccessing time:\t%6.3fms\n",time);
printf("Percentage of Bad Matching pixels:\t%6.3f%%\n",err_nonocc*100);
*/
printf("\n");
delete []left;
delete []right;
delete []disp;
}
return 0;
}
void SelfSimDescriptor::compute(const Mat& img, vector<float>& descriptors, Size winStride,
const vector<Point>& locations) const
{
CV_Assert( img.depth() == CV_8U );
winStride.width = std::max(winStride.width, 1);
winStride.height = std::max(winStride.height, 1);
Size gridSize = getGridSize(img.size(), winStride);
int i, nwindows = locations.empty() ? gridSize.width*gridSize.height : (int)locations.size();
int border = largeSize/2 + smallSize/2;
int fsize = (int)getDescriptorSize();
vector<float> tempFeature(fsize+1);
descriptors.resize(fsize*nwindows + 1);
Mat ssd(largeSize, largeSize, CV_32F), mappingMask;
computeLogPolarMapping(mappingMask);
#if 0 //def _OPENMP
int nthreads = cvGetNumThreads();
#pragma omp parallel for num_threads(nthreads)
#endif
for( i = 0; i < nwindows; i++ )
{
Point pt;
float* feature0 = &descriptors[fsize*i];
float* feature = &tempFeature[0];
int x, y, j;
if( !locations.empty() )
{
pt = locations[i];
if( pt.x < border || pt.x >= img.cols - border ||
pt.y < border || pt.y >= img.rows - border )
{
for( j = 0; j < fsize; j++ )
feature0[j] = 0.f;
continue;
}
}
else
pt = Point((i % gridSize.width)*winStride.width + border,
(i / gridSize.width)*winStride.height + border);
SSD(img, pt, ssd);
// Determine in the local neighborhood the largest difference and use for normalization
float var_noise = 1000.f;
for( y = -1; y <= 1 ; y++ )
for( x = -1 ; x <= 1 ; x++ )
var_noise = std::max(var_noise, ssd.at<float>(largeSize/2+y, largeSize/2+x));
for( j = 0; j <= fsize; j++ )
feature[j] = FLT_MAX;
// Derive feature vector before exp(-x) computation
// Idea: for all x,a >= 0, a=const. we have:
// max [ exp( -x / a) ] = exp ( -min(x) / a )
// Thus, determine min(ssd) and store in feature[...]
for( y = 0; y < ssd.rows; y++ )
{
const schar *mappingMaskPtr = mappingMask.ptr<schar>(y);
const float *ssdPtr = ssd.ptr<float>(y);
for( x = 0 ; x < ssd.cols; x++ )
{
int index = mappingMaskPtr[x];
feature[index] = std::min(feature[index], ssdPtr[x]);
}
}
var_noise = -1.f/var_noise;
for( j = 0; j < fsize; j++ )
feature0[j] = feature[j]*var_noise;
Mat _f(1, fsize, CV_32F, feature0);
cv::exp(_f, _f);
}
}
