Example #1
0
        /// <summary>
        /// Add a recognition result to the list of results. The list is orderd by probability
        /// </summary>
        /// <param name="Probability"></param>
        /// <param name="Value"></param>
        public void AddRecognitionResult(double Probability, String Value)
        {
            RecognitionResult newResult;

            newResult = null;
            int iNewPosition = RecognitionResults.Count;

            if (Probability > 0.01)
            {
                newResult             = new RecognitionResult();
                newResult.Content     = Value;
                newResult.Probability = Probability;

                while (iNewPosition > 0 && RecognitionResults[iNewPosition - 1].Probability < Probability)
                {
                    iNewPosition--;
                }

                if (iNewPosition < 4)
                {
                    RecognitionResults.Insert(iNewPosition, newResult);
                }
            }
        }
Example #2
0
        /// <summary>
        /// This functions splits a character in multiple components. Used for splitting connected characters
        /// </summary>
        public void Split(ShapeNet ShapeNet)
        {
            List <int> SplitLines;

            //Step 1: Get the position for possible splits
            SplitLines = SplitDeterminePositions();

            if (SplitLines.Count == 0)
            {
                return;
            }

            RecognitionResults.Clear();

            //Step 2: Find the combination of the best (highest scores) recognised components
            List <PageComponent> Components = new List <PageComponent>(0);
            PageComponent        newComponent;
            PageComponent        prevComponent;
            Rectangle            SplitArea;
            int start, end;

            SplitLines.Insert(0, 0);
            SplitLines.Add(Width - 1);

            start = 0;
            end   = 1;

            while (end < SplitLines.Count)
            {
                SplitArea = new Rectangle(SplitLines[start] + 1, 0, SplitLines[end] - SplitLines[start] - 2, Height);

                if (SplitArea.Width > 0 && SplitArea.Height > 0)
                {
                    while (NumberPixelsOnRow(BinaryBytes, SplitArea, 0, 0) == 0)
                    {
                        SplitArea.Y      = SplitArea.Y + 1;
                        SplitArea.Height = SplitArea.Height - 1;
                    }

                    while (NumberPixelsOnRow(BinaryBytes, SplitArea, SplitArea.Height - 1, 0) == 0)
                    {
                        SplitArea.Height = SplitArea.Height - 1;
                    }

                    newComponent = PartialCopy(SplitArea);

                    ExtractFeatures.ExecuteExtractFeatures(newComponent, false);
                    RecogniseComponent.RecogniseWithoutConnectedRepair(ShapeNet, newComponent);

                    if (Components.Count > 0 && end - start > 1)
                    {
                        prevComponent = Components.Last();

                        if (prevComponent.ContentProbability < newComponent.ContentProbability && newComponent.Content != "connected" && newComponent.Content != "garbage")
                        {
                            Components.Remove(prevComponent);
                            Components.Add(newComponent);
                        }
                        else
                        {
                            start = end - 1;
                            end--;
                        }
                    }
                    else
                    {
                        Components.Add(newComponent);
                    }
                }
                end++;
            }

            //Add the new recognition result
            RecognitionResult newResult;

            newResult             = new RecognitionResult();
            newResult.Content     = "";
            newResult.Probability = 0;

            foreach (PageComponent Component in Components)
            {
                newResult.Content     += Component.Content;
                newResult.Probability += Component.ContentProbability;
            }

            newResult.Probability = newResult.Probability / Components.Count;

            RecognitionResults.Add(newResult);

            //Save a copy of the image to the disc
            if (DebugTrace.DebugTrace.TraceFeatures)
            {
                String ComponentID = "000000" + ID;
                ComponentID = ComponentID.Substring(ComponentID.Length - 6);

                foreach (int SplitLine in SplitLines)
                {
                    int pointer = SplitLine;

                    for (int y = 0; y < Height; y++)
                    {
                        if (BinaryBytes[SplitLine, y] == 0xFF)
                        {
                            BinaryBytes[SplitLine, y] = 0x10;
                        }
                        pointer += Stride;
                    }
                }

                Bitmap Bitmap   = DebugTrace.DebugTrace.CreateBitmapFromByteArray(BinaryBytes, new Size(Width, Height));
                String Filename = DebugTrace.DebugTrace.TraceFeatureFolder + "image_" + ComponentID + "_split.bmp";
                Bitmap.Save(Filename);
            }
        }