// Public factory to build a TabVector from a list of boxes.
// The TabVector will be of the given alignment type.
// The input vertical vector is used in fitting, and the output
// vertical_x, vertical_y have the resulting line vector added to them
// if the alignment is not ragged.
// The extended_start_y and extended_end_y are the maximum possible
// extension to the line segment that can be used to align with others.
// The input CLIST of BLOBNBOX good_points is consumed and taken over.
TabVector* TabVector::FitVector(TabAlignment alignment, ICOORD vertical,
int extended_start_y, int extended_end_y,
BLOBNBOX_CLIST* good_points,
int* vertical_x, int* vertical_y) {
TabVector* vector = new TabVector(extended_start_y, extended_end_y,
alignment, good_points);
if (!vector->Fit(vertical, false)) {
delete vector;
return NULL;
}
if (!vector->IsRagged()) {
vertical = vector->endpt_ - vector->startpt_;
int weight = vector->BoxCount();
*vertical_x += vertical.x() * weight;
*vertical_y += vertical.y() * weight;
}
return vector;
}
// Return true if this vector is the same side, overlaps, and close
// enough to the other to be merged.
bool TabVector::SimilarTo(const ICOORD& vertical,
const TabVector& other, BlobGrid* grid) const {
if ((IsRightTab() && other.IsRightTab()) ||
(IsLeftTab() && other.IsLeftTab())) {
// If they don't overlap, at least in extensions, then there is no chance.
if (ExtendedOverlap(other.extended_ymax_, other.extended_ymin_) < 0)
return false;
// A fast approximation to the scale factor of the sort_key_.
int v_scale = abs(vertical.y());
if (v_scale == 0)
v_scale = 1;
// If they are close enough, then OK.
if (sort_key_ + kSimilarVectorDist * v_scale >= other.sort_key_ &&
sort_key_ - kSimilarVectorDist * v_scale <= other.sort_key_)
return true;
// Ragged tabs get a bigger threshold.
if (!IsRagged() || !other.IsRagged() ||
sort_key_ + kSimilarRaggedDist * v_scale < other.sort_key_ ||
sort_key_ - kSimilarRaggedDist * v_scale > other.sort_key_)
return false;
if (grid == NULL) {
// There is nothing else to test!
return true;
}
// If there is nothing in the rectangle between the vector that is going to
// move, and the place it is moving to, then they can be merged.
// Setup a vertical search for any blob.
const TabVector* mover = (IsRightTab() &&
sort_key_ < other.sort_key_) ? this : &other;
int top_y = mover->endpt_.y();
int bottom_y = mover->startpt_.y();
int left = MIN(mover->XAtY(top_y), mover->XAtY(bottom_y));
int right = MAX(mover->XAtY(top_y), mover->XAtY(bottom_y));
int shift = abs(sort_key_ - other.sort_key_) / v_scale;
if (IsRightTab()) {
right += shift;
} else {
left -= shift;
}
GridSearch<BLOBNBOX, BLOBNBOX_CLIST, BLOBNBOX_C_IT> vsearch(grid);
vsearch.StartVerticalSearch(left, right, top_y);
BLOBNBOX* blob;
while ((blob = vsearch.NextVerticalSearch(true)) != NULL) {
TBOX box = blob->bounding_box();
if (box.top() > bottom_y)
return true; // Nothing found.
if (box.bottom() < top_y)
continue; // Doesn't overlap.
int left_at_box = XAtY(box.bottom());
int right_at_box = left_at_box;
if (IsRightTab())
right_at_box += shift;
else
left_at_box -= shift;
if (MIN(right_at_box, box.right()) > MAX(left_at_box, box.left()))
return false;
}
return true; // Nothing found.
}
return false;
}
