Ejemplo n.º 1
0
vector<Rect> CharacterSegmenter::combineCloseBoxes( vector<Rect> charBoxes, float biggestCharWidth)
{
  vector<Rect> newCharBoxes;
  
  for (int i = 0; i < charBoxes.size(); i++)
  {
    if (i == charBoxes.size() - 1)
    {
	newCharBoxes.push_back(charBoxes[i]);
	break;
    }
    float bigWidth = (charBoxes[i + 1].x + charBoxes[i + 1].width - charBoxes[i].x);
    
    float w1Diff = abs(charBoxes[i].width - biggestCharWidth);
    float w2Diff = abs(charBoxes[i + 1].width - biggestCharWidth);
    float bigDiff = abs(bigWidth - biggestCharWidth);
    bigDiff *= 1.3;	// Make it a little harder to merge boxes. 
    
    if (bigDiff < w1Diff && bigDiff < w2Diff)
    {
      Rect bigRect(charBoxes[i].x, charBoxes[i].y, bigWidth, charBoxes[i].height);
      newCharBoxes.push_back(bigRect);
      if (this->config->debugCharSegmenter)
      {
	for (int z = 0; z < charAnalysis->thresholds.size(); z++)
	{
	  Point center(bigRect.x + bigRect.width / 2, bigRect.y + bigRect.height / 2);
	  RotatedRect rrect(center, Size2f(bigRect.width, bigRect.height + (bigRect.height / 2)), 0);
	  ellipse(imgDbgCleanStages[z], rrect, Scalar(0,255,0), 1);
	}
	cout << "Merging 2 boxes -- " << i << " and " << i + 1 << endl;
      }
      
      i++;
    }
    else
    {
	newCharBoxes.push_back(charBoxes[i]);
    }
    
    
    
  }
  
  return newCharBoxes;
}
Ejemplo n.º 2
0
/*
 * orientation := (x1, y1, x2, y2)^T
 *
 * */
bool Keyframe::extract_part(cv::Mat& dst,
								cv::Point centre, cv::Vec4i orientation,
								int window_size) {

	int align_x = 0;
	int align_y = 0;
	cv::Mat frame = keyframe_;

	if (centre.x < window_size/2 || centre.x > keyframe_.cols - window_size/2
			|| centre.y < window_size/2 || centre.y > keyframe_.rows - window_size/2) {

		align_x = window_size;
		align_y = window_size;

		frame = cv::Mat(cv::Size(frame.cols + 2*align_x, frame.rows + 2*align_y), CV_32F, 0.05);
		cv::Mat roi = frame(cv::Rect(align_x, align_y, keyframe_.cols, keyframe_.rows));
		keyframe_.copyTo(roi);
	}

	// Rotating the ROI so that the direction points downwards
	float dy = orientation[1] - orientation[3];
	float dx = orientation[0] - orientation[2];
	float angle = -acos(dy/sqrt(dy*dy + dx*dx)) * 180.f/M_PI;

	if (dx < 0) { angle = abs(angle); }

	centre.x += align_x;
	centre.y += align_y;
	cv::RotatedRect rrect(centre, cv::Size(window_size, window_size), angle);

	// try
	cv::Mat roi = frame;

	// get the rotation matrix
    cv::Mat R = cv::getRotationMatrix2D(rrect.center, angle, 1.0);

    // perform the affine transformation
    cv::Mat roi_rotated;
    warpAffine(roi, roi_rotated, R, roi.size(), cv::INTER_CUBIC);

    // crop the resulting image
    cv::getRectSubPix(roi_rotated, rrect.size, rrect.center, dst);

	return true;
};
Ejemplo n.º 3
0
    void Display::impl::draw()
    {
        SDL_PumpEvents();

        pixfmt            pixf(rbwindow);
        pixfmt            pixf_pre(rbwindow);
        base_renderer     rb(pixf);
        base_renderer     rb_pre(pixf_pre);
        solid_renderer    rs(rb);
        renderer_bin      rbin(rb);
        agg::scanline_u8 sl;
        agg::rasterizer_scanline_aa<> pf;

        if (fondo)
            SDL_BlitSurface(fondo.get(), 0, window.get(), 0);
        else
            rb.clear(agg::rgba(0, 0, 0));

        agg::glyph_rendering gren = agg::glyph_ren_agg_gray8;

        if(m_feng.load_font("timesi.ttf", 0, gren)) {
            m_feng.hinting(1);
            m_feng.flip_y(1);
            for (impl::it_tsprites it = textSprites.begin()
                ,end = textSprites.end()
                ;it!= end
                ;++it) 
            {
                TextSprite::impl* tsimpl = *it;
                if (tsimpl->visible) {
                    m_feng.height(tsimpl->size);
                    m_feng.width(tsimpl->size);
                    m_contour.width(-tsimpl->size * tsimpl->size * 0.05);
                    double x  = tsimpl->x;
                    double y0 = tsimpl->y + tsimpl->size;
                    double y  = y0;
                    for (std::string::iterator letra = tsimpl->caption.begin(), last = tsimpl->caption.end(); letra != last; ++letra) {
                        const agg::glyph_cache* glyph = m_fman.glyph(*letra);
                        if (glyph) {
                            m_fman.init_embedded_adaptors(glyph, x, y);
                            rs.color(agg::rgba8(0, 0, 0));
                            agg::render_scanlines(m_fman.gray8_adaptor(), 
                                m_fman.gray8_scanline(), 
                                rs);
                            x += glyph->advance_x;
                            y += glyph->advance_y;
                        }
                    }
                }
            }
        }

        for (impl::it_sprites it = sprites.begin()
            ,end = sprites.end()
            ;it!= end
            ;++it) 
        {
            Sprite::impl* simpl = *it;
            if (simpl->visible)
            {
                agg::rendering_buffer buffer((unsigned char*)simpl->surface->pixels,
                    simpl->surface->w, simpl->surface->h, simpl->surface->pitch);
                interpolator_type interpolator;
                span_alloc_type sa;
                span_gen_type sg(sa, buffer, agg::rgba_pre(0, 0, 0, 0), interpolator);
                renderer_type ri;
                agg::rounded_rect rec(0, 0, buffer.width(), buffer.height(), 0);

                agg::trans_affine src_mtx;
                src_mtx *= agg::trans_affine_translation(simpl->x, simpl->y);
                agg::trans_affine img_mtx = src_mtx;
                img_mtx.invert();
                interpolator.transformer(img_mtx);
                ri.attach(rb_pre, sg);
                agg::rounded_rect rrect(0, 0, buffer.width(), buffer.height(), 0);
                agg::conv_transform<agg::rounded_rect> tr(rrect, src_mtx);
                pf.add_path(tr);
                agg::render_scanlines(pf, sl, ri);

            }
        }
        SDL_BlitSurface(window.get(), 0, screen, 0);
        SDL_Flip(screen);
    }