Esempio n. 1
0
        public static CachedBitmap[] ExtractPlayerNames(this Bitmap img, bool isTrophyScreen = false)
        {
            if (img == null)
            {
                throw new ArgumentException("The given screenshot does not exist!");
            }
            if (img.Width != 1280 || img.Height != 720)
            {
                throw new ArgumentException("The size of the given screenshot is not valid!");
            }

            Bitmap[]       playerImages       = new Bitmap[12];
            CachedBitmap[] cachedPlayerImages = new CachedBitmap[12];
            if (isTrophyScreen) // try detect trophy screen later...
            {
            }
            else
            {
                for (int i = 0; i < 12; i++)
                {
                    playerImages[i] = img.extractRegion(680, 52 + 52 * i, 276, 43);
                }

                for (int i = 0; i < 12; i++)
                {
                    float isYellow = playerImages[i].RegionProximity(0, 0, playerImages[i].Width, 5, 15, 220, 241);

                    byte[] processedImg;
                    if (isYellow > 0.8f)
                    {
                        processedImg = playerImages[i].Binarize(77, 85, 64, 0.8f);
                    }
                    else
                    {
                        processedImg = playerImages[i].Binarize(255, 255, 255, 0.7f);
                    }

                    cachedPlayerImages[i] = new CachedBitmap((Bitmap)ic.ConvertFrom(processedImg));
                }
            }

            return(cachedPlayerImages);
        }
Esempio n. 2
0
        public static CachedBitmap[] ExtractPlayerFlags(this Bitmap img)
        {
            if (img == null)
            {
                throw new ArgumentException("The given screenshot does not exist!");
            }
            if (img.Width != 1280 || img.Height != 720)
            {
                throw new ArgumentException("The size of the given screenshot is not valid!");
            }

            CachedBitmap[] cachedPlayerFlags = new CachedBitmap[12];

            for (int i = 0; i < 12; i++)
            {
                cachedPlayerFlags[i] = new CachedBitmap(img.extractRegion(958, 60 + 52 * i, 42, 28));
            }

            return(cachedPlayerFlags);
        }
Esempio n. 3
0
        public static CachedBitmap[] ExtractPlayerTags(this Bitmap img)
        {
            if (img == null)
            {
                throw new ArgumentException("The given screenshot does not exist!");
            }
            if (img.Width != 1280 || img.Height != 720)
            {
                throw new ArgumentException("The size of the given screenshot is not valid!");
            }

            Bitmap[] tagImages = new Bitmap[12];
            for (int i = 0; i < 12; i++)
            {
                tagImages[i] = img.extractRegion(680, 52 + 52 * i, 72, 43);
            }

            CachedBitmap[] cachedPlayerTags = new CachedBitmap[12];
            for (int i = 0; i < 12; i++)
            {
                float isYellow = tagImages[i].RegionProximity(0, 0, tagImages[i].Width, 5, 15, 220, 241);

                byte[] processedImg;
                if (isYellow > 0.8f)
                {
                    processedImg = tagImages[i].Binarize(77, 85, 64, 0.8f);
                }
                else
                {
                    processedImg = tagImages[i].Binarize(255, 255, 255, 0.7f);
                }

                cachedPlayerTags[i] = new CachedBitmap((Bitmap)ic.ConvertFrom(processedImg));
            }


            return(cachedPlayerTags);
        }
Esempio n. 4
0
        public string RecognizePlayer(CachedBitmap img)
        {
            string str        = string.Empty;
            int    x          = 0;
            double confidence = 0f;

            while (true)
            {
                List <GlyphScore> scores = new List <GlyphScore>();

                for (int skip = -1; skip <= 1; skip++)
                {
                    int xBegin = img.FindNextBinaryColumn(x + skip, true);
                    if (xBegin == -1)
                    {
                        break;
                    }

                    foreach (BinaryChar glyph in charCache.Where(p => p.Type == CharType.Text))
                    {
                        double score = scoreGlyph(img, glyph, xBegin + skip);
                        if (score == -9999 || double.IsNaN(score))
                        {
                            continue;
                        }
                        scores.Add(new GlyphScore()
                        {
                            X = xBegin + skip, Glyph = glyph, Score = score
                        });
                    }
                }
                if (scores.Count == 0)
                {
                    break;
                }

                scores = scores.OrderByDescending(p => p.Score).ToList();
                GlyphScore chosen = scores[0];
                confidence += chosen.Score;

                if (chosen.X - x > 6)
                {
                    str += " ";
                }

                string s = chosen.Glyph.Data;
                if (s == "l" || s == "i" || s == "I" || s == "!" || s == "ı")
                {
                    // Disambiguate All I´s
                }
                str += s;

                for (int y = 0; y < img.Height; y++)
                {
                    for (int xp = 0; xp < chosen.Glyph.Bitmap.Width; xp++)
                    {
                        if (chosen.Glyph.Bitmap.GetBinaryPixel(xp, y))
                        {
                            if (img.GetBinaryPixel(chosen.X + xp, y))
                            {
                                img.SetPixel(chosen.X + xp, y, 0, 0, 255);
                            }
                            else
                            {
                                img.SetPixel(chosen.X + xp, y, 255, 0, 255);
                            }
                        }
                        else if (img.GetBinaryPixel(chosen.X + xp, y))
                        {
                            img.SetPixel(chosen.X + xp, y, 255, 0, 0);
                        }
                    }
                }

                for (int y = 0; y < img.Height; y++)
                {
                    if (!img.GetBinaryPixel(chosen.X, y))
                    {
                        img.SetPixel(chosen.X, y, 0, 0, 255);
                    }
                }

                x = chosen.X + chosen.Glyph.Bitmap.Width + 1;
            }

            for (int i = 0; i < str.Length; i++)
            {
                char c = str[i];
                if (c != 'l' && c != 'I')
                {
                    continue;
                }

                char prev = (i > 0 ? str[i - 1] : ' ');
                char next = (i < str.Length - 1 ? str[i + 1] : ' ');

                if ((c == 'l' && prev == ' ') ||
                    (isUppercase(prev) && isUppercase(next)))
                {
                    str = replaceChar(str, i, 'I');
                }
            }

            return(str);
        }
Esempio n. 5
0
        private double scoreGlyph(CachedBitmap img, BinaryChar glyph, int xPen)
        {
            int nextColumn      = img.CacheNextFilledColumn.ElementAtOrDefault(xPen + 2);
            int nextEmptyColumn = img.CacheNextEmptyColumn.ElementAtOrDefault(xPen + glyph.Bitmap.Width);
            int endColumn       = img.CacheNextFilledColumn.ElementAtOrDefault(xPen + glyph.Bitmap.Width + 4);
            int prevColumn      = img.CachePrevFilledColumn.ElementAtOrDefault(xPen + glyph.Bitmap.Width + 1);

            if (nextColumn == -1 || prevColumn == -1)
            {
                return(-9999d);
            }
            if (nextColumn - xPen < 2 || (endColumn == -1 && prevColumn - xPen < 2))
            {
                return(-9999d);
            }
            if (nextEmptyColumn == -1 || nextEmptyColumn - xPen > 80)
            {
                return(-9999d);
            }

            int    estimatedWidthDiff  = Math.Abs((nextEmptyColumn - xPen) - glyph.Bitmap.Width);
            double estimatedWidthBonus = 1d / (estimatedWidthDiff + 1d);

            double wrongColumns = 0d;

            for (int x = xPen; x < (xPen + glyph.Bitmap.Width); x++)
            {
                wrongColumns += Math.Abs(img.CacheColumnFilling.ElementAtOrDefault(x) - glyph.Bitmap.CacheColumnFilling.ElementAtOrDefault(x - xPen));
            }

            if (glyph.Bitmap.Width < 5)
            {
                wrongColumns = 0d;
            }
            else
            {
                wrongColumns /= glyph.Bitmap.Width;
            }

            double nonMatchingPixels = 0d;
            double glyphDistanceSum  = 0d;
            double glyphDistanceMax  = 0d;
            double glyphPixelNum     = 0d;
            double targetDistanceSum = 0d;
            double targetDistanceNum = 0d;
            double targetDistanceMax = 0d;
            double targetPixelNum    = 0d;

            for (int y = 0; y < img.Height; y++)
            {
                for (int x = 0; x < glyph.Bitmap.Width; x++)
                {
                    if (glyph.Bitmap.CacheNearestBinaryPixel[y].ElementAtOrDefault(x) == 0)
                    {
                        glyphPixelNum++;

                        double distance = img.CacheNearestBinaryPixel[y].ElementAtOrDefault(x + xPen);
                        glyphDistanceSum += distance;
                        glyphDistanceMax  = Math.Max(glyphDistanceMax, distance);
                    }

                    if (img.CacheNearestBinaryPixel[y].ElementAtOrDefault(x + xPen) == 0)
                    {
                        targetPixelNum++;

                        double distance = glyph.Bitmap.CacheNearestBinaryPixel[y][x];
                        targetDistanceSum += distance;
                        targetDistanceNum++;
                        targetDistanceMax = Math.Max(targetDistanceMax, distance);
                    }

                    if ((img.CacheNearestBinaryPixel[y].ElementAtOrDefault(x + xPen) <= 1) ^ (glyph.Bitmap.CacheNearestBinaryPixel[y].ElementAtOrDefault(x) <= 1))
                    {
                        nonMatchingPixels++;
                    }
                }
            }

            List <double> scoreParts = new List <double>()
            {
                -Math.Pow(glyphDistanceMax <= 1 ? 0d : glyphDistanceMax, 1.5d) * 5,
                -glyphDistanceSum / (glyphPixelNum * 0.1d),
                -glyphDistanceSum * 0.05d,
                -Math.Pow(targetDistanceMax <= 1 ? 0d : targetDistanceMax, 1.5d) * 10d,
                -(targetDistanceSum / targetDistanceNum) * 25d,
                -targetDistanceSum * 0.1d,
                -nonMatchingPixels * 0.05d,
                +(glyph.Bitmap.Width < 8 ? -5d + (glyph.Bitmap.Width * 0.5d) : 20 + (glyph.Bitmap.Width - 8) * 0.5),
                +estimatedWidthBonus * 19d,
                (glyph.Bitmap.Width < 8 && estimatedWidthBonus < 0.5) ? -10 : 0,
                (glyph.Bitmap.Width <8 && estimatedWidthBonus> 0.5) ? 10 : 0,
                glyphPixelNum * 0.075,
            };

            double score = 0f;

            foreach (double scorePart in scoreParts)
            {
                if (!Double.IsNaN(scorePart))
                {
                    score += scorePart;
                }
                else
                {
                }
            }

            return(score);
        }