vector<POI> POIFinder::GetPOIsInImage(IplImage *cv_image) { //Pre-processing // Image originalImage(cv_image); // Image grayImage = originalImage.getGrayScale(); /* IplImage *gray_image = cvCreateImage(cvGetSize(cv_image),cv_image->depth, 1); if(cv_image->nChannels == 3) { cvCvtColor(cv_image, gray_image,CV_BGR2GRAY); } else cvCopyImage(cv_image, gray_image); Image grayImage(gray_image);*/ Image grayImage(cv_image); //Core algorithm vector<Blob> detectedBlobs = FindBlobs(grayImage); vector<POI> newCoordinates; for (unsigned int i = 0; i < detectedBlobs.size(); i++) { newCoordinates.push_back(POI(detectedBlobs[i].GetCentroid())); //cout << "Novo POI: " << endl; //Debug::printCvPoint2D32f(newCoordinates[newCoordinates.size()-1].getCoordinates2d()); }; return newCoordinates; }
void faceDetector::detectFace() { if(FaceEnable) { detectObject(faceClassifier,grayImage,faces); } leftEyes.clear(); rightEyes.clear(); noses.clear(); mouth.clear(); std::sort(faces.begin(),faces.end(),rectSort); if(faces.size() > 0) { FaceRIO = faces[0]; FaceDetected = true; faceMat = grayImage(FaceRIO); } else { FaceRIO = Rect(-1,-1,-1,-1); } }
void DateWidget::paintEvent(QPaintEvent *event) { static QPixmap pix = QPixmap(":/calendar").scaled(DATEWIDGETWIDTH, 64); QPainter painter(this); painter.drawPixmap(QPoint(0, 0), isEnabled() ? pix : QPixmap::fromImage(grayImage(pix.toImage()))); QString month = mDate.toString("MMM"); QString year = mDate.toString("yyyy"); QString day = mDate.toString("dd"); QFont font = QFont("monospace", 10); QFontMetrics metrics = QFontMetrics(font); painter.setFont(font); painter.setPen(QPen(QBrush(Qt::white), 0)); painter.setBrush(QBrush(Qt::white)); painter.drawText(QPoint(6, metrics.height() + 1), month); painter.drawText(QPoint(DATEWIDGETWIDTH - metrics.width(year) - 6, metrics.height() + 1), year); font.setPointSize(14); metrics = QFontMetrics(font); painter.setPen(QPen(QBrush(Qt::black), 0)); painter.setBrush(Qt::black); painter.setFont(font); painter.drawText(QPoint(DATEWIDGETWIDTH / 2 - metrics.width(day) / 2, 45), day); if (hasFocus()) { QStyleOptionFocusRect option; option.initFrom(this); option.backgroundColor = palette().color(QPalette::Background); style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter, this); } }
Mat faceDetector::getFaceMat() { if(isFaceDetected()) { return grayImage(FaceRIO); } else { return Mat(16,16,CV_8UC1); } }
void CvxLSD::detect_lines(const vil_image_view<vxl_byte> & image, vcl_vector<LSDLineSegment> & line_segments) { assert(image.nplanes() == 3 || image.nplanes() == 1); vil_image_view<vxl_byte> grayImage; if (image.nplanes() == 3) { vil_convert_planes_to_grey(image, grayImage); } else { grayImage = image; } double * imageData = NULL; double * out = NULL; int width = grayImage.ni(); int height = grayImage.nj(); int n = 0; imageData = (double *) malloc( width * height * sizeof(double) ); assert(imageData); for(int j=0; j<height; j++) { for(int i=0; i<width; i++) { imageData[i + j * width] = grayImage(i, j); } } /* LSD call */ out = lsd(&n, imageData, width, height); /* print output */ // printf("%d line segments found:\n",n); line_segments.resize(n); for(int i=0; i<n; i++) { double x1 = out[7*i + 0]; double y1 = out[7*i + 1]; double x2 = out[7*i + 2]; double y2 = out[7*i + 3]; double line_width = out[7*i + 4]; double p = out[7*i + 5]; double tmp = out[7*i + 6]; line_segments[i].seg_ = vgl_line_segment_2d<double>(vgl_point_2d<double>(x1, y1), vgl_point_2d<double>(x2, y2)); line_segments[i].width_ = line_width; line_segments[i].angle_precision_ = p; line_segments[i].NFA_ = tmp; } free( (void *) imageData ); free( (void *) out ); }
StarWidget::StarWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f), current(0) { if (!activeStar) { activeStar = new QPixmap(); QSvgRenderer render(QString(":star")); QPixmap renderedStar(IMG_SIZE, IMG_SIZE); renderedStar.fill(Qt::transparent); QPainter painter(&renderedStar); render.render(&painter, QRectF(0, 0, IMG_SIZE, IMG_SIZE)); (*activeStar) = renderedStar; } if (!inactiveStar) { inactiveStar = new QPixmap(); (*inactiveStar) = grayImage(activeStar); } }
StarWidget::StarWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f), current(0), readOnly(false) { int dim = defaultIconMetrics().sz_small; if (activeStar.isNull()) { QSvgRenderer render(QString(":star")); QPixmap renderedStar(dim, dim); renderedStar.fill(Qt::transparent); QPainter painter(&renderedStar); render.render(&painter, QRectF(0, 0, dim, dim)); activeStar = renderedStar.toImage(); } if (inactiveStar.isNull()) { inactiveStar = grayImage(activeStar); } setFocusPolicy(Qt::StrongFocus); }
void BriefDescriptorExtractor::computeImpl(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors) const { // Construct integral image for fast smoothing (box filter) Mat sum; Mat grayImage(image.size(), CV_8UC1); if( image.type() != CV_8U ) cvtColor( image, grayImage, COLOR_BGR2GRAY ); ///TODO allow the user to pass in a precomputed integral image //if(image.type() == CV_32S) // sum = image; //else integral( grayImage, sum, CV_32S); //Remove keypoints very close to the border KeyPointsFilter::runByImageBorder(keypoints, image.size(), PATCH_SIZE/2 + KERNEL_SIZE/2); descriptors = Mat::zeros((int)keypoints.size(), bytes_, CV_8U); test_fn_(sum, keypoints, descriptors); }
void BlinkAnalyser::receiveNewFrame(cv::Mat newFrame){ cv::cvtColor(newFrame,this->grayImage,cv::COLOR_BGR2GRAY); if (this->faceDetector->detect(this->grayImage,5, this->faceBoundingBox)) { //调用FaceDetector,如果检测到脸 this->upperImage = grayImage(this->faceBoundingBox.returnUpperRect()); //截取图像的上半部分(准备检测人眼) if(this->eyeDetector->detect(this->upperImage,this->eyesRects)){ //调用eyeDetector,如果检测到眼睛 if(this->isEyesOpen == false){ this->isEyesOpen = true; this->blinkCount++; } Utils::drawRect(this->grayImage, eyesRects,this->faceBoundingBox.returnRect().x,this->faceBoundingBox.returnRect().y); }else{ //如果没检测到眼睛 this->isEyesOpen = false; } Utils::drawRect(this->grayImage,this->faceBoundingBox); }else{ //如果没检测到脸 this->blinkCount = 0; } if(blinkCount > this->blinkThreshold){ this->success(); } //cv::moveWindow("BlinkAnalyser",200,160); //cv::imshow("BlinkAnalyser", grayImage); }
ImageGray GrayscaleImage::convertToGrayscale(ImageRGB & image) { // Image size. int width = image.width(); int height = image.height(); // The destination image. ImageGray grayImage(width, height); // For every pixel in the image. for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { // Get the pixel at position x,y. Rgb<unsigned char &> pixelRGB = image.at(x, y); unsigned char& pixelGray = grayImage.at(x, y); // Convert RGB to grayscale. pixelGray = pixelRGB.red * 0.114 + pixelRGB.green * 0.587 + pixelRGB.blue * 0.299; } } // Return the gray image. return grayImage; }
void LevelAnalyzedImage::analyze() { if ( inputImage_.empty() ) return; cv::Mat grayImage; { std::lock_guard<std::mutex> lock(inputImageMutex_); cv::cvtColor(inputImage_, grayImage, CV_BGR2GRAY); } // Noise reduction cv::medianBlur(grayImage, grayImage, 5); // Contrast collection cv::Mat lut(1, 256, CV_8U); for (int i = 0; i < 256; ++i) { lut.at<unsigned char>(i) = (i < threshold_) ? (std::pow(i, 2) / threshold_) : (256 - std::pow(i, 2) / std::pow(256, 2)); // lut.at<unsigned char>(i) = 255 / (1 + std::exp(-contrast_ * (i - 128) / 255)); } cv::LUT(grayImage, lut, grayImage); // Check each cell color std::vector<int> heights; for (auto rect : targetRects_) { // copy // To fill gaps rect.width += 1; rect.height += 1; // Check ROI if ( !(rect.x >= 0 && rect.width >= 0 && rect.x + rect.width <= grayImage.cols && rect.y >= 0 && rect.height >= 0 && rect.y + rect.height <= grayImage.rows) ) { qDebug() << "targetRects contains invalid rect data."; continue; } // Calculate average color cv::Mat roiImage = grayImage(rect); if (rect.width > 3 && rect.height > 3) { rect.x += rect.width / 3; rect.y += rect.height / 3; rect.width /= 3; rect.height /= 3; } cv::Mat averageRoiImage = grayImage(rect); cv::Mat rowAverage, average; cv::reduce(averageRoiImage, rowAverage, 0, CV_REDUCE_AVG); cv::reduce(rowAverage, average, 1, CV_REDUCE_AVG); // Set all pixels in ROI as its average color auto averageValue = average.at<unsigned char>(0); roiImage = cv::Scalar(averageValue); // Set results auto brickDetected = averageValue > threshold_ ? 1 : 0; heights.push_back(brickDetected); } // check change addHeightsCache(heights); checkResult(); { std::lock_guard<std::mutex> lock(mutex_); cv::cvtColor(grayImage, image_, CV_GRAY2BGR); emit imageChanged(); } emit update(); }
//Processes a frame and returns output image bool HiLight::processFrame(const cv::Mat& inputFrame, int* screen_position, double current_timestamp, char *results, bool* denoise_check, bool* first_bit_check, int* hilight_line_index, char* hilight_results_tmp ) { *denoise_check = false; *first_bit_check = false; if(!initialized){ initialized = true; for(int i = 0; i<grid_x; i++){ for(int j = 0; j<grid_y; j++ ){ for (int k = 0; k < first_bit_window; k++){ first_bit_color_window[i][j][k] = 0; } for (int k = 0; k < N; k++){ grid_color_intensity[i][j][k] = 0; hilight_results_stack[i][j][k] = 0; } hilight_results[i][j] = 0; } } if (isImage){ MVDR = true; first_2_ratio = 0.6;//0.8 first_bit_voting = 0.5;//0.7 }else{ MVDR = false; first_2_ratio = 0.8; //0.7 first_bit_voting = 0.7; //0.6 } window_index = 0; first_bit_detected = false; first_bit_index = 0; hilight_stack_index = 0; start_time = current_timestamp; current_time = current_timestamp; denoise_start = false; MVDR_index = 0; bit_counter = 0; results_stack_counter = 0; fftSetup = vDSP_create_fftsetup(LOG_N, kFFTRadix2); start_receiving = false; counter_after_detect_1= 0; first_bit_1_detected = false; first_bit_2_detected = false; hilight_first_bit_index = 0; hilight_first_bit_counter = 0; hilight_first_bit_position = 0; if (screen_position[2] < screen_position[4]){ image_ROI_position[0].y = screen_position[2]; }else{ image_ROI_position[0].y = screen_position[4]; } if (screen_position[1] < screen_position[7]){ image_ROI_position[0].x = screen_position[1]; }else{ image_ROI_position[0].x = screen_position[7]; } if (screen_position[6] < screen_position[8]){ image_ROI_position[1].y = screen_position[8]; }else{ image_ROI_position[1].y = screen_position[6]; } if (screen_position[5] < screen_position[3]){ image_ROI_position[1].x = screen_position[3]; }else{ image_ROI_position[1].x = screen_position[5]; } if (isImage){ // Set grids points to calculate the grid position for (int i = 0; i <= grid_x * grid_x_MVDR; i++){ grids_points_top_image[i].x = screen_position[1] + (screen_position[3] - screen_position[1]) / grid_x / grid_x_MVDR * i; grids_points_top_image[i].y = screen_position[2] + (screen_position[4] - screen_position[2]) / grid_x / grid_x_MVDR * i; grids_points_bottom_image[i].x = screen_position[7] + (screen_position[5] - screen_position[7]) / grid_x / grid_x_MVDR * i; grids_points_bottom_image[i].y = screen_position[8] + (screen_position[6] - screen_position[8]) / grid_x / grid_x_MVDR * i; } for (int i = 0; i <= grid_y * grid_y_MVDR; i++){ grids_points_left_image[i].x = screen_position[1] + (screen_position[7] - screen_position[1]) / grid_y / grid_y_MVDR * i; grids_points_left_image[i].y = screen_position[2] + (screen_position[8] - screen_position[2]) / grid_y / grid_y_MVDR * i; grids_points_right_image[i].x = screen_position[3] + (screen_position[5] - screen_position[3]) / grid_y / grid_y_MVDR * i; grids_points_right_image[i].y = screen_position[4] + (screen_position[6] - screen_position[4]) / grid_y / grid_y_MVDR * i; } for (int i = 0; i < grid_x * grid_x_MVDR; i++){ for (int j = 0; j < grid_y * grid_y_MVDR; j++){ cv::Point2f r1; cv::Point2f r2; cv::Point2f r3; cv::Point2f r4; intersection(grids_points_top_image[i], grids_points_bottom_image[i], grids_points_left_image[j], grids_points_right_image[j], r1);//top left intersection(grids_points_top_image[i+1], grids_points_bottom_image[i+1], grids_points_left_image[j], grids_points_right_image[j], r2);//top right intersection(grids_points_top_image[i+1], grids_points_bottom_image[i+1], grids_points_left_image[j+1], grids_points_right_image[j+1], r3);// bottom right intersection(grids_points_top_image[i], grids_points_bottom_image[i], grids_points_left_image[j+1], grids_points_right_image[j+1], r4);//bottom left //refine grid_position if (r1.x <= r4.x){ grids_position_image[i][j][0].x = r4.x - image_ROI_position[0].x; }else{ grids_position_image[i][j][0].x = r1.x - image_ROI_position[0].x; } if (r1.y <= r2.y){ grids_position_image[i][j][0].y = r2.y - image_ROI_position[0].y; }else{ grids_position_image[i][j][0].y = r1.y - image_ROI_position[0].y; } if (r3.x <= r2.x){ grids_position_image[i][j][1].x = r3.x - image_ROI_position[0].x; }else{ grids_position_image[i][j][1].x = r2.x - image_ROI_position[0].x; } if (r3.y <= r4.y){ grids_position_image[i][j][1].y = r3.y - image_ROI_position[0].y; }else{ grids_position_image[i][j][1].y = r4.y - image_ROI_position[0].y; } } } }else{ // Set grids points to calculate the grid position for (int i = 0; i <= grid_x; i++){ grids_points_top_video[i].x = screen_position[1] + (screen_position[3] - screen_position[1]) / grid_x * i; grids_points_top_video[i].y = screen_position[2] + (screen_position[4] - screen_position[2]) / grid_x * i; grids_points_bottom_video[i].x = screen_position[7] + (screen_position[5] - screen_position[7]) / grid_x * i; grids_points_bottom_video[i].y = screen_position[8] + (screen_position[6] - screen_position[8]) / grid_x * i; } for (int i = 0; i <= grid_y; i++){ grids_points_left_video[i].x = screen_position[1] + (screen_position[7] - screen_position[1]) / grid_y * i; grids_points_left_video[i].y = screen_position[2] + (screen_position[8] - screen_position[2]) / grid_y * i; grids_points_right_video[i].x = screen_position[3] + (screen_position[5] - screen_position[3]) / grid_y * i; grids_points_right_video[i].y = screen_position[4] + (screen_position[6] - screen_position[4]) / grid_y * i; } for (int i = 0; i < grid_x; i++){ for (int j = 0; j < grid_y; j++){ cv::Point2f r1; cv::Point2f r2; cv::Point2f r3; cv::Point2f r4; intersection(grids_points_top_video[i], grids_points_bottom_video[i], grids_points_left_video[j], grids_points_right_video[j], r1);//top left intersection(grids_points_top_video[i+1], grids_points_bottom_video[i+1], grids_points_left_video[j], grids_points_right_video[j], r2);//top right intersection(grids_points_top_video[i+1], grids_points_bottom_video[i+1], grids_points_left_video[j+1], grids_points_right_video[j+1], r3);// bottom right intersection(grids_points_top_video[i], grids_points_bottom_video[i], grids_points_left_video[j+1], grids_points_right_video[j+1], r4);//bottom left //refine grid_position if (r1.x <= r4.x){ grids_position_video[i][j][0].x = r4.x - image_ROI_position[0].x; }else{ grids_position_video[i][j][0].x = r1.x - image_ROI_position[0].x; } if (r1.y <= r2.y){ grids_position_video[i][j][0].y = r2.y - image_ROI_position[0].y; }else{ grids_position_video[i][j][0].y = r1.y - image_ROI_position[0].y; } if (r3.x <= r2.x){ grids_position_video[i][j][1].x = r3.x - image_ROI_position[0].x; }else{ grids_position_video[i][j][1].x = r2.x - image_ROI_position[0].x; } if (r3.y <= r4.y){ grids_position_video[i][j][1].y = r3.y - image_ROI_position[0].y; }else{ grids_position_video[i][j][1].y = r4.y - image_ROI_position[0].y; } } } } srcTri[0] = cv::Point2f( screen_position[2],screen_position[1] ); srcTri[1] = cv::Point2f( screen_position[4],screen_position[3] ); srcTri[2] = cv::Point2f( screen_position[6],screen_position[5] ); dist_top = sqrt(pow(screen_position[4]-screen_position[2],2.0) + pow(screen_position[3]-screen_position[1],2.0)); dstTri[0] = cv::Point2f( screen_position[2],screen_position[1] ); dstTri[1] = cv::Point2f( screen_position[2],screen_position[1] + dist_top ); dstTri[2] = cv::Point2f( screen_position[2] + (int)(dist_top*transmitter_screen_ratio),screen_position[1] + dist_top); warp_mat = getAffineTransform( srcTri, dstTri ); }else{ current_time = current_timestamp; } //crop the transmitter screen from the captured image cv::Mat image_ROI = inputFrame(cv::Range(image_ROI_position[0].y, image_ROI_position[1].y), cv::Range(image_ROI_position[0].x, image_ROI_position[1].x)); getGray_HiLight(image_ROI, grayImage); image_ROI.release(); for (int c = 0; c < grid_x; c++){ for (int r = 0; r < grid_y; r++){ brightness[c][r] = 0; } } if (isImage){ int brightness_c = 0; int brightness_r = 0; for (int c = 0; c < grid_x * grid_x_MVDR; c++){ for (int r = 0; r < grid_y * grid_y_MVDR; r++) { cv::Mat tile = grayImage(cv::Range(grids_position_image[c][r][0].y + grid_margin, grids_position_image[c][r][1].y - grid_margin) , cv::Range(grids_position_image[c][r][0].x + grid_margin, grids_position_image[c][r][1].x - grid_margin)); cv::Scalar pixel_scalar = cv::mean(tile); tile.release(); float brightness_tmp =pixel_scalar[0]; if (MVDR){ if(!denoise_start && MVDR_index < MVDR_frame){ grid_color_intensity_MVDR[c][r][MVDR_index] = brightness_tmp; if ( c == grid_x * grid_x_MVDR -1 && r == grid_y * grid_y_MVDR - 1){ MVDR_index++; } }else if(!denoise_start && MVDR_index >= MVDR_frame){ denoise_start = true; *denoise_check = true; get_MVDR_weighting(grid_color_intensity_MVDR, MVDR_weighting); //print MVDR matrix if (isDebug){ for (int i = 0; i < grid_x * grid_x_MVDR; i++){ for (int j = 0; j < grid_y * grid_y_MVDR; j++){ printf("%f\t", MVDR_weighting[i][j]); } printf("\n"); } } }else{ brightness_c = floor(c*1.0/grid_x_MVDR); brightness_r = floor(r*1.0/grid_y_MVDR); brightness[brightness_c][brightness_r] = brightness[brightness_c][brightness_r] + brightness_tmp * MVDR_weighting[c][r]; } }else{ brightness_c = floor(c*1.0/grid_x_MVDR); brightness_r = floor(r*1.0/grid_y_MVDR); brightness[brightness_c][brightness_r] = brightness[brightness_c][brightness_r] + brightness_tmp; } } } }else{ for (int c = 0; c < grid_x; c++){ for (int r = 0; r < grid_y; r++) { cv::Mat tile = grayImage(cv::Range(grids_position_video[c][r][0].y + grid_margin, grids_position_video[c][r][1].y - grid_margin) , cv::Range(grids_position_video[c][r][0].x + grid_margin, grids_position_video[c][r][1].x - grid_margin)); cv::Scalar pixel_scalar = cv::mean(tile); tile.release(); float brightness_tmp =pixel_scalar[0]; brightness[c][r] = brightness_tmp; } } } if (denoise_start || !MVDR){ for (int c = 0; c < grid_x; c++){ for (int r = 0; r < grid_y; r++){ if (window_index<(N-1)) { grid_color_intensity[c][r][window_index] = brightness[c][r]; window_index++; }else{ int i; float fft_sum_N_over_2 = 0; for (i = 1; i < N; i++){ grid_color_intensity[c][r][i-1] = grid_color_intensity[c][r][i]; } grid_color_intensity[c][r][N-1] = brightness[c][r]; for (i = 0; i < N/2; i++){ fft_sum_N_over_2 = fft_sum_N_over_2 + grid_color_intensity[c][r][2*i] - grid_color_intensity[c][r][2*i+1]; } // Initialize the input buffer with a sinusoid // We need complex buffers in two different formats! tempSplitComplex.realp = new float[N/2]; tempSplitComplex.imagp = new float[N/2]; // ---------------------------------------------------------------- // Forward FFT // Scramble-pack the real data into complex buffer in just the way that's // required by the real-to-complex FFT function that follows. vDSP_ctoz((DSPComplex*)grid_color_intensity[c][r], 2, &tempSplitComplex, 1, N/2); // Do real->complex forward FFT vDSP_fft_zrip(fftSetup, &tempSplitComplex, 1, LOG_N, kFFTDirection_Forward); int max_pulse_index = object_pulse_threashold; float max_pulse = -100; float object_pulse_power_1 = LinearToDecibel(pow (fft_sum_N_over_2, 2.0)/ N); float object_pulse_power_2; int object_pulse_force; int object_pulse; for (int k = object_pulse_threashold; k < N/2; k++) { float spectrum = LinearToDecibel((pow (tempSplitComplex.realp[k], 2.0) + pow (tempSplitComplex.imagp[k], 2.0))/ 4/ N); if (max_pulse<spectrum){ max_pulse = spectrum; max_pulse_index = k; } if(k == object_pulse_2){ object_pulse_power_2 = spectrum; } } delete tempSplitComplex.realp; delete tempSplitComplex.imagp; if(max_pulse < object_pulse_power_1 && object_pulse_power_1 > -25){ object_pulse = 1; }else if(max_pulse == object_pulse_power_2){ object_pulse = 2; }else{ object_pulse = 0; } if(object_pulse_power_1 >= object_pulse_power_2){ object_pulse_force = 1; }else{ object_pulse_force = 2; } //decode data by find the peak frequency power if (first_bit_detected){ if (first_bit_1_detected && isCalibrate){ hilight_first_bit_stack[c][r][hilight_first_bit_index] = object_pulse_force; } if(current_time - start_time >= N / 60.0 * (bit_counter + 1)){ hilight_results[c][r] = get_hilight_results(hilight_results_stack[c][r], hilight_stack_index); hilight_results_stack[c][r][0] = object_pulse_force; }else{ hilight_results_stack[c][r][hilight_stack_index] = object_pulse_force; } }else{ first_bit_color_window[c][r][first_bit_index] = object_pulse; } } } } if (first_bit_1_detected && isCalibrate){ hilight_first_bit_timestamp[hilight_first_bit_index++] = current_time; }if(first_bit_2_detected && isCalibrate){ first_bit_2_detected = false; hilight_first_bit_counter++; if (hilight_first_bit_counter == N/2){ calibrate_first_bit_position(); } } if (first_bit_detected){ if(current_time - start_time >= N / 60.0 * (bit_counter + 1)){ int counter_for_2 = 0; for (int i = 0; i < grid_x; i++){ for (int j = 0; j < grid_y; j++){ if (isDebug || start_receiving){ printf("%d ",hilight_results[i][j]); } if (hilight_results[i][j] == 2){ counter_for_2++; } } } if (isDebug || start_receiving){ printf("\n"); } hilight_stack_index = 1; bit_counter++; if (!start_receiving){ counter_after_detect_1++; if (counter_after_detect_1 > 3){ reset(); }else{ if(counter_for_2 >= (double)grid_x * grid_y * first_2_ratio){ first_bit_2_detected = true; start_receiving = true; *first_bit_check = true; if (isDebug){ printf("\n"); } } } return false; }else{ int results_counter_tmp =0; for (int i = 0; i < grid_x; i++){ for (int j = 0; j < grid_y; j++){ output_bit_stack[results_stack_counter++] = hilight_results[i][j]; hilight_results_tmp[results_counter_tmp++] = hilight_results[i][j] + '0' - 1; } } hilight_line_index[0] = results_stack_counter/grid_x/grid_y; if (results_stack_counter == output_bit_stck_length){ results_stack_counter = 0; get_char_from_bits(output_bit_stack, results); printf("%s\n",results); if (demo){ debug_reset(); return true; }else{ debug_reset(); return false; } }else{ return false; } } }else{ hilight_stack_index++; } }else{ if(first_bit_index<first_bit_window-1){ first_bit_index++; }else{ first_bit_detected = detect_first_bit(first_bit_color_window); if (first_bit_detected){ if (isCalibrate){ first_bit_1_detected = true; } start_time = current_time; } } } } return false; }
// init application and run int Run() { CBitmapCapture capture(DEMO_IMAGE); // open camera if (!capture.OpenCamera()) { printf("error: could not open camera\n"); return 1; } const int width = capture.GetWidth(); const int height = capture.GetHeight(); // create temp image for the image processing CByteImage image(width, height, capture.GetType()); CByteImage grayImage(width, height, CByteImage::eGrayScale); CByteImage tempImage(width, height, CByteImage::eGrayScale); CByteImage visualizationImage(width, height, CByteImage::eRGB24); CByteImage *pImage = ℑ // create an application handler CApplicationHandlerInterface *pApplicationHandler = CreateApplicationHandler(); pApplicationHandler->Reset(); // create a main window m_pMainWindow = CreateMainWindow(0, 0, width, height + 190, "Hough Line Detection Demo"); // events are sent to this class, hence this class needs to have the CMainWindowEventInterface m_pMainWindow->SetEventCallback(this); // create an image widget to display a window WIDGET_HANDLE pImageWidget = m_pMainWindow->AddImage(0, 190, width, height); // add a label and a slider for the low threshold WIDGET_HANDLE pLabelCannyLow = m_pMainWindow->AddLabel(15, 15, 200, 30, "Canny low threshold: 0"); m_pSliderCannyLow = m_pMainWindow->AddSlider(15, 30, 200, 40, 0, 1020, 102, m_nCannyLowThreshold); // add a label and a slider for the high threshold WIDGET_HANDLE pLabelCannyHigh = m_pMainWindow->AddLabel(15, 70, 200, 30, "Canny high threshold: 0"); m_pSliderCannyHigh = m_pMainWindow->AddSlider(15, 85, 200, 40, 0, 1020, 102, m_nCannyHighThreshold); // add a label and a slider for the number of lines to extract WIDGET_HANDLE pLabelLines = m_pMainWindow->AddLabel(260, 15, 200, 30, "Circles to extract: 0 lines"); m_pSliderLinesToExtract = m_pMainWindow->AddSlider(260, 30, 200, 40, 0, 30, 5, m_nCirclesToExtract); // add labels/sliders for specifying the radius interval of interest WIDGET_HANDLE pLabelMinRadius = m_pMainWindow->AddLabel(260, 70, 200, 30, "Min radius: 0"); m_pSliderMinRadius = m_pMainWindow->AddSlider(260, 85, 200, 40, 1, 200, 5, m_nMinRadius); WIDGET_HANDLE pLabelMaxRadius = m_pMainWindow->AddLabel(260, 125, 200, 30, "Max radius: 0"); m_pSliderMaxRadius = m_pMainWindow->AddSlider(260, 140, 200, 40, 1, 200, 5, m_nMaxRadius); // add a button to toggle between the original image and the processed one m_pButton = m_pMainWindow->AddButton(510, 80, 110, 35, "Show Edges"); // add a labels to display processing stats WIDGET_HANDLE pLabelMS = m_pMainWindow->AddLabel(560, 15, 70, 20, "0 ms"); WIDGET_HANDLE pLabelFPS = m_pMainWindow->AddLabel(560, 45, 70, 20, "0 fps"); // make the window visible m_pMainWindow->Show(); char buffer[1024]; CVec3dArray resultListCircles(50); CDynamicArrayTemplate<int> resultHits(50); CVec2dArray edgePoints(10000), edgeDirections(10000); // main loop while (!pApplicationHandler->ProcessEventsAndGetExit()) { if (!capture.CaptureImage(&pImage)) break; // this is for visualization purposes only ImageProcessor::ConvertImage(pImage, &visualizationImage); get_timer_value(true); // convert input image to grayscale image ImageProcessor::ConvertImage(&image, &tempImage, true); // smooth image ImageProcessor::GaussianSmooth3x3(&tempImage, &grayImage); // detect edges with Canny edge detector ImageProcessor::Canny(&grayImage, edgePoints, edgeDirections, m_nCannyLowThreshold, m_nCannyHighThreshold); // detect lines with Hough transform ImageProcessor::HoughTransformCircles(edgePoints, edgeDirections, width, height, m_nMinRadius, m_nMaxRadius, m_nCirclesToExtract, 1, resultListCircles, resultHits, &visualizationImage); const unsigned int t = get_timer_value(); // display the speed stats sprintf(buffer, "%2.2f ms", t / 1000.0f); m_pMainWindow->SetText(pLabelMS, buffer); sprintf(buffer, "%3.2f fps", 1000000.0f / t); m_pMainWindow->SetText(pLabelFPS, buffer); sprintf(buffer, "Canny low threshold: %i", m_nCannyLowThreshold); m_pMainWindow->SetText(pLabelCannyLow, buffer); sprintf(buffer, "Canny high threshold: %i", m_nCannyHighThreshold); m_pMainWindow->SetText(pLabelCannyHigh, buffer); sprintf(buffer, "Min radius: %i", m_nMinRadius); m_pMainWindow->SetText(pLabelMinRadius, buffer); sprintf(buffer, "Max radius: %i", m_nMaxRadius); m_pMainWindow->SetText(pLabelMaxRadius, buffer); sprintf(buffer, "Circles to extract: %i", m_nCirclesToExtract); m_pMainWindow->SetText(pLabelLines, buffer); // display either the original image or the processed image if (m_bShowEdges) { ImageProcessor::Canny(&grayImage, &grayImage, m_nCannyLowThreshold, m_nCannyHighThreshold); m_pMainWindow->SetImage(pImageWidget, &grayImage); } else m_pMainWindow->SetImage(pImageWidget, &visualizationImage); } delete m_pMainWindow; delete pApplicationHandler; return 0; }