mrgloom

хмм посмотрел что происходит в диспетчере задач, когда доходит дело до cvExtractSURF , так там резкое выделение памяти где то 1.5 гига, вообще то странно, учитывая, что потом то все освобождается (т.е. это не дескрипторы столько занимают) по F10 не удалось войти в функцию возможно потому что она в скомпиленой либе? там по ходу алгоритм такой находят много много точек, а потом по параметру HESSIAN выкидывают лишние. еще не совсем ясное дело с cvWarpPerspective получается, что возможно наложить только первое нетронутое изображение на варпнутое? т.е. я не понял можно ли выбирать какое изображение будет сверху и какое варпиться относительно какого? CvMat* homography_matrix = cvCreateMat(3, 3, CV_32FC1); cvFindHomography(points2, points1, homography_matrix, CV_RANSAC, RANSAC_ERR); // возможно переставлять points1 и points2 местами? IplImage* img_rgb1 = cvLoadImage("1.bmp"); IplImage* img_rgb2 = cvLoadImage("2.bmp"); IplImage* img_warp=cvCreateImage(cvSize(img_rgb1->width+img_rgb2->width,img_rgb1->height+img_rgb2->height),IPL_DEPTH_8U,3); cvWarpPerspective(img_rgb2,img_warp,homography_matrix,CV_WARP_FILL_OUTLIERS,cvScalarAll(0)); cvSetImageROI(img_warp,cvRect(0,0,img_rgb1->width,img_rgb1->height)); cvCopy(img_rgb1,img_warp); cvResetImageROI(img_warp); в итоге у меня удачно получилось склеить два снимка которые вы выкладывали, они правда 30-40 мб и в размере 5кх7к

хмм это может быть критично. а так результат довольно неплохой получился. нельзя ли сделать такую эрозию чтобы скажем есть объект и он по краям объедается по 1 пикселю и так чтобы по середине осталась толщина в 1 пиксель? (хотя я тут возможно не учел, что если так объедать скажем вертикальный или горизонтальный объект, то получим правильный его "скелет" просто линию, а если какой то наклонный скажем овал с бугристыми краями то мы не сможем получить "правильную" наклонную линию) а как подбирается ядро? если неизвестен изначально размер линий? возможно снять какую то статистику? и еще дополнительно как убрать маленькие элементы не затронув больших линий? (выделено на картинке)

ну так собственно говоря сам SURF и заключается в том как выделить точки и как посчитать дескрипторы. ну если винда сделает все сама на автомате то хорошо, но скорее всего об этом надо самому заботится. да точно, я ошибся. но подумайте о том, что если мы склеиваем N изображений, то у нас первое изображение растет постоянно т.е. на первом шаге 1+(1-per1) на втором 1+(1-per1)+(1-per2) на N шаге 1+(1-per1)+(1-per2)+..+(1-perN) где perN процент перекрытия изображений на N шаге.

ну тут вопрос возможно ли распараллеливание SURF (что эквивалентно ответу на вопрос можно ли делить изображение на куски) http://www.vision.ee.ethz.ch/~surf/eccv06.pdf надо как бы понять сам алгоритм. SIFT походу вообще нельзя делить т.к. там строятся пирамиды от начального изображения (хотя я может и ошибаюсь). а так то пусть 1Гб занято системой на всякую лабуду, загружаем 1 изображение ~1Гб находим точки + N мб (зависит от длины вектора дескрипторов и количества точек) удаляем 1 изображения -1Гб загружаем 2 изображение (все тоже самое) удаляем 2 изображение имеем (N1+N2)мб точек+дескрипторы. фильтруем с помощью flannFindPairs. удаляем все остальные точки, имеем Nмб точек. пихаем все добро в cvFindHomography там RANSAC'ом фильтруется. (кстати хотелось бы получить его отдельную реализацию, а то он встроен cvFindHomography , а внутренний код я не осилил и сам написать тоже не осилил) (и еще вопрос когда надо использовать матрицу гомографии, а когда фундаментальную матрицу) удаляем все точки.имеем только матрицу гомографии. загружем 2 изображения ~2Гб и делаем cvWarpPerspective (для варпа полюбому надо загружать все изображения или писать что то свое) в итоге за 4 гб вроде и не вышли. другое дело если это какие то замуты в opencv ограничение на кол-во точек и используемую суммарную память. (вроде в винде х32 приложение может использовать макс 2Гб с расширением (какой то там ключ) вроде бы 3Гб)

и да еще вопрос я так понимаю, что снимки то потом будут склеиваться? (если так то можно не по всему изображению искать, а только по предполагаемой области перекрытия) cvExtractSURF() сколько точек находит?

небось cvReleaseImage(&img); забываешь сколько памяти на компе? так же интересует вопросы: 1.Как реализовывается своп на хард если действительно не хватает памяти? (я так понимаю это надо делать сторонними методами) 2.Opencv работает многопоточно?если нет то как это реализовать?(а то у меня все выполняется на 1 ядре походу) попозже постараюсь выложить свой проект с SURF на opencv2.1

еще вопрос может есть какая то морфологическая операция чтобы убрать маленькие элементы на бинарном изображении? и при это не затронуть большие объекты? пример на увеличении(соответственно весь мусор надо убрать, полоски оставить)

изображение на котором много полосок(они практически белые, можно хорошо их выделить даже бинаризацией otsu, после бинаризации остается немного мусора в виде точек и сами полоски немного неровные), полоски под небольшим наклоном, надо определить этот наклон чтобы сделать поворот изображения. пример как на увеличении выглядит полоска, красным отмечены длины высота и ширина в середине(возможно надо брать максимальную ширину ограничивающего наклонного прямоугольника, но хз как его строить), более важна высота полоски, т.к. лучше всего выделить самую длинную полоску(для уменьшения погрешности определения угла), а ширина скорее для определения лишних объектов или горизонтальных полос. вообщем если возможно рассматривать такой объект как контур и получить такие характеристики то все норм, а так я уже смотрю в сторону блобов (а в opencv они сделаны отдельно? http://opencv.willowgarage.com/wiki/cvBlobsLib или http://code.google.com/p/cvblob/) т.е. если возможно у такого объекта определить высоту именно как на рисунке, а не как если бы мы его ограничили прямоугольником и посчитали высоту прямоугольника, то это наверно даже будет точнее чем преобразование хафа, но и медленней. вообщем все упирается в вопрос как сделать проще и быстрее либо Хафом, либо блобы, либо как то еще. ну заранее нет возможности узнать, что это за кривая, кривую ее еще надо сдетектировать на изображении, а это тоже непонятно как делать) вообщем в итоге думаю плохая это затея (или сложная).

cvErode не подходит,т.к. во первых не угадаешь число требуемых итераций ,а во вторых, т.к. он делает линии разрывными ,т.к. они имеют не одинаковую толщину по всей длине.

склеиваются прямоугольные изображения, которые имеют перекрытия, при склейке 2-х или полосок не возникает трудностей, но вот ситуацию показанную на картинке непонятно как решать.

Ну понятное дело один холст, но как я понял вы предлагаете реализовать так берем 1 клеим с помощью сифта к 2 и их в 1 картинку к этой картинке клеим 3 и т.д. и так все время у нас участвует всего по 2 картинки.так? но тут есть проблемы 1-е изображение все время растет и считать все время для него точки это вычислительно сложно, я хотел бы ограничится только краями с запасом где и происходит перекрытие, но тут может снизится точность(хотя не знаю), которая очень сильно влияет на матрицу гомографии, потом еще у самого сифта если не менять параметры то на одних изображениях найдет мало точек(невозможно или неправильно произвести склейку)(на изображениях где мало деталей), а на другом очень много(причем не там где надо и даже после)(на изображениях где много одинаковых деталей). вообщем сифт и вычислительно сложен и нестабилен. тем более не понятно решит ли это проблему Г области? или преобразования гомографии должны все сделать автоматически? вот небольшое уточнение красными жирными линиями показано направление сшивки 1-1 1-2 и 1-1 2-1, волнистая красная линия показывает то что возможно 1-2 и 2-1 совмещены неидеально, простыми линиями показано какие сифт найдет соответсвия.

известно что уже собрана область буквой Г (изображения 1-1 1-2 2-1)и требуется к ней присоединить изображение 2-2, оно перекрывается с 1-1 по диагонали, с 1-2 по вертикали, с 2-1 по горизонтали.перекрытием с изображением с 1-1 можно пренебречь, т.к. оно мало, остается 1-2 и 2-1 и мы получаем смещение от одной пары х1,у1 и от второй х2,у2.(по горизонтали получаем большое значение х1 малое у1, по вертикали наоборот x2 малое y2 большое(на картинке как размер векторов)). я пробовал компенсировать максимум смещения(выбирается максимум малых и по этому направлению производится склейка) -неплохо но не идеально так как ошибка все таки есть я пробовал усреднять х=(х1+х2)\2 у=(у1+у2)\2 - плохой результат еще пробовал сравнивать максимумы корреляции и брать те координаты где корреляция больше. - вроде как плохо(максимум как параметр видимо можно использовать только внутри изображения т.е. максимум на 1 изображении не сравним с максимумом на другом) из этой же серии можно было попробовать использовать максимумы корреляции как весовые коэффициенты для х,у , но думаю тоже не получится. т.е. мне кажется что должно быть какое то нелинейное преобразование или фигуру Г не надо считать целой. сглаживание границ это уже 2 вопрос который будет решаться потом. (кстати тут тоже сразу вопрос как смешивать в целом понятно, а возможно ли определить уровень детализации(или резкости)? т.е. в том куске где происходит перекрытие использовать не линейное сглаживание, а взять и заменить лучшим куском из 2-х) + еще видел какие то работы о выборе кривой по которой производится склейка может это надо тоже учитывать?

Есть два перекрывающихся изображения хочется сделать линейное сглаживание(linear blending) там где они перекрываются. Использую функцию cvAddWeighted но все работает очень медленно наверно потому что беру по 1 полоске толщиной в пиксель и постоянно копирую. Может можно как то оптимизировать? или использовать другие функции? int dx=mat_image[i][j+1].x-mat_image[i][j].x; int dy=mat_image[i][j+1].y-mat_image[i][j].y; int wc=mat_image[i][j].src->width-abs(dx); //ширина области перекрытия int hc=mat_image[i][j+1].src->height-abs(dy); //высота области перекрытия double L=0.5*(wc); for (int k=0;k<L+1;k++) { // левый шов на 2 изображении //mat_image[i][j].src и mat_image[i][j+1].src соседние изображения cvSetImageROI(mat_image[i][j].src,cvRect(MIN(dx+wc/2+k,mat_image[i][j].src->width-1),MAX(0,dy),1,hc)); cvSetImageROI(mat_image[i][j+1].src,cvRect(MIN(wc/2+k,mat_image[i][j].src->width-1),abs(MIN(0,dy)),1,hc)); double beta = 0.5*(1+k/L); double alpha = 1-beta; IplImage* dst = cvCloneImage(mat_image[i][j+1].src); cvAddWeighted(mat_image[i][j].src, alpha, mat_image[i][j+1].src, beta, 0.0, dst); cvCopy(dst, mat_image[i][j+1].src); cvResetImageROI(mat_image[i][j+1].src); cvResetImageROI(mat_image[i][j].src); cvReleaseImage(&dst); // освобождение памяти if (k!=0) { //правый шов на 1 изображении cvSetImageROI(mat_image[i][j].src,cvRect(MAX(0,dx+wc/2-k),MAX(0,dy),1,hc)); cvSetImageROI(mat_image[i][j+1].src,cvRect(MAX(0,wc/2-k),abs(MIN(0,dy)),1,hc)); dst = cvCloneImage(mat_image[i][j+1].src); cvAddWeighted(mat_image[i][j+1].src, alpha, mat_image[i][j].src, beta, 0.0, dst); cvCopy(dst, mat_image[i][j+1].src); cvResetImageROI(mat_image[i][j+1].src); cvResetImageROI(mat_image[i][j].src); cvReleaseImage(&dst); } }

я все таки не очень понял поможет это или нет. cvMatchTemplate не особо удобна т.к. требуется расширять нулями первое(что требует доп памяти) или уменьшать второе(что может снизить точность) , и непонятно будет ли реализация с FFTW работать быстрее. 2 изображения которые перекрываются. выделяем область перекрытия с запасом на 1 изображении, и берем небольшой кусок на втором. (в целом работает но бывают ошибки) в каком то алгоритме видел параметр сколько пиков найти, но что это за пики непонятно, может второй кусок бьется на полоски и определяется их пики? а потом проверяется правильно ли они найдены?

Просто тут даже вопрос об общем алгоритме и управлением памятью. Необходимо выделить область на 1 изображении и скопировать и на 2 и скопировать. разделить все на полоски толщиной 1 пиксель, попихать все это в 2 массива полосок, выполнить преобразование скопировать в 3 массив, соединить в область(или по одной) и скопировать в результирующее изображение.

хмм вроде бы ответ http://tech.dir.groups.yahoo.com/group/OpenCV/message/5681 сначала дилатация, а потом найти пики, видимо все равно придется писать руками или резать на полоски и потом cvmaxmin. хотя не понятно как выбрать нужный уровень дилатации.

как сделать так чтобы искать не 1 пик, а смотреть чтобы совместились главный пик+ еще несколько локальных пиков? это должно повысить точность.

Когда я провожу бинаризацию изображения, то бывает (в зависимости от выбранного порога и самого изображения) получаю либо разделение 1 целевого объекта на части , либо склеенные 2 и более целевых объектов. Хотелось бы узнать какая задача проще соединить части 1 объекта или разделить 2 и более объектов, а так же методы решения.

Интересует еще как у local thresholding выбирать размер маски(исходя из чего? размер объектов, сцена?) и форма маски.Может каким то специальным образом обходить объекты. используя еще какие то дополнительные критерии.

Возник вопрос в свете истерии насчет CUDA и т.д. Что лучше использовать для Image Processing? требования быстрота(всмысле вычислительная мощность) и распространенность (т.е. мало ошибок,много готовых алгоритмов, хорошая документация, большое комьюнити). Варианты на которые я наткнулся. 1.OpenCV (не знаю поддерживает ли SSE и т.д.?) (опять же вопрос распаралеллены ли встроенные алгоритмы? или надо самому? через внутренние средства или OpenMP?) (как ваять Гуи?) (вроде как большое комьюнити) 2.Matlab (слабые малофункциональные гуи(хотя может и не прав),медленно(тоже может не прав, ибо можно С файлы подключать), зато все есть в тулбоксах(для статистики и нейросетей и т.д.), для простых задач есть примеры) (легче писать чем на С++) причем скорее всего можно .ехе или .dll собрать и использовать из главной программы (не проверял). (в новых версиях обещали CUDA, но для этого надо писать отдельные .mex файлы) 3.CUDA и OpenCL обещают большую производительность, но есть существенные ограничения на алгоритмы(вот тут то и вопрос удастся ли переложить все требуемые алгоритмы и (или) совместить частичную обработку на gpu и частично на cpu, при том гоняя все это через память и не погрязнув в сложной структуре кода) вроде есть GPUCV. а так хотелось бы услышать мнение тех кто пользовался и какие подводные камни по всем 3 пунктам. 4.Прочие библиотеки для С#, python и т.д.(не суть, но может больше готового кода, легче разработка и т.д.)

так то я склоняюсь к матлабу ибо для меня легче там программировать.Ну вот главная проблема в том что у меня radeon 4850 на данный момент и соответственно можно использовать только лишь OpenCL. Про работу матлаба с карточками пишут только про тесла и квадро, а купить я смогу только лишь gtx 460. но привлекает что в коде почти ничего менять не нужно(если есть готовые аналоги процедур для gpu) лишь 1 дополнительная инструкция для копирования переменных в память видеокарты.

Ну я методом local thresholding получаю неплохие результаты, но не идеальные, притом что для конкретной картинки приходится подбирать параметры, для другой же картинки из этой же серии уже нужны несколько другие параметры. т.е. хотелось бы использовать метод который выполняется максимально автоматически или который дает максимально хороший результат, вычислительная сложность не важна. а контуры как искали? edge detection? разве нахождение контуров не тоже самое что найти объект? ведь достаточно залить этот контур, если он замнкнутый.

Задача бинаризации как то сильно пересекается с задачей сегментации и выделением контуров, т.е. не очень понятно где что кончается и где начинается. Нашел adaptive local thresholding http://pacific.mpi-cbg.de/wiki/index.php/Auto_Local_Threshold , но тут стоит вопрос как выбирать размер окрестности точки? может существуют какие то более совершенные методы? (более автоматические, возможно, что то связанное с градиентом?) Отцу все таки Global threshold и от этого дает хуже результат, а водораздел вроде как для другого используется, хотя я может ошибаюсь(и все равно там параметры надо подбирать или задавать начальные точки, то же самое что region growing)

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

Собственно говоря фильтр винера у меня уже реализован на С#(без OpenCV) и в матлабе он есть.(там же генерю шумы), и теорию я по нему читал, правда несколько напрягает, что вся теория в частотной области, а реализация в пространсвенной.(вроде даже читал что выигрыш по скорости у пространсвенных (кроме то ли малых изображений, то ли малых масок) потому как фурье преобразование туда сюда гонять надо и это ресурсоемко) но работает он как то неудовлетворительно, как я понимаю сильная привязка к уровню шума, который определяется как средняя дисперсия по всему изображению(и соответсвенно очень неточно).Правда тут есть идея его модифицировать, для оценки параметров шума из зашумленного изображения вычитаем фильтрованное, в итоге получаем примерное распределение шума что то типа как на картинке. начальное с шумом разница выделенные области так вот задача стоит в том чтобы убрать из рассмотрения эти черные области которые портят статистику, а с помощью чего это сделать я не знаю. Смотрел еще какие то принты последних лет на английском, там идет сравнение 5 алгоритмов 2009-2010 годов но теорию не осилил, да еще и на английском. (попозже может скину если найду)