public override void Charseg(ref Intarray result_segmentation, Bytearray orig_image)
{
Logger.Default.Image("segmenting", orig_image);
int PADDING = 3;
OcrRoutine.optional_check_background_is_lighter(orig_image);
Bytearray image = new Bytearray();
Narray <byte> bimage = image;
image.Copy(orig_image);
OcrRoutine.binarize_simple(image);
OcrRoutine.Invert(image);
ImgOps.pad_by(ref bimage, PADDING, PADDING);
// pass image to segmenter
segmenter.SetImage(image);
// find all cuts in the image
segmenter.FindAllCuts();
// choose the best of all cuts
segmenter.FindBestCuts();
Intarray segmentation = new Intarray();
segmentation.Resize(image.Dim(0), image.Dim(1));
for (int i = 0; i < image.Dim(0); i++)
{
for (int j = 0; j < image.Dim(1); j++)
{
segmentation[i, j] = image[i, j] > 0 ? 1 : 0;
}
}
for (int r = 0; r < segmenter.bestcuts.Length(); r++)
{
int c = segmenter.bestcuts[r];
Narray <Point> cut = segmenter.cuts[c];
for (int y = 0; y < image.Dim(1); y++)
{
for (int x = cut[y].X; x < image.Dim(0); x++)
{
if (segmentation[x, y] > 0)
{
segmentation[x, y]++;
}
}
}
}
ImgOps.extract_subimage(result_segmentation, segmentation, PADDING, PADDING,
segmentation.Dim(0) - PADDING, segmentation.Dim(1) - PADDING);
if (small_merge_threshold > 0)
{
SegmRoutine.line_segmentation_merge_small_components(ref result_segmentation, small_merge_threshold);
SegmRoutine.line_segmentation_sort_x(result_segmentation);
}
SegmRoutine.make_line_segmentation_white(result_segmentation);
// set_line_number(segmentation, 1);
Logger.Default.Image("resulting segmentation", result_segmentation);
}
private void ProcessSegmentationMethod(object sender, RoutedEventArgs e)
{
string strSermenterName = (sender as Control).Tag.ToString();
ISegmentLine segmenter = ComponentCreator.MakeComponent <ISegmentLine>(strSermenterName);
if (segmenter == null || currBookLine == null)
{
return;
}
// приведем к чернобелому
Bytearray image = currBookLine.ImageBytearray;
//IBinarize binarizer = new BinarizeByOtsu();
//binarizer.Binarize(image, image);
OcrRoutine.binarize_simple(image, image);
// сегментация
Intarray charseg = new Intarray();
segmenter.Charseg(ref charseg, image);
// фон равен 0
SegmRoutine.make_line_segmentation_black(charseg);
// удалим маленькие сегменты
SegmRoutine.remove_small_components(charseg, 3, 3);
ImgLabels.renumber_labels(charseg, 1);
currBookLine.CharsegIntarray = charseg;
CurrSegmentsCount = NarrayUtil.Max(charseg);
// Show segmented image
ShowCharsegImage(charseg,
(currBookLine.HaveTranscript && CurrSegmentsCount == currBookLine.Transcript.Length) ?
currBookLine.Transcript : "");
// to enable save button
EnableCharsegCmdButtons();
}
public void TestArrays()
{
string imgfn = "test-c3.png";
// load Bytearray
Bytearray ba = new Bytearray(1, 1);
ImgIo.read_image_gray(ba, imgfn);
OcrRoutine.Invert(ba);
//NarrayUtil.Sub((byte)255, image);
byte[] bytes1 = ba.To1DArray();
NarrayShow.ShowConsole(ba);
StdInput linput1 = new StdInput(ba);
Console.WriteLine();
// load StdInput
Bitmap bitmap = ImgIo.LoadBitmapFromFile(imgfn);
StdInput linput2 = StdInput.FromBitmap(bitmap);
//NarrayShow.ShowConsole(linput2);
// test convert
Floatarray fa = linput2.ToFloatarray();
StdInput linput3 = new StdInput(fa);
Console.WriteLine("Arrays is identical? {0}", Equals(linput1.GetDataBuffer(), linput2.GetDataBuffer()));
Console.WriteLine("Arrays is identical? {0}", Equals(linput2.GetDataBuffer(), linput3.GetDataBuffer()));
}
public void SetLine(Bytearray image)
{
CHECK_ARG(image.Dim(1) < PGeti("maxheight"), "image.Dim(1) < PGeti(\"maxheight\")");
// run the segmenter
/*Narray<Rect> bboxes = new Narray<Rect>();
* Intarray iar = new Intarray();
* iar.Copy(image);
* ImgLabels.bounding_boxes(ref bboxes, iar);*/
//Console.WriteLine("IMG SETLINE: imin:{0} imax:{1}", NarrayUtil.ArgMin(iar), NarrayUtil.ArgMax(iar));
//Console.WriteLine("INDEX_BLACK:{0} {1} {2} {3}", bboxes[0].x0, bboxes[0].y0, bboxes[0].x1, bboxes[0].y1);
//ImgIo.write_image_gray("image.png", image);
OcrRoutine.binarize_simple(binarized, image);
segmenter.Object.Charseg(ref segmentation, binarized);
/*Intarray segm = new Intarray();
* segm.Copy(segmentation);
* ImgLabels.simple_recolor(segm);
* ImgIo.write_image_packed("segm_image.png", segm);*/
//NarrayUtil.Sub(255, binarized);
SegmRoutine.make_line_segmentation_black(segmentation);
SegmRoutine.remove_small_components(segmentation, 3, 3); // i add this line
ImgLabels.renumber_labels(segmentation, 1);
// set up the grouper
grouper.Object.SetSegmentation(segmentation);
}
public override void Charseg(ref Intarray outimage, Bytearray inimage)
{
int swidth = PGeti("swidth");
int sheight = PGeti("sheight");
Bytearray image = new Bytearray();
image.Copy(inimage);
OcrRoutine.binarize_simple(image);
OcrRoutine.Invert(image);
outimage.Copy(image);
if (swidth > 0 || sheight > 0)
{
Morph.binary_close_rect(image, swidth, sheight);
}
Intarray labels = new Intarray();
labels.Copy(image);
ImgLabels.label_components(ref labels);
for (int i = 0; i < outimage.Length1d(); i++)
{
if (outimage.At1d(i) > 0)
{
outimage.Put1d(i, SegmRoutine.cseg_pixel(labels.At1d(i)));
}
}
SegmRoutine.make_line_segmentation_white(outimage);
SegmRoutine.check_line_segmentation(outimage);
}
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 override void Charseg(ref Intarray segmentation, Bytearray inraw)
{
Logger.Default.Image("segmenting", inraw);
OcrRoutine.optional_check_background_is_lighter(inraw);
Bytearray image = new Bytearray();
image.Copy(inraw);
OcrRoutine.binarize_simple(image);
OcrRoutine.Invert(image);
segmenter.SetImage(image);
segmenter.FindAllCuts();
segmenter.FindBestCuts();
Intarray seg = new Intarray();
seg.Copy(image);
for (int r = 0; r < segmenter.bestcuts.Length(); r++)
{
int w = seg.Dim(0);
int c = segmenter.bestcuts[r];
Narray <Point> cut = segmenter.cuts[c];
for (int y = 0; y < image.Dim(1); y++)
{
for (int i = -1; i <= 1; i++)
{
int x = cut[y].X;
if (x < 1 || x >= w - 1)
{
continue;
}
seg[x + i, y] = 0;
}
}
}
ImgLabels.label_components(ref seg);
// dshowr(seg,"YY"); dwait();
segmentation.Copy(image);
ImgLabels.propagate_labels_to(ref segmentation, seg);
SegmRoutine.line_segmentation_merge_small_components(ref segmentation, small_merge_threshold);
SegmRoutine.line_segmentation_sort_x(segmentation);
SegmRoutine.make_line_segmentation_white(segmentation);
// set_line_number(segmentation, 1);
Logger.Default.Image("resulting segmentation", segmentation);
}
public override void Charseg(ref Intarray result_segmentation, Bytearray orig_image)
{
Bytearray image = new Bytearray();
image.Copy(orig_image);
OcrRoutine.optional_check_background_is_lighter(image);
OcrRoutine.binarize_simple(image);
OcrRoutine.Invert(image);
Intarray ccseg = new Intarray();
ccseg.Copy(image);
ImgLabels.label_components(ref ccseg);
base.Charseg(ref result_segmentation, orig_image);
SegmRoutine.combine_segmentations(ref result_segmentation, ccseg);
}
public override void Charseg(ref Intarray segmentation, Bytearray image)
{
Bytearray timage = new Bytearray();
timage.Copy(image);
//for (int i = 0; i < image.Length(); i++) image[i] = (byte)(image[i] > 0 ? 0 : 1);
OcrRoutine.binarize_simple(timage);
OcrRoutine.Invert(image);
Skeleton.Thin(ref timage);
//ImgIo.write_image_gray("_thinned.png", timage);
ImgMisc.remove_singular_points(ref timage, 2);
//ImgIo.write_image_gray("_segmented.png", timage);
Intarray tsegmentation = new Intarray();
tsegmentation.Copy(timage);
ImgLabels.label_components(ref tsegmentation);
SegmRoutine.remove_small_components(tsegmentation, 4, 4);
//ImgIo.write_image_packed("_labeled.png", tsegmentation);
segmentation.Copy(image);
ImgLabels.propagate_labels_to(ref segmentation, tsegmentation);
//ImgIo.write_image_packed("_propagated.png", segmentation);
}
public override void Charseg(ref Intarray segmentation, Bytearray inraw)
{
setParams();
//Logger.Default.Image("segmenting", inraw);
int PADDING = 3;
OcrRoutine.optional_check_background_is_lighter(inraw);
Bytearray image = new Bytearray();
image.Copy(inraw);
OcrRoutine.binarize_simple(image);
OcrRoutine.Invert(image);
SetImage(image);
FindAllCuts();
FindBestCuts();
Intarray seg = new Intarray();
seg.MakeLike(image);
seg.Fill(255);
for (int r = 0; r < bestcuts.Length(); r++)
{
int w = seg.Dim(0);
int c = bestcuts[r];
Narray <Point> cut = cuts[c];
for (int y = 0; y < image.Dim(1); y++)
{
for (int i = -1; i <= 1; i++)
{
int x = cut[y].X;
if (x < 1 || x >= w - 1)
{
continue;
}
seg[x + i, y] = 0;
}
}
}
ImgLabels.label_components(ref seg);
// dshowr(seg,"YY"); dwait();
segmentation.Copy(image);
for (int i = 0; i < seg.Length1d(); i++)
{
if (segmentation.At1d(i) == 0)
{
seg.Put1d(i, 0);
}
}
ImgLabels.propagate_labels_to(ref segmentation, seg);
if (PGeti("component_segmentation") > 0)
{
Intarray ccseg = new Intarray();
ccseg.Copy(image);
ImgLabels.label_components(ref ccseg);
SegmRoutine.combine_segmentations(ref segmentation, ccseg);
if (PGeti("fix_diacritics") > 0)
{
SegmRoutine.fix_diacritics(segmentation);
}
}
#if false
SegmRoutine.line_segmentation_merge_small_components(ref segmentation, small_merge_threshold);
SegmRoutine.line_segmentation_sort_x(segmentation);
#endif
SegmRoutine.make_line_segmentation_white(segmentation);
// set_line_number(segmentation, 1);
//Logger.Default.Image("resulting segmentation", segmentation);
}
public override void Extract(Narray <Floatarray> outarrays, Floatarray inarray)
{
outarrays.Clear();
Floatarray input = new Floatarray();
input.Copy(inarray);
int w = input.Dim(0), h = input.Dim(1);
Floatarray a = new Floatarray(); // working array
int csize = PGeti("csize");
// get rid of small components
SegmRoutine.erase_small_components(input, PGetf("minsize"), PGetf("threshold"));
// compute a thresholded version for morphological operations
Bytearray thresholded = new Bytearray();
OcrRoutine.threshold_frac(thresholded, input, PGetf("threshold"));
// compute a smoothed version of the input for gradient computations
float sigma = PGetf("gradsigma");
Floatarray smoothed = new Floatarray();
smoothed.Copy(input);
Gauss.Gauss2d(smoothed, sigma, sigma);
// x gradient
a.Resize(w, h);
for (int j = 0; j < h; j++)
{
for (int i = 0; i < w; i++)
{
float delta;
if (i == 0)
{
delta = 0f;
}
else
{
delta = smoothed[i, j] - smoothed[i - 1, j];
}
a[i, j] = delta;
}
}
Floatarray xgrad = outarrays.Push(new Floatarray());
OcrRoutine.scale_to(xgrad, a, csize, PGetf("noupscale"), PGetf("aa"));
for (int j = 0; j < csize; j++)
{
for (int i = 0; i < csize; i++)
{
if (j % 2 == 0)
{
xgrad[i, j] = Math.Max(xgrad[i, j], 0f);
}
else
{
xgrad[i, j] = Math.Min(xgrad[i, j], 0f);
}
}
}
// y gradient
a.Resize(w, h);
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
float delta;
if (j == 0)
{
delta = 0f;
}
else
{
delta = smoothed[i, j] - smoothed[i, j - 1];
}
a[i, j] = delta;
}
}
Floatarray ygrad = outarrays.Push(new Floatarray());
OcrRoutine.scale_to(ygrad, a, csize, PGetf("noupscale"), PGetf("aa"));
for (int i = 0; i < csize; i++)
{
for (int j = 0; j < csize; j++)
{
if (i % 2 == 0)
{
ygrad[i, j] = Math.Max(ygrad[i, j], 0f);
}
else
{
ygrad[i, j] = Math.Min(ygrad[i, j], 0f);
}
}
}
// junctions, endpoints, and holes
Floatarray junctions = new Floatarray();
Floatarray endpoints = new Floatarray();
Floatarray holes = new Floatarray();
Bytearray junctions1 = new Bytearray();
Bytearray endpoints1 = new Bytearray();
Bytearray holes1 = new Bytearray();
Bytearray dilated = new Bytearray();
Bytearray binary = new Bytearray();
junctions.MakeLike(input, 0f);
endpoints.MakeLike(input, 0f);
holes.MakeLike(input, 0f);
int n = PGeti("n");
float step = PGetf("step");
int bs = PGeti("binsmooth");
for (int i = 0; i < n; i++)
{
sigma = step * i;
if (bs > 0)
{
OcrRoutine.binsmooth(binary, input, sigma);
}
else
{
binary.Copy(thresholded);
Morph.binary_dilate_circle(binary, (int)(sigma));
}
OcrRoutine.skeletal_features(endpoints1, junctions1, binary, 0.0f, 0.0f);
NarrayUtil.Greater(junctions1, (byte)0, (byte)0, (byte)1);
junctions.Copy(junctions1);
NarrayUtil.Greater(endpoints1, (byte)0, (byte)0, (byte)1);
endpoints.Copy(endpoints1);
SegmRoutine.extract_holes(ref holes1, binary);
NarrayUtil.Greater(holes1, (byte)0, (byte)0, (byte)1);
holes.Copy(holes1);
}
junctions *= 1.0f / (float)n;
endpoints *= 1.0f / (float)n;
holes *= 1.0f / (float)n;
OcrRoutine.scale_to(outarrays.Push(new Floatarray()), junctions, csize, PGetf("noupscale"), PGetf("aa"));
OcrRoutine.scale_to(outarrays.Push(new Floatarray()), endpoints, csize, PGetf("noupscale"), PGetf("aa"));
OcrRoutine.scale_to(outarrays.Push(new Floatarray()), holes, csize, PGetf("noupscale"), PGetf("aa"));
}
