C\#aforge 라 이브 러 리 를 사용 하여 인증 코드 인 스 턴 스 를 식별 합 니 다.

시간 이 정말 빨리 가 네요.눈 깜짝 할 사이 에 올해 가 지나 갑 니 다.반년 동안 블 로 그 를 쓰 지 않 았 습 니 다.시간 을 말 해 야 죠.여동생 과 영 어 를 하 는 데 썼 습 니 다.하하...며칠 전에 맏형 이 나 에 게 물 었 다
왜 이렇게 오랫동안 블 로 그 를 쓰 지 않 았 습 니까?좋 습 니 다.계속 견지 하고 제 소감 을 계속 공유 하 세 요.
이 시 리 즈 는 우리 가 aforge.net 를 가지 고 놀 고 있 습 니 다.공식 적 인 말 을 사용 하면 개발 자 와 연구자 에 게 C\#프레임 워 크 를 바탕 으로 디자인 된 것 입 니 다.이 프레임 워 크 는 서로 다른 라 이브 러 리 와 라 이브 러 리 에 관 한 것 을 제공 합 니 다.
자원,그리고 많은 응용 프로그램 예,컴퓨터 시각 과 인공지능,이미지 처리,신경 망,유전 알고리즘,기계 학습,로봇 등 분야,이 시리즈 연구 의 중심 을 포함한다.
바로 AForge.Imaging 이라는 네 임 스페이스 아래 의 동쪽 을 마구 잡 이 로 만 드 는 것 입 니 다.
    참,얼마나 많은 회사 가 데 스 카드 를 직원 들 의 복지 카드 로 사용 하 는 지 모 르 겠 습 니 다.우리 회 사 는 바로 이 렇 습 니 다.매달 회사 에서 Money 를 충전 합 니 다.그리고 우리 같은 방귀 농민 들 은 매달 15 일 에 얼마나 보 냈 는 지 즐겁게 보 러 갑 니 다.

올 라 가서 보 니 어허~그리고 90 년대 의 인증 코드 가 있 습 니 다.올 해 는 이런 인증 코드 를 찾 은 사이트 가 많 지 않 을 것 같 습 니 다.이미지 처 리 를 조금 알 면 이 인증 코드 는...
감사합니다.이 편 은 우리 가 어떻게 그것 을 식별 하 는 지 보 자.
인증 코드 처리
1.  일반 처리 원칙
    이러한 인증 코드 는 왜 없 는 것 과 같다 고 말 합 니까?첫 번 째 는 글씨체 규범 이 정연 하고 두 번 째 는 회전 하지 않 고 왜곡 되 어 붙 어 있 습 니 다.세 번 째 는 글씨체 의 색깔 이 단일 하고 아래 는 처리 절 차 를 보 겠 습 니 다.
여기 서 주의해 야 할 것 은 aforge 는 픽 셀 형식 이 24/32bpp 인 픽 셀 형식 그림 만 받 아들 이기 때문에 처리 하기 전에 먼저 형식 전환 을 진행 합 니 다.

//
            var bnew = new Bitmap(b.Width, b.Height, PixelFormat.Format24bppRgb);

            Graphics g = Graphics.FromImage(bnew);

            g.DrawImage(b, 0, 0);

            g.Dispose();

<1>그림 그 레이스 케 일
이것 은 이미지 인식 이 보통 가 야 하 는 첫 번 째 단계 이다.이미지 그 레이스 케 일 화 는 후속 적 으로 rgb 에 대한 계 산 량 을 줄 이 는 데 도움 이 되 고 우리 가 이치 화 하 는 데 도 편리 하 다.aforge 에서 우 리 는 전문 적 인 유형 을 한 걸음 에 해결 하고 간결 하고 편리 하 다.

            //
            b = new Grayscale(0.2125, 0.7154, 0.0721).Apply(b);
<2>이치 화
  이치 화 는 말 그대로 두 가지 값 이다.예 를 들 어 흰색 이 아니면 검은색 이 고 검은색 이 아니면 흰색 이다.그러면 흰색 과 검은색 의 기준 은 하나의 한도 값 을 제공 해 야 한다.크 거나 작 으 면 어 떨 까?aforge 에서 도 비슷 한 유형 으로 처리 해 야 한다.

            //
            b = new Threshold(50).Apply(b);
<3>소음 제거
  위의 사진 에서 볼 수 있 듯 이 붉 은 점 이 많아 서 피부병 처럼 만 들 었 다.자세히 살 펴 보면 이런 소음 은 독립 적 이 고 부피 가 작은 특징 을 가지 고 있 기 때문에 판단 하 는 기준 은 그림 에서 특정한 블록 의 크기 가 내 가 설정 한 한도 값 안에 있 으 면 이 를 없 애고 똑 같이 전문 적 인 유형 으로 처리 하 는 것 이다.

            //
            new BlobsFiltering(1, 1, b.Width, b.Height).Apply(b);
  여기 서 구체 적 으로 파 라 메 터 를 어떻게 전달 하 는 지 후속 시 리 즈 는 천천히 해석 할 것 이다.
<4>그림 자 르 기
   그림 을 자 르 는 장점 은 우리 가 진정 으로 식별 해 야 할 요소 의 효과 적 인 범위 가 얼마나 큰 지 알 아야 하 는 동시에 우리 가 이 그림 들 을 템 플 릿 으로 저장 하 는 데 도 편리 하 다 는 것 이다.

코드 는 다음 과 같 습 니 다:

/// <summary>
        /// Y
        /// ( )
        /// </summary>
        /// <param name="?"></param>
        /// <returns></returns>
        public List<Bitmap> Crop_Y(Bitmap b)
        {
            var list = new List<Bitmap>();

            // “1” ,
            int[] cols = new int[b.Width];

            /*
             * 
             */
            for (int x = 0; x < b.Width; x++)
            {
                for (int y = 0; y < b.Height; y++)
                {
                    //
                    var pixel = b.GetPixel(x, y);

                    //
                    if (pixel.R == 0)
                    {
                        cols[x] = ++cols[x];
                    }
                }
            }

            int left = 0, right = 0;

            for (int i = 0; i < cols.Length; i++)
            {
                // ( , , , )
                if (cols[i] > 0 || (i + 1 < cols.Length && cols[i + 1] > 0))
                {
                    if (left == 0)
                    {
                        // left
                        left = i;
                    }
                    else
                    {
                        // right
                        right = i;
                    }
                }
                else
                {
                    // ,
                    if ((left > 0 || right > 0))
                    {
                        Crop corp = new Crop(new Rectangle(left, 0, right - left + 1, b.Height));

                        var small = corp.Apply(b);

                        // , 20*50

                        list.Add(small);
                    }

                    left = right = 0;
                }
            }

            return list;
        }

        /// <summary>
        /// X
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        public List<Bitmap> Crop_X(List<Bitmap> list)
        {
            var corplist = new List<Bitmap>();

            // ,
            foreach (var segb in list)
            {
                // “1” ,
                int[] rows = new int[segb.Height];

                /*
                 * 
                 */
                for (int y = 0; y < segb.Height; y++)
                {
                    for (int x = 0; x < segb.Width; x++)
                    {
                        //
                        var pixel = segb.GetPixel(x, y);

                        //
                        if (pixel.R == 0)
                        {
                            rows[y] = ++rows[y];
                        }
                    }
                }

                int bottom = 0, top = 0;

                for (int y = 0; y < rows.Length; y++)
                {
                    // ( , , , )
                    if (rows[y] > 0 || (y + 1 < rows.Length && rows[y + 1] > 0))
                    {
                        if (top == 0)
                        {
                            // top
                            top = y;
                        }
                        else
                        {
                            // bottom
                            bottom = y;
                        }
                    }
                    else
                    {
                        // ,
                        if ((top > 0 || bottom > 0) && bottom - top > 0)
                        {
                            Crop corp = new Crop(new Rectangle(0, top, segb.Width, bottom - top + 1));

                            var small = corp.Apply(segb);

                            corplist.Add(small);
                        }

                        top = bottom = 0;
                    }
                }
            }

            return corplist;
        }

<5>이미지 정밀 처리
여기 서 주의해 야 할 것 은 예 를 들 어 숫자'2'는 상하 좌우 의 공백 을 제거 한 후에 소음 의 간섭 을 더 해 매번 자 른 그림 의 크기 가 똑 같 지 않 기 때문에 여기 서 더욱 편리 하 게 식별 하기 위해 우 리 는 그림 의 크기 를 리 셋 하고'숫자 2'를 문자 가운데 로 해 야 한다.

/// <summary>
        ///
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public List<Bitmap> ToResizeAndCenterIt(List<Bitmap> list, int w = 20, int h = 20)
        {
            List<Bitmap> resizeList = new List<Bitmap>();


            for (int i = 0; i < list.Count; i++)
            {
                //
                list[i] = new Invert().Apply(list[i]);

                int sw = list[i].Width;
                int sh = list[i].Height;

                Crop corpFilter = new Crop(new Rectangle(0, 0, w, h));

                list[i] = corpFilter.Apply(list[i]);

                //
                list[i] = new Invert().Apply(list[i]);

                //
                int centerX = (w - sw) / 2;
                int centerY = (h - sh) / 2;

                list[i] = new CanvasMove(new IntPoint(centerX, centerY), Color.White).Apply(list[i]);

                resizeList.Add(list[i]);
            }

            return resizeList;
        }

사실 정교 하 게 처리 한 후에 이 그림 들 은 우리 의 템 플 릿 라 이브 러 리 의 그림 이 될 수 있 습 니 다.모든 템 플 릿 그림 에 구체 적 인 숫자 를 표시 할 수 있 습 니 다.나중에 우리 가 다시 만 났 을 때 싱크로 율 을 계산 하면 됩 니 다.다음은 이미 제 작 된 템 플 릿 입 니 다.

<6>템 플 릿 일치 식별
템 플 릿 사진 이 다 만 들 어 졌 으 니 모든 것 이 거의 다 되 지 않 았 습 니 다.다음 에 오 는 인증 코드 는 제 가 다 자 른 후에 정밀 한 그림 을 만 든 후에 템 플 릿 과 일치 합 니 다.afroge 안에 있 습 니 다.
템 플 릿 매 칭 을 위 한 ExhaustiveTemplate Matching 이 있 습 니 다.편리 합 니 다.

 ExhaustiveTemplateMatching templateMatching = new ExhaustiveTemplateMatching(0.9f);
여기 서 0.9f 는 바로 설 정 된 한도 값 이다.0.9 보다 큰 한도 값 만 이 템 플 릿 이 목표 그림 과 비슷 하 다 고 생각 한 다음 에 0.9 보다 큰 싱크로 율 에서 가장 큰 것 을 얻 을 수 있다.
우리 가 마지막 으로 식별 한 이미지.

var files = Directory.GetFiles(Environment.CurrentDirectory + "\\Template\\");

            var templateList = files.Select(i => { return new Bitmap(i); }).ToList();
            var templateListFileName = files.Select(i => { return i.Substring(30, 1); }).ToList();

            var result = new List<string>();

            ExhaustiveTemplateMatching templateMatching = new ExhaustiveTemplateMatching(0.9f);

            // ,
            for (int i = 0; i < list.Count; i++)
            {
                float max = 0;
                int index = 0;

                for (int j = 0; j < templateList.Count; j++)
                {
                    var compare = templateMatching.ProcessImage(list[i], templateList[j]);

                    if (compare.Length > 0 && compare[0].Similarity > max)
                    {
                        //
                        max = compare[0].Similarity;
                        index = j;
                    }
                }

                result.Add(templateListFileName[index]);
            }

마지막 효 과 는 괜 찮 습 니 다.식별 율 은 기본적으로 100%입 니 다.

좋은 웹페이지 즐겨찾기