void ADCensus::disparityMapFromRGB(QUrl leftImageUrl, QUrl rightImageUrl) { std::string left = leftImageUrl.toLocalFile().toStdString(); std::string right = rightImageUrl.toLocalFile().toStdString(); cout << "Opening [" << left << " " << right << "]" << endl; RGB24Buffer *leftImage = BMPLoader().loadRGB(left); RGB24Buffer *rightImage = BMPLoader().loadRGB(right); G8Buffer *leftGray = leftImage->getChannel(ImageChannel::GRAY); G8Buffer *rightGray = rightImage->getChannel(ImageChannel::GRAY); AbstractBuffer<int32_t> disparities = constructDisparityMap(leftImage, rightImage, leftGray, rightGray); G8Buffer *result = new G8Buffer(disparities.getSize()); for (int x = 0; x < result->w; ++x) { for (int y = 0; y < result->h; ++y) { result->element(y,x) = (disparities.element(y, x) / (double)result->w * 255 * 3); } } BMPLoader().save("result.bmp", result); cout << "Resulting disparity map saved to result.bmp\n"; delete leftImage; delete rightImage; delete leftGray; delete rightGray; delete result; }
SCProg::SCProg(const std::string &src_file) { #ifndef __APPLE__ AbstractBuffer * src = new FileBuffer(std::string("./shaders/")+src_file); d_ready = false; d_program = glCreateProgram(); d_shader = glCreateShader (GL_COMPUTE_SHADER); const char * source = (const char *) src->buffer(); int len = strlen(source); glShaderSource (d_shader,1 , &source, &len); delete src; // bad glCompileShader(d_shader); GLint compileStatus; GLint compileLogsz; glGetShaderiv ( d_shader, GL_COMPILE_STATUS, &compileStatus ); glGetShaderiv ( d_shader, GL_INFO_LOG_LENGTH, &compileLogsz ); char *errorLog; if ( compileStatus == 0 ) { GLint logRecived; errorLog = (char *)calloc(compileLogsz,sizeof(char)); glGetShaderInfoLog(d_shader,compileLogsz,&logRecived, errorLog); std::string e_log(errorLog); free(errorLog); LOGE("Compute shader build failed:\n",e_log.c_str()); /*TODO proper cleanup*/ return; } glAttachShader(d_program, d_shader); GLint linkStatus; GLint linkLogsz; glLinkProgram (d_program); glGetProgramiv ( d_program, GL_LINK_STATUS, &linkStatus ); glGetProgramiv ( d_program, GL_INFO_LOG_LENGTH, &linkLogsz); if ( linkStatus == 0 ) { GLint logRecived; errorLog = (char *)calloc(linkLogsz,sizeof(char)); glGetProgramInfoLog(d_program,linkLogsz,&logRecived, errorLog); std::string e_log(errorLog); free(errorLog); LOGE("Compute shader link failed: %s\n",e_log.c_str()); return; } #endif d_ready = true; }
void RGB24Buffer::drawIsolines( double zx, double zy, double zh, double zw, double steps, FunctionArgs &f) { int i,j; if (f.inputs < 2) return; AbstractBuffer<double> *values = new AbstractBuffer<double>(this->getSize()); double *in = new double[f.inputs ]; double *out = new double[f.outputs]; for (int i = 0; i < f.inputs; i++) { in[i] = 0.0; } for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { in[0] = (i * zh / h) + zy; in[1] = (j * zw / w) + zx; f(in, out); values->element(i,j) = out[0]; /* if (j == w / 2) { printf("out: [%d %d] %lf\n", i, j, out[0]); }*/ } } for (i = 1; i < h - 1; i++) { for (j = 1; j < w - 1; j++) { double c = values->element(i,j); double r = values->element(i,j + 1); double l = values->element(i + 1,j); double ls = ((int) (c * steps)) / steps; double hs = ((int) (c * steps) + 1) / steps; if (r < ls || r > hs || l < ls || l > hs ) element(i,j) = RGBColor::gray(128); } } deletearr_safe(in); deletearr_safe(out); delete_safe(values); }
AbstractBuffer<int32_t> ADCensus::constructDisparityMap(const AbstractBuffer<pixel> *leftImage, const AbstractBuffer<pixel> *rightImage, const AbstractBuffer<grayPixel> *leftGrayImage, const AbstractBuffer<grayPixel> *rightGrayImage) { // Initialization int width = leftImage->w; int height = leftImage->h; BaseTimeStatisticsCollector collector; Statistics outerStats; outerStats.setValue("H", height); outerStats.setValue("W", width); AbstractBuffer<int32_t> bestDisparities = AbstractBuffer<int32_t>(height, width); AbstractBuffer<COST_TYPE> minCosts = AbstractBuffer<COST_TYPE>(height, width); minCosts.fillWith(-1); // Disparity computation outerStats.startInterval(); AbstractBuffer<int64_t> leftCensus = AbstractBuffer<int64_t>(height, width); AbstractBuffer<int64_t> rightCensus = AbstractBuffer<int64_t>(height, width); makeCensus(leftGrayImage, leftCensus); makeCensus(rightGrayImage, rightCensus); outerStats.resetInterval("Making census"); makeAggregationCrosses(leftImage); outerStats.resetInterval("Making aggregation crosses"); for (uint i = 0; i < CORE_COUNT_OF(table1); i++) { table1[i] = robust(i, lambdaCT); table2[i] = robust(i, lambdaAD); } bool parallelDisp = true; parallelable_for(0, width / 3, [this, &minCosts, &bestDisparities, &leftImage, &rightImage, &leftCensus, &rightCensus, &collector, height, width, parallelDisp](const BlockedRange<int> &r) { for (int d = r.begin(); d != r.end(); ++d) { Statistics stats; stats.startInterval(); AbstractBuffer<COST_TYPE> costs = AbstractBuffer<COST_TYPE>(height, width); stats.resetInterval("Matrix construction"); parallelable_for(windowHh, height - windowHh, [this, &costs, &leftImage, &rightImage, &leftCensus, &rightCensus, d, width](const BlockedRange<int> &r) { for (int y = r.begin(); y != r.end(); ++y) { auto *im1 = &leftImage->element(y, windowWh + d); auto *im2 = &rightImage->element(y, windowWh); int64_t *cen1 = &leftCensus.element(y, windowWh + d); int64_t *cen2 = &rightCensus.element(y, windowWh); int x = windowWh + d; #ifdef WITH_SSE for (; x < width - windowWh; x += 8) { FixedVector<Int16x8, 4> c1 = SSEReader8BBBB_DDDD::read((uint32_t *)im1); FixedVector<Int16x8, 4> c2 = SSEReader8BBBB_DDDD::read((uint32_t *)im2); UInt16x8 dr = SSEMath::difference(UInt16x8(c1[RGBColor::FIELD_R]), UInt16x8(c2[RGBColor::FIELD_R])); UInt16x8 dg = SSEMath::difference(UInt16x8(c1[RGBColor::FIELD_G]), UInt16x8(c2[RGBColor::FIELD_G])); UInt16x8 db = SSEMath::difference(UInt16x8(c1[RGBColor::FIELD_B]), UInt16x8(c2[RGBColor::FIELD_B])); UInt16x8 ad = (dr + dg + db) >> 2; Int16x8 cost_ad = Int16x8(robustLUTAD(ad[0]), robustLUTAD(ad[1]), robustLUTAD(ad[2]), robustLUTAD(ad[3]), robustLUTAD(ad[4]), robustLUTAD(ad[5]), robustLUTAD(ad[6]), robustLUTAD(ad[7])); Int64x2 cen10(&cen1[0]); Int64x2 cen12(&cen1[2]); Int64x2 cen14(&cen1[4]); Int64x2 cen16(&cen1[6]); Int64x2 cen20(&cen2[0]); Int64x2 cen22(&cen2[2]); Int64x2 cen24(&cen2[4]); Int64x2 cen26(&cen2[6]); Int64x2 diff0 = cen10 ^ cen20; Int64x2 diff2 = cen12 ^ cen22; Int64x2 diff4 = cen14 ^ cen24; Int64x2 diff6 = cen16 ^ cen26; Int16x8 cost_ct(robustLUTCen(_mm_popcnt_u64(diff0.getInt(0))), robustLUTCen(_mm_popcnt_u64(diff0.getInt(1))), robustLUTCen(_mm_popcnt_u64(diff2.getInt(0))), robustLUTCen(_mm_popcnt_u64(diff2.getInt(1))), robustLUTCen(_mm_popcnt_u64(diff4.getInt(0))), robustLUTCen(_mm_popcnt_u64(diff4.getInt(1))), robustLUTCen(_mm_popcnt_u64(diff6.getInt(0))), robustLUTCen(_mm_popcnt_u64(diff6.getInt(1)))); Int16x8 cost_total = cost_ad + cost_ct; for (int i = 0; i < 8; ++i) { costs.element(y, x + i) = cost_total[i]; } im1 += 8; im2 += 8; cen1+= 8; cen2+= 8; } #else for (; x < width - windowWh; ++x) { uint8_t c_ad = costAD(*im1, *im2); uint8_t c_census = hammingDist(*cen1, *cen2); costs.element(y, x) = robustLUTCen(c_census) + robustLUTAD(c_ad); im1 ++; im2 ++; cen1++; cen2++; } #endif } }, !parallelDisp ); stats.resetInterval("Cost computation"); aggregateCosts(&costs, windowWh + d, windowHh, width - windowWh, height - windowHh); stats.resetInterval("Cost aggregation"); for (int x = windowWh + d; x < width - windowWh; ++x) { for (int y = windowHh; y < height - windowHh; ++y) { tbb::mutex::scoped_lock(bestDisparitiesMutex); if(costs.element(y, x) < minCosts.element(y, x)) { minCosts.element(y, x) = costs.element(y, x); bestDisparities.element(y, x) = d; //result.element(y,x) = (bestDisparities.element(y, x) / (double)width * 255 * 3); } } } //BMPLoader().save("../../result.bmp", result); stats.endInterval("Comparing with previous minimum"); collector.addStatistics(stats); } }, parallelDisp);