public static void remove_small_components(Intarray segmentation, int w = 5, int h = 4)
{
if (NarrayUtil.Max(segmentation) > 100000)
{
throw new Exception("remove_small_components: to many segments");
}
Narray <Rect> bboxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref bboxes, segmentation);
for (int i = 1; i < bboxes.Length(); i++)
{
Rect b = bboxes[i];
if (b.Width() < w && b.Height() < h)
{
for (int x = b.x0; x < b.x1; x++)
{
for (int y = b.y0; y < b.y1; y++)
{
if (segmentation[x, y] == i)
{
segmentation[x, y] = 0;
}
}
}
}
}
}
public static void check_approximately_sorted(Intarray labels)
{
for (int i = 0; i < labels.Length1d(); i++)
{
if (labels.At1d(i) > 100000)
{
throw new Exception("labels out of range");
}
}
Narray <Rect> rboxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref rboxes, labels);
#if false
// TODO/tmb disabling check until the overseg issue is fixed --tmb
for (int i = 1; i < rboxes.Length(); i++)
{
if (rboxes[i].Right < rboxes[i - 1].Left)
{
/*errors_log("bad segmentation", labels);
* errors_log.recolor("bad segmentation (recolored)", labels);
* throw_fmt("boxes aren't approximately sorted: "
* "box %d is to the left from box %d", i, i-1);*/
}
}
#endif
}
public override void Charseg(ref Intarray outimage, Bytearray inarray)
{
Bytearray image = new Bytearray();
image.Copy(inarray);
OcrRoutine.binarize_simple(image);
OcrRoutine.Invert(image);
outimage.Copy(image);
Intarray labels = new Intarray();
labels.Copy(image);
ImgLabels.label_components(ref labels);
Narray <Rect> boxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref boxes, labels);
Intarray equiv = new Intarray(boxes.Length());
for (int i = 0; i < boxes.Length(); i++)
{
equiv[i] = i;
}
for (int i = 1; i < boxes.Length(); i++)
{
Rect p = boxes[i];
for (int j = 1; j < boxes.Length(); j++)
{
if (i == j)
{
continue;
}
Rect q = boxes[j];
int x0 = Math.Max(p.x0, q.x0);
int x1 = Math.Min(p.x1, q.x1);
int iw = x1 - x0;
if (iw <= 0)
{
continue; // no overlap
}
int ow = Math.Min(p.Width(), q.Width());
float frac = iw / (float)(ow);
if (frac < 0.5f)
{
continue; // insufficient overlap
}
// printf("%d %d : %d %d : %g\n",i,j,iw,ow,frac);
equiv.Put1d(Math.Max(i, j), Math.Min(i, j));
}
}
for (int i = 0; i < labels.Length(); i++)
{
labels.Put1d(i, equiv.At1d(labels.At1d(i)));
}
ImgLabels.renumber_labels(labels, 1);
outimage.Move(labels);
SegmRoutine.make_line_segmentation_white(outimage);
SegmRoutine.check_line_segmentation(outimage);
}
public static void line_segmentation_sort_x(Intarray segmentation)
{
if (NarrayUtil.Max(segmentation) > 100000)
{
throw new Exception("line_segmentation_merge_small_components: to many segments");
}
Narray <Rect> bboxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref bboxes, segmentation);
Floatarray x0s = new Floatarray();
unchecked
{
x0s.Push((float)-999999);
}
for (int i = 1; i < bboxes.Length(); i++)
{
if (bboxes[i].Empty())
{
x0s.Push(999999);
}
else
{
x0s.Push(bboxes[i].x0);
}
}
// dprint(x0s,1000); printf("\n");
Narray <int> permutation = new Intarray();
Narray <int> rpermutation = new Intarray();
NarrayUtil.Quicksort(permutation, x0s);
rpermutation.Resize(permutation.Length());
for (int i = 0; i < permutation.Length(); i++)
{
rpermutation[permutation[i]] = i;
}
// dprint(rpermutation,1000); printf("\n");
for (int i = 0; i < segmentation.Length1d(); i++)
{
if (segmentation.At1d(i) == 0)
{
continue;
}
segmentation.Put1d(i, rpermutation[segmentation.At1d(i)]);
}
}
public static Bitmap ConvertCharsegToBitmapRecolor(Intarray charseg, string trans = "")
{
Intarray cseg = new Intarray();
cseg.Copy(charseg);
Narray <Rect> bboxes = new Narray <Rect>();
//SegmRoutine.make_line_segmentation_black(cseg);
ImgLabels.bounding_boxes(ref bboxes, cseg);
SegmRoutine.make_line_segmentation_white(cseg);
ImgLabels.simple_recolor(cseg);
return(DrawSegmentTranscript(
DrawSegmentNumbers(
ImgRoutine.NarrayToRgbBitmap(cseg),
bboxes),
bboxes,
trans));
}
public void EstimateSpaceSize()
{
Intarray labels = new Intarray();
labels.Copy(segmentation);
ImgLabels.label_components(ref labels);
Narray <Rect> boxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref boxes, labels);
Floatarray distances = new Floatarray();
distances.Resize(boxes.Length());
distances.Fill(99999f);
for (int i = 1; i < boxes.Length(); i++)
{
Rect b = boxes[i];
for (int j = 1; j < boxes.Length(); j++)
{
Rect n = boxes[j];
int delta = n.x0 - b.x1;
if (delta < 0)
{
continue;
}
if (delta >= distances[i])
{
continue;
}
distances[i] = delta;
}
}
float interchar = NarrayUtil.Fractile(distances, PGetf("space_fractile"));
space_threshold = interchar * PGetf("space_multiplier");
// impose some reasonable upper and lower bounds
float xheight = 10.0f; // FIXME
space_threshold = Math.Max(space_threshold, PGetf("space_min") * xheight);
space_threshold = Math.Min(space_threshold, PGetf("space_max") * xheight);
}
public static void remove_small_components <T>(Narray <T> bimage, int mw, int mh)
{
Intarray image = new Intarray();
image.Copy(bimage);
ImgLabels.label_components(ref image);
Narray <Rect> rects = new Narray <Rect>();
ImgLabels.bounding_boxes(ref rects, image);
Bytearray good = new Bytearray(rects.Length());
for (int i = 0; i < good.Length(); i++)
{
good[i] = 1;
}
for (int i = 0; i < rects.Length(); i++)
{
if (rects[i].Width() < mw && rects[i].Height() < mh)
{
// printf("*** %d %d %d\n",i,rects[i].width(),rects[i].height());
good[i] = 0;
}
}
for (int i = 0; i < image.Length1d(); i++)
{
if (good[image.At1d(i)] == 0)
{
image.Put1d(i, 0);
}
}
for (int i = 0; i < image.Length1d(); i++)
{
if (image.At1d(i) == 0)
{
bimage.Put1d(i, default(T)); // default(T) - 0
}
}
}
/// <summary>
/// Compute the groups for a segmentation (internal method).
/// </summary>
private void computeGroups()
{
rboxes.Clear();
ImgLabels.bounding_boxes(ref rboxes, labels);
int n = rboxes.Length();
// NB: we start with i=1 because i=0 is the background
for (int i = 1; i < n; i++)
{
for (int range = 1; range <= maxrange; range++)
{
if (i + range > n)
{
continue;
}
Rect box = rboxes.At1d(i);
Intarray seg = new Intarray();
bool bad = false;
for (int j = i; j < i + range; j++)
{
if (j > i && rboxes.At1d(j).x0 - rboxes.At1d(j - 1).x1 > maxdist)
{
bad = true;
break;
}
box.Include(rboxes.At1d(j));
seg.Push(j);
}
if (bad)
{
continue;
}
boxes.Push(box);
segments.Push(seg);
}
}
}
protected void rescale(Floatarray v, Floatarray input)
{
if (input.Rank() != 2)
{
throw new Exception("CHECK_ARG: sub.Rank()==2");
}
Floatarray sub = new Floatarray();
// find the largest connected component
// and crop to its bounding box
// (use a binary version of the character
// to compute the bounding box)
Intarray components = new Intarray();
float threshold = PGetf("threshold") * NarrayUtil.Max(input);
Global.Debugf("biggestcc", "threshold {0}", threshold);
components.MakeLike(input);
components.Fill(0);
for (int i = 0; i < components.Length(); i++)
{
components[i] = (input[i] > threshold ? 1 : 0);
}
int n = ImgLabels.label_components(ref components);
Intarray totals = new Intarray(n + 1);
totals.Fill(0);
for (int i = 0; i < components.Length(); i++)
{
totals[components[i]]++;
}
totals[0] = 0;
Narray <Rect> boxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref boxes, components);
int biggest = NarrayUtil.ArgMax(totals);
Rect r = boxes[biggest];
int pad = (int)(PGetf("pad") + 0.5f);
r.PadBy(pad, pad);
Global.Debugf("biggestcc", "({0}) {1}[{2}] :: {3} {4} {5} {6}",
n, biggest, totals[biggest],
r.x0, r.y0, r.x1, r.y1);
// now perform normal feature extraction
// (use the original grayscale input)
sub = input;
ImgMisc.Crop(sub, r);
int csize = PGeti("csize");
float s = Math.Max(sub.Dim(0), sub.Dim(1)) / (float)csize;
if (PGetf("noupscale") > 0 && s < 1.0f)
{
s = 1.0f;
}
float sig = s * PGetf("aa");
float dx = (csize * s - sub.Dim(0)) / 2f;
float dy = (csize * s - sub.Dim(1)) / 2f;
if (sig > 1e-3f)
{
Gauss.Gauss2d(sub, sig, sig);
}
v.Resize(csize, csize);
v.Fill(0f);
for (int i = 0; i < csize; i++)
{
for (int j = 0; j < csize; j++)
{
float x = i * s - dx;
float y = j * s - dy;
if (x < 0 || x >= sub.Dim(0))
{
continue;
}
if (y < 0 || y >= sub.Dim(1))
{
continue;
}
float value = ImgOps.bilin(sub, x, y);
v[i, j] = value;
}
}
/*Global.Debugf("biggestcc", "{0} {1} ({2}) -> {3} {4} ({5})",
* sub.Dim(0), sub.Dim(1), NarrayUtil.Max(sub),
* v.Dim(0), v.Dim(1), NarrayUtil.Max(v));*/
}
public List <List <float> > SpaceCosts(List <Candidate> candidates, Bytearray image)
{
/*
* Given a list of character recognition candidates and their
* classifications, and an image of the corresponding text line,
* compute a list of pairs of costs for putting/not putting a space
* after each of the candidate characters.
*
* The basic idea behind this simple algorithm is to try larger
* and larger horizontal closing operations until most of the components
* start having a "wide" aspect ratio; that's when characters have merged
* into words. The remaining whitespace should be spaces.
*
* This is just a simple stopgap measure; it will be replaced with
* trainable space modeling.
*/
int w = image.Dim(0);
int h = image.Dim(1);
Bytearray closed = new Bytearray();
int r;
for (r = 0; r < maxrange; r++)
{
if (r > 0)
{
closed.Copy(image);
Morph.binary_close_circle(closed, r);
}
else
{
closed.Copy(image);
}
Intarray labeled = new Intarray();
labeled.Copy(closed);
ImgLabels.label_components(ref labeled);
Narray <Rect> rects = new Narray <Rect>();
ImgLabels.bounding_boxes(ref rects, labeled);
Floatarray aspects = new Floatarray();
for (int i = 0; i < rects.Length(); i++)
{
Rect rect = rects[i];
float aspect = rect.Aspect();
aspects.Push(aspect);
}
float maspect = NarrayUtil.Median(aspects);
if (maspect >= this.aspect_threshold)
{
break;
}
}
// close with a little bit of extra space
closed.Copy(image);
Morph.binary_close_circle(closed, r + 1);
// compute the remaining aps
//Morph.binary_dilate_circle();
// every character box that ends near a cap gets a space appended
return(null);
}
public static void line_segmentation_merge_small_components(ref Intarray segmentation, int r = 10)
{
if (NarrayUtil.Max(segmentation) > 100000)
{
throw new Exception("line_segmentation_merge_small_components: to many segments");
}
make_line_segmentation_black(segmentation);
Narray <Rect> bboxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref bboxes, segmentation);
bboxes[0] = Rect.CreateEmpty();
bool changed;
do
{
changed = false;
for (int i = 1; i < bboxes.Length(); i++)
{
Rect b = bboxes[i];
if (b.Empty())
{
continue;
}
if (b.Width() >= r || b.Height() >= r)
{
continue;
}
// merge small components only with touching components
int closest = 0;
Rect b1 = b.Grow(1);
b1.Intersect(new Rect(0, 0, segmentation.Dim(0), segmentation.Dim(1)));
for (int x = b1.x0; x < b1.x1; x++)
{
for (int y = b1.y0; y < b1.y1; y++)
{
int value = segmentation[x, y];
if (value == 0)
{
continue;
}
if (value == i)
{
continue;
}
closest = value;
break;
}
}
if (closest == 0)
{
continue;
}
for (int x = b.x0; x < b.x1; x++)
{
for (int y = b.y0; y < b.y1; y++)
{
if (segmentation[x, y] == i)
{
segmentation[x, y] = closest;
}
}
}
bboxes[i] = Rect.CreateEmpty();
changed = true;
}
} while (changed);
}
public static void fix_diacritics(Intarray segmentation)
{
Narray <Rect> bboxes = new Narray <Rect>();
ImgLabels.bounding_boxes(ref bboxes, segmentation);
if (bboxes.Length() < 1)
{
return;
}
Intarray assignments = new Intarray(bboxes.Length());
for (int i = 0; i < assignments.Length(); i++)
{
assignments[i] = i;
}
for (int j = 0; j < bboxes.Length(); j++)
{
float dist = 1e38f;
int closest = -1;
for (int i = 0; i < bboxes.Length(); i++)
{
// j should overlap i in the x direction
if (bboxes.At1d(j).x1 < bboxes.At1d(i).x0)
{
continue;
}
if (bboxes.At1d(j).x0 > bboxes.At1d(i).x1)
{
continue;
}
// j should be above i
if (!(bboxes.At1d(j).y0 >= bboxes.At1d(i).y1))
{
continue;
}
#if false
// j should be smaller than i
if (!(bboxes.At1d(j).area() < bboxes.At1d(i).area()))
{
continue;
}
#endif
float d = Math.Abs((bboxes[j].x0 + bboxes[j].x1) / 2 - (bboxes[i].x0 + bboxes[i].x1) / 2);
if (d >= dist)
{
continue;
}
dist = d;
closest = i;
}
if (closest < 0)
{
continue;
}
assignments[j] = closest;
}
for (int i = 0; i < segmentation.Length(); i++)
{
segmentation.Put1d(i, assignments[segmentation.At1d(i)]);
}
ImgLabels.renumber_labels(segmentation, 1);
}