На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
! правила раздела Алгоритмы
1. Помните, что название темы должно хоть как-то отражать ее содержимое (не создавайте темы с заголовком ПОМОГИТЕ, HELP и т.д.). Злоупотребление заглавными буквами в заголовках тем ЗАПРЕЩЕНО.
2. При создании темы постарайтесь, как можно более точно описать проблему, а не ограничиваться общими понятиями и определениями.
3. Приводимые фрагменты исходного кода старайтесь выделять тегами code.../code
4. Помните, чем подробнее Вы опишете свою проблему, тем быстрее получите вразумительный совет
5. Запрещено поднимать неактуальные темы (ПРИМЕР: запрещено отвечать на вопрос из серии "срочно надо", заданный в 2003 году)
6. И не забывайте о кнопочках TRANSLIT и РУССКАЯ КЛАВИАТУРА, если не можете писать в русской раскладке :)
Модераторы: Akina, shadeofgray
  
> Улучшение изображения отпечатка пальцев , Проблема при вычислении расхождения полутонового изображения
    Всем привет.
    Пишу курсач на тему "Улучшение изображения отпечатка пальцев". Тема интересная но и не простая. Перерыл много форумов, статей и др и в конечном итоге нашел то, что мне надо - достаточно не плохое описание всего процесса (улучшения изображения): описание
    И самое обидное, что первый же пункт не получается.
    Первое, что надо высчитать, по предложенному алгоритму, это среднюю величину и расхождение полутонового изображения.
    user posted image
    Ну тут всё просто:
    ExpandedWrap disabled
      // Calculate M
      M = 0;
      for (int i = 0; i < N; i++)
      {
          for (int j = 0; j < N; j++)
          {
              M += BitmapData[i, j].Gray();
          }
      }
      M /= Math.Pow(N, 2);
       
      // Calculate VAR
      VAR = 0;
      for (int i = 0; i < N; i++)
      {
          for (int j = 0; j < N; j++)
          {
              VAR += Math.Pow(BitmapData[i, j].Gray() - M, 2);
          }
      }
      VAR /= Math.Pow(N, 2);

    Однако... число VAR считается как то не правильно что ли. Получается слишком большое. Сразу не обращал на это внимание. Но когда приступил ко второму пункту (нормализация изображения), то этот косяк выявился.
    Дело в том, что я прогонял в алгоритме их же пример: клик и у меня на выходе было не то, что надо. Тогда начал подставлять разные значения в VAR и наткнулся на случай, что у меня всё отработало как надо (если VAR = 5, хотя у меня она была равна примерно тысяче). Ну в общем я в тупике :(. Если есть идеи что не так, буду рад их услышать.

    Заранее спасибо.
      а) допустим, что самый тёмный = 0.
      б) --||-- самый яркий = 200.
      в) в первом цикле посчитаем средний M, получим 100.
      г) во втором цикле будет сумма числа x, где x = 100 в квадрате.
      д) усреднится в конце - на выходе будет 100 в квадрате.
      Вот вкратце. Думайте, что тут не так.
        programm_err
        Оно и должно быть большим так как в квадрате.Т.е в диапозоне 0..65025
          Вторая формула не совсем правильная, там не СКО, а дисперсия вычисляется (VAR2)
            Ну то, что оно должно быть большим, я понял исходя из формулы. По этому, как и писал, не обратил на это внимания. Но когда начал нормализовать изображение - получалось не то, что надо. Возможно дело не в VAR. Но тогда в чем?
            Может я в коде накосячил? Хотя вроде как проверил несколько раз =(
            ExpandedWrap disabled
              for (int i = 0; i < N; i++)
              {
                  for (int j = 0; j < N; j++)
                  {
                      int gray = BitmapData[i, j].Gray();
                      int pow = (int)(Math.Pow(gray - M, 2) * VAR0);
                      gray = (int)Math.Floor(M0 + Math.Sqrt(pow / VAR));
                      if (gray > M)
                      {
                          gray += (int)M0;
                      }
                      else
                      {
                          gray = (int)M0 - gray;
                      }
                      BitmapData[i, j] = Color.FromArgb(gray, gray, gray);
                  }
              }

            Цитата amk @
            amk
            , а какой формулой предложите пользоваться вы?
              (int)Math.Floor(M0 + Math

              M0 лишняя
                Ох, какая глупая ошибка, спасибо что нашли.
                Тем не менее, результат всё равно не тот =(

                Добавлено
                Пожалуй надо добавить что условие
                ExpandedWrap disabled
                  if (gray > M)
                  {
                      gray += (int)M0;
                      a++;
                  }

                никогда не выполняется.
                  programm_err, а есть эталонный пример? Так чтобы пошагово все значения были подсчитаны?
                    programm_err
                    Цитата programm_err @
                    никогда не выполняется.

                    это по тому что у вас ещё одна ошибка вы получили gray потом тут же поменяли его значение.
                    Пробуете использовать 1 переменную вместо 2.
                      Цитата programm_err @
                      а какой формулой предложите пользоваться вы?

                      Корень квадратный от VAR возьми.

                      Выпиши отдельно формулы для нормализации - из твоих кусков программ непонятно, что ты хочешь получить.
                        Pavia, это нашел уже, но спасибо и вам.
                        amk, для данной формулы:
                        user posted image
                        я сначала беру яркость пикселя
                        ExpandedWrap disabled
                          int gray = BitmapData[i, j].Gray();

                        Далее считаю знаменатель
                        ExpandedWrap disabled
                          int pow = (int)Math.Pow(gray - M, 2) * VAR0;

                        Далее числитель делю на VAR и из результата беру корень
                        ExpandedWrap disabled
                          int ngray = (int)Math.Floor(Math.Sqrt(pow / VAR));

                        Далее в зависимости от gray увеличиваю на М0 или вычитаю из М0 новый цвет.
                        ExpandedWrap disabled
                          if (gray > M)
                          {
                              ngray = M0 + ngray;
                          }
                          else
                          {
                              ngray = M0 - ngray;
                          }

                        после чего в исходном изображении меняю значение пикселя
                        ExpandedWrap disabled
                          BitmapData[i, j] = Color.FromArgb(ngray, ngray, ngray);


                        После вашего первого сообщения брал из VAR корень. Результат более похож на правду, но не такой же как в примере.
                        user posted image -> user posted image
                          не знаменатель, а числитель :)
                            Math teacher, не совсем понял что вы хотите. Что такое эталонный пример?
                              Интересно, кто такую дурость в формуле написал.
                              Приведенная двойная формула эквивалентна простой

                              G(i,j) = M0 + (I(i,j) - M)*sqrt(VAR0/VAR)

                              sqrt(VAR0/VAR) лучше вычислить заранее
                              Для этой формулы корень из VAR брать не нужно, он и так берется.

                              Чему у тебя равны M0 и VAR0?

                              По моим прикидкам значение VAR0 должно быть порядка 1282 = 16384 или немного меньше. M0 = 128
                                amk
                                Извините что так долго отвечал.
                                Я попробовал вашим алгоритмом и у меня что-то не так пошло. Распишу всё. Посчитал М = 218. Посчитал VAR = 965/
                                ExpandedWrap disabled
                                  int N2 = N * N;
                                  // Calculate M
                                  M = 0;
                                  for (int i = 0; i < N; i++)
                                  {
                                      for (int j = 0; j < N; j++)
                                      {
                                          M += BitmapData[i, j].Gray();
                                      }
                                  }
                                  M /= N2;
                                   
                                  // Calculate VAR
                                  VAR = 0;
                                  for (int i = 0; i < N; i++)
                                  {
                                      for (int j = 0; j < N; j++)
                                      {
                                          VAR += (int)Math.Pow(BitmapData[i, j].Gray() - M, 2);
                                      }
                                  }
                                  VAR /= N2;

                                Далее начал нормализацию. В начале как вы и писали посчитал sqrt(VAR0/VAR)
                                ExpandedWrap disabled
                                  int div = (int)Math.Sqrt(VAR / Math.Pow(VAR0, 2)); // VAR0 = 128

                                Ну а далее получаем следующее:
                                Math.Pow(VAR0, 2) = 16384
                                VAR / Math.Pow(VAR0, 2) = 0.06
                                (int)Math.Sqrt(VAR / Math.Pow(VAR0, 2)) = 0

                                Очевидно, что я что-то не так сделал, но вроде делал именно то, что вы писали.
                                  Стоп! Я допустил ошибку.
                                  ExpandedWrap disabled
                                    int div = (int)Math.Sqrt(Math.Pow(VAR0, 2) / VAR);

                                  Проверил - всё работает как надо! Как я рад. Спасибо вам огромное!
                                    И так. чего я добился (не без помощи) на этом этапе.
                                    Отпечаток пальца из примера нормализовался на ура. Результат именно тот, которого и ожидал:
                                    user posted image -> user posted image

                                    Но далее я попробовал проделать этот же алгоритм, только уже с реальными отпечатками:
                                    user posted image -> user posted image

                                    Результат мне не очень понравился. Однако подумал, что возможно это нормальный результат.
                                    Следующий шаг - Частотное изображение выступа.
                                    Для этого надо для каждого пикселя искать градиенты. Я решил проверить - как отработает выделение границ изображения с помощью оператора Собеля. И получилось что, для изображения, которое дано в примере в статье - все границы выделились очень четко, а вот для реального изображения - плохо (а именно - границ почти не видно).

                                    Возможно кто-то знает, каким оператором, кроме Собеля, можно воспользоваться для более четкой детализации?
                                      Цитата programm_err @
                                      Стоп! Я допустил ошибку.
                                      С математикой у тебя слабовато, элементарные преобразования формул не можешь сделать (или ленишься). Я потому и предлагал сразу в VAR корень записывать (СКО).

                                      В примере у тебя идеальный отпечаток. Он имеет более-менее равномерный фон и равномерную контрастность. Чтобы получить аналогичный результат с реальных изображений надо применять этот алгоритм локально. Выделяешь на изображении квадратик размером скажем 16х16 - вычисляешь M и VAR (лучше сразу взяв корень). Сдвигаешь квадратик на 8 пикселей (можно выбрать и другой шаг) - снова вычисляешь M и VAR. Полученные значения сглаживаешь (хотя бы линейной интерполяцией) и для каждой точки вычисляешь новое значение исходя из локальных значений M и VAR.

                                      Добавлено
                                      Правда в таком простейшем случае вокруг отпечатка будет мусор.

                                      И вообще этот метод нормализации для изображений близких к бинарным работает не ахти.
                                        programm_err
                                        Видимо у вас какие-то ещё ошибки. У вас белый цвет после нормализации становиться серым.

                                        По поводу второго отпечатка. Реальное изображение повернуто и пустой фон заполнен белым цветом. Вам нужно проделать обратное в фотошопе повернуть и обрезать белый цвет. А то иначе алгоритм нормализации будет сбоить, так как оценку среднего и дисперсии сделает неправильную. Либо разбить картинку на локальные области произвести для каждой области свою оценку и нормализацию.

                                        По поводу оператора Собеля. В начале предыдущей статьи указанно разрешение сканирования. У второй картинке разрешение явно в 2 раза больше.
                                        Вам нужно её уменьшить что-бы привести к нормальному разрешению. Иначе оператор Собеля будет вести себя неустойчиво(другими словами может выдавать чёрти что кроме нужного). В принципе можно не картинку уменьшать, а радиус оператор Собеля увеличивать.

                                        Цитата
                                        ко, а вот для реального изображения - плохо (а именно - границ почти не видно).

                                        То что они плохие это ещё ничего не значит. Нас интересует среднее значение по некоторой окрестности в данном случае 16 на 16 пикселей.
                                        Сообщение отредактировано: Pavia -
                                          Цитата Pavia @
                                          белый цвет после нормализации становиться серым.
                                          Это как раз демонстрирует то, что метод вообще не совсем корректен. Светлых пикселей на изображении больше, поэтому среднее значение смещено к светлой части. После преобразования светлые пиксели становятся не белыми, а серыми.
                                            А вот, кстати, что получается после несложной обработки в редакторе.
                                            Делаем копию изображения.
                                            Размываем его, я использовал "Gauss Blur" с радиусом 6 (что бы совсем не видно было отпечатка)
                                            Вычитаем размытое изображение из исходного + 128
                                            Для полученной картинки корректируем яркость и контраст (я добавил 32% яркости и 72% контраста)
                                            Прикреплённая картинка
                                            Прикреплённая картинка


                                            Добавлено
                                            Да, пользовался редактором Paint Shop Pro 9
                                              amk
                                              Цитата amk @
                                              Это как раз демонстрирует то, что метод вообще не совсем корректен.

                                              Да, то что там описано лучше заменить автоконтрастом.

                                              Особого смысл в нормализации не вижу. Если только для последующей сохранения в базе данных.

                                              А вообще ИХМО лучше её сделать так.


                                              ExpandedWrap disabled
                                                procedure Normalizetion1(var r:TByteMap; bm:TByteMap; sigma:Real); Overload;
                                                var rm,rm1,mean,variant:TRealMap;
                                                 mean_,std_:Real;
                                                 p,p0:PAByte;
                                                 p1,p2:PAReal;
                                                 LL,i,j:Integer;
                                                begin
                                                 if r=nil then
                                                    begin
                                                    R:=TByteMap.Create(bm.UnitFormat);
                                                    R.Fast:=True;
                                                    R.Width:=bm.Width;
                                                    R.Height:=bm.Height;
                                                    R.Fast:=False;
                                                    end else
                                                    begin
                                                    if not ((r.UnitFormat=bm.UnitFormat) and (r.Width=bm.Width)
                                                           and (r.Height=bm.Height)) then exit;
                                                    end;
                                                 
                                                rm:=ByteMap2RealMap(bm);
                                                mean:=GausianBlur(rm,sigma);
                                                rm1:=Mul(rm,rm);
                                                rm.Free;
                                                variant:=GausianBlur(rm1,sigma);
                                                if (mean<>nil) and (variant<>nil) then
                                                 begin
                                                 LL:=mean.Width*mean.UnitFormat;
                                                 for j:=0  to mean.Height-1 do
                                                  begin
                                                  p:=R.ScanLine[j];
                                                  p0:=bm.ScanLine[j];
                                                  p1:=mean.ScanLine[j];
                                                  p2:=variant.ScanLine[j];
                                                  for i:=0 to LL-1 do
                                                   begin
                                                   mean_:=p1[i];
                                                   if (p2[i]-mean_*mean_<+0.0) then std_:=0
                                                     else  std_:=sqrt(p2[i]-mean_*mean_);
                                                   p[i]:=Max(Min(Round((p0[i]-mean_)/(std_+0.001)*128+128),255),0);
                                                   end;
                                                  end;
                                                 end else
                                                 begin
                                                 FreeAndNil(r);
                                                 end;
                                                end;


                                              user posted image
                                                Немного слишком контрастно получилось. В нижней части, где линии расходятся, черное пятно получилось. Трудно понять, как линии идут.
                                                Отпечаток похоже смазан. Или снят неудачно.
                                                  amk
                                                  Я контрастность специально поднял так линии лучше видны, а пятно это потому что я картинки перепутал и взял в качестве исходной уже корректированную. Вот так правильно.

                                                  user posted image
                                                  Сообщение отредактировано: Pavia -
                                                    Осталось придумать, как от окружающего шума избавиться.
                                                      Ох ничего себе.Pavia вам низкий поклон.
                                                      Можно я использую ваш код в своем курсовом? Только перепишу его на шарпе.
                                                      Далее поищу методы, для избавления от шумов.
                                                      1 пользователей читают эту тему (1 гостей и 0 скрытых пользователей)
                                                      0 пользователей:


                                                      Рейтинг@Mail.ru
                                                      [ Script execution time: 0.2309 ]   [ 16 queries used ]   [ Generated: 22.11.26, 21:06 GMT ]