Арифмерика, логика и сравнение

Материал из CompVision

LUT

Преобразует матрицу по таблице соответствия (look up table)

(Look Up Table – это такая таблица которая служит для перевода некоторой последовательности чисел в другую последовательность например : элементы массива с индексами 0,1,2,3,4,5,6 содержат значения 12,0,5,7,2,8,10 – в таком случае число 2, обработаное такой таблицей станет числом 5, а число 4 - числом 2) .

void cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );

src - исходная матрица (8 - битный массив)

dst - выходная матрица произвольной битовой глубины, с тем же количеством каналов, что и у исходной матрицы. lut - таблица соответствия из 256 элементов, должна иметь такую же битовую глубину что и выходная матрица. В случае много канальных входной и выходной матриц, lut может также быть одноканальной, в таком случае ко всем каналам применяется одна и та же таблица. Функция cvLUT заполняет выходную матрицу значениями из lut. Индексы элементов lut для соответствующей координаты выходной матрицы берутся из тех же координат входной матрицы. Функция обрабатывает каждый элемент матрицы как показано ниже:

dst(I)=lut[src(I)+DELTA]

где DELTA = 0 если src имеет тип CV_8U, и DELTA = 128 если src имеет тип CV_8S.

ConvertScale

Преобразует одну матрицу в другую, с (необязательным) линейным преобразованием.

void cvConvertScale( const CvArr* src, CvArr* dst, double scale=1, double shift=0 );
#define cvCvtScale cvConvertScale
#define cvScale cvConvertScale
#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )

src - исходная матрица

dst - выходая матрица

scale - масштабный фактор (на это значение умножается каждый элемент)

shift - смещение (это значение добавляется к каждому элементу) Функция cvConvertScale имеет несколько различных приложений, поэтому имеет несколько функций-синонимов (см. #define). Функция копирует одну матрицу в другую, предварительно применив линейное преобразование, после линейного преобразования, если это необходимо функция осуществляет преобразование типов элементов матрицы.

dst(I)=src(I)*scale + (shift,shift,...)

Все каналы многоканальных матриц обрабатываются независимо.

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

В случае scale = 1, shift = 0 линейного преобразования не производится, в таком случае функция просто преобразует тип элементов одной матрицы в другую. Для этого применяется синоним функции cvConvertScale - cvConvert. Если преобразования типов не требуется, рекомендуется применять синоним cvScale.

ConvertScaleAbs

Преобразует элементы входной матрицы в 8-битный целый тип, с (необязательным) линейным преобразованием

void cvConvertScaleAbs( const CvArr* src, CvArr* dst, double scale=1, double shift=0 );
#define cvCvtScaleAbs cvConvertScaleAbs

src - входная матрица

dst - выходная матрица (элементы матрицы должны иметь тип CV_8U)

scale - масштабный фактор (на это значение умножается каждый элемент)

shift - смещение (это значение добавляется к каждому элементу). Функция cvConvertScaleAbs похожа на cvConvertScale но сохраняет абсолютные значения результатов преобразования: dst(I)=abs(src(I)*scale + (shift,shift,...))

Функция поддерживает только выходные матрицы типа CV_8U, для остальных типов, функция может быть эмулирована использованием комбинации функций cvConvertScale и cvAbs.

Add

Поэлементно суммирует две матрицы (возможно суммирование по маске)

void cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL );

src1 - первое слагаемое (матрица)

src2 - второе слагаемое (матрица)

dst - результат

mask - маска, суммируются только те элементы входных матриц, для которых в соответствующей им ячейке маски содержится ненулевое значение. Тип элементов маски 8-битное целое, количество каналов маски 1. Функция складывает матрицы поэлементно как показано ниже:

dst(I)=src1(I)+src2(I) if mask(I)!=0

src1, src2, dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

AddS

Прибавляет заданное число ко всем элементам матрицы (возможно суммирование по маске)

void cvAddS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL );

src - исходная матрица

value - прибавляемое число

dst - результирующая матрица

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.Функция складывает число с элементами матрицы как показано ниже: dst(I)=src(I)+value if mask(I)!=0

src1 и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

AddWeighted

Находит взвешенную сумму двух матриц

void cvAddWeighted( const CvArr* src1, double alpha, const CvArr* src2, double beta, double gamma, CvArr* dst );

src1 - первая исходная матрица

alpha - вес первой матрицы (число, на которое поэлементно домножается первая матрица перед поэлементным сложением)

src2 - вторая исходная матрица

beta - вес второй матрицы (число, на которое поэлементно домножается вторая матрица перед поэлементным сложением) gamma - смещение результата, число которое добавляется к результату сложения:

dst(I)=src1(I)*alpha+src2(I)*beta+gamma

src1, src2, dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

Sub

Поэлементно вычитает из одной матрицы другую(возможно вычитание по маске)

void cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL );

src1 - матрица из которой вычитаем

src2 - матрица которую вычитаем

dst - результат

mask - маска, вычисляется разность только тех элементов входных матриц, для которых в соответствующей им ячейке маски содержится ненулевое значение. Тип элементов маски 8-битное целое, количество каналов маски 1. Функция находит поэлементную разность матриц поэлементно как показано ниже:

dst(I)=src1(I)-src2(I) if mask(I)!=0

src1, src2, dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

SubS

Вычитает заданное число из всех элементов матрицы (возможно вычитание по маске)

void cvSubS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL );

src - исходная матрица

value - вычитаемое число

dst - результирующая матрица

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.Функция вычитает число из элементов матрицы как показано ниже:

dst(I)=src(I)-value if mask(I)!=0

src1 и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

(прим.: не пойму зачем эта функция, если есть AddS ?)

SubRS

Вычисляет разность между числом и матрицей (почувствуйте разницу с SubS)

void cvSubRS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL );

src - вычитаемая матрица

value - число из которого поэлементно вычитаем матрицу

dst - результирующая матрица

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.Функция вычитает элементы матрицы из числа как показано ниже:

dst(I)=value-src(I) if mask(I)!=0

src1 и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

Mul

Вычисляет поэлементное произведение двух матриц

void cvMul( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1 );

src1 - перевый множитель

src2 - второй множитель

dst - результат

scale - масштабный фактор Функция вычисляет поэлементное произведение двух матриц с домножением результата на число scale:

dst(I)=scale•src1(I)•src2(I)

src1, src2, dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

Div

Вычисляет поэлементное частное двух матриц

void cvDiv( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1 );

src1 - делимое

src2 - делитель

dst - результат

scale - масштабный фактор

Функция вычисляет поэлементное произведение двух матриц с домножением результата на число scale. Если делимое NULL то в результат будет помещено частное от деления scale на src2:

dst(I)=scale•src1(I)/src2(I), if src1!=NULL
dst(I)=scale/src2(I), if src1=NULL

src1, src2, dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

And

Вычисляет поэлементное побитовое И (конъюнкцию) двух матриц (возможна конъюнкция по маске)

void cvAnd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL );

src1 - первый операнд

src2 - второй операнд

dst - результат

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1. Функция cvAnd - вычисляет поэлементное побитовое И (конъюнкцию) двух матриц:

dst(I)=src1(I)&src2(I) if mask(I)!=0

В случае с действительным типом (как и в других случаях) элементов матрицы, операция проводится над битовым представлением элемента. src1, src2, dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

AndS

Вычисляет поэлементное побитовое И (конъюнкцию) элементов матрицы и числа (возможна конъюнкция по маске)

void cvAndS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL );

src - первый операнд (матрица)

value - число, с которым будет производиться логическое побитовое И всех элементов матрицы (с учетом маски, конечно)

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.

dst - результат Функция cvAndS - вычисляет поэлементное побитовое И (конъюнкцию) элементов матрицы и числа:

dst(I)=src(I)&value if mask(I)!=0

Перед выполнением операции число приводится к тому же типу, который имеют элементы матрицы.

В случае с действительным типом (как и в других случаях) элементов матрицы, операция проводится над битовым представлением элемента. src и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)). Пример, приведенный ниже показывает процедуру вычисления абсолютного значения матрицы с элементами типа плавающая точка, путем сброса в ноль старшего (знакового) бита:

float a[] = { -1, 2, -3, 4, -5, 6, -7, 8, -9 };
CvMat A = cvMat( 3, 3, CV_32F, &a );
int i, abs_mask = 0x7fffffff;
cvAndS( &A, cvRealScalar(*(float*)&abs_mask), &A, 0 );
for( i = 0; i < 9; i++ )
printf("%.1f ", a[i] );

На экране должно быть выведено: 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

Or

Вычисляет поэлементное побитовое ИЛИ (дизъюнкцию) двух матриц (возможна дизъюнкция по маске)

void cvOr( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL );

src1 - первый операнд

src2 - второй операнд

dst - результат

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.

В случае с действительным типом (как и в других случаях) элементов матрицы, операция проводится над битовым представлением элемента.

Функция cvOr - вычисляет поэлементное побитовое ИЛИ (дизъюнкцию) двух матриц

dst(I)=src1(I)|src2(I)

OrS

Вычисляет поэлементное побитовое И (дизъюнкцию) элементов матрицы и числа (возможна дизъюнкция по маске)

void cvOrS( const CvArr* src, const CvScalar value, CvArr* dst, const CvArr* mask=NULL );

src - первый операнд (матрица)

value - число, с которым будет производиться логическое побитовое ИЛИ всех элементов матрицы (с учетом маски, конечно)

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.

dst - результат

Функция cvOrS - вычисляет поэлементное побитовое ИЛИ (дизъюнкцию) элементов матрицы и числа:

dst(I)=src(I)|value if mask(I)!=0

Перед выполнением операции число приводится к тому же типу, который имеют элементы матрицы.

В случае с действительным типом (как и в других случаях) элементов матрицы, операция проводится над битовым представлением элемента.

src и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

Xor

Вычисляет поэлементное побитовое ИСКЛЮЧИТЕЛЬНОЕ ИЛИ двух матриц (возможна XOR по маске)

void cvXor( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL );

src1 - первый операнд

src2 - второй операнд

dst - результат

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.

Функция cvXor вычисляет поэлементное побитовое ИСКЛЮЧИТЕЛЬНОЕ ИЛИ двух матриц:

dst(I)=src1(I)^src2(I) if mask(I)!=0

В случае с действительным типом (как и в других случаях) элементов матрицы, операция проводится над битовым представлением элемента.

XorS

Вычисляет поэлементное побитовое ИСКЛЮЧИТЕЛЬНОЕ ИЛИ матрицы и числа (возможна XOR по маске)

void cvXorS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL );

src - первый операнд (матрица)

value - число, с которым будет производиться логическое побитовое ИСКЛЮЧИТЕЛЬНОЕ ИЛИ всех элементов матрицы (с учетом маски, конечно)

mask - маска, изменяются только те элементы входных матрицы, для которых в соответствующей ячейке маски содержится ненулевое значение. Тип элементов маски: 8-битное целое, количество каналов маски 1.

dst - результат

Функция cvXorS - вычисляет поэлементное побитовое ИСКЛЮЧИТЕЛЬНОЕ ИЛИ (дизъюнкцию) элементов матрицы и числа:

dst(I)=src(I)^value if mask(I)!=0

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

src и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)). Пример демонстрирует вычисление комплексных чисел, сопряженных данным:

float a[] = { 1, 0, 0, 1, -1, 0, 0, -1 }; /* 1, j, -1, -j */
CvMat A = cvMat( 4, 1, CV_32FC2, &a );
int i, neg_mask = 0x80000000;
cvXorS( &A, cvScalar( 0, *(float*)&neg_mask, 0, 0 ), &A, 0 );
for( i = 0; i < 4; i++ )
printf("(%.1f, %.1f) ", a[i*2], a[i*2+1] );

Результатом будет вывод на экран: (1.0,0.0) (0.0,-1.0) (-1.0,0.0) (0.0,1.0)

Not

Логическое отрицание (инверсия)

void cvNot( const CvArr* src, CvArr* dst );

src - операнд (матрица)

dst - результат

Функция cvNot инвертирует каждый бит исходной матрицы:

dst(I)=~src(I)

src и dst - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

Cmp

Поэлементное сравнение двух матриц

void cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );

src1 - первый операнд

src2 - второй операнд

dst - результат

Обе входных матрицы должны быть одноканальными. Выходная матрица должна быть одноканальной и иметь тип CV_8U or CV_8S.

cmp_op - флаг, определяющий какая операция сравнения будет проводиться:

   * CV_CMP_EQ - src1(I) "равно" src2(I)
   * CV_CMP_GT - src1(I) "больше чем" src2(I)
   * CV_CMP_GE - src1(I) "больше или равно" src2(I)
   * CV_CMP_LT - src1(I) "меньше чем" src2(I)
   * CV_CMP_LE - src1(I) "меньше или равно" src2(I)
   * CV_CMP_NE - src1(I) "не равно" src2(I)

Функция cvCmp производит поэлементное сравнение двух матриц: dst(I)=src1(I) op src2(I), где 'op' это: '=', '>', '>=', '<', '<=' или '!='.

Если условие выполняется, то значение соответствующего элемента результирующей матрицы будет равно 255 (FF) src1 и src2 - должны иметь один и тот же тип элементов, и один и тот же размер (или ROI (область интереса)).

CmpS

Поэлементное сравнение матрицы с числом

void cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );

src - первый операнд (матрица)

value - число, с которым будет производиться сравнение

dst - результат

Входная матрица должна быть одноканальной. Выходная матрица должна быть одноканальной и иметь тип CV_8U or CV_8S. cmp_op - флаг, определяющий какая операция сравнения будет проводиться:

  * CV_CMP_EQ - src1(I) "равно" src2(I)
  * CV_CMP_GT - src1(I) "больше чем" src2(I)
  * CV_CMP_GE - src1(I) "больше или равно" src2(I)
  * CV_CMP_LT - src1(I) "меньше чем" src2(I)
  * CV_CMP_LE - src1(I) "меньше или равно" src2(I)
  * CV_CMP_NE - src1(I) "не равно" src2(I)

Функция cvCmpS поэлементное сравнение матрицы с числом:

dst(I)=src(I) op scalar, где 'op' это: '=', '>', '>=', '<', '<=' или '!='.

Если условие выполняется, то значение соответствующего элемента результирующей матрицы будет равно 255 (FF)

InRange

Проверяет, лежит ли значение элемента входной матрицы в диапазоне,максимум и минимум которого задается элементами двух других матриц, имеющих те же координаты, что и проверяемый элемент.

void cvInRange( const CvArr* src, const CvArr* lower, const CvArr* upper, CvArr* dst );

src - проверяемая матрица.

lower - матрица, элементы которой задают нижнюю границу допустимого диапазона.

upper - матрица, элементы которой задают верхнюю границу диапазона.

dst - результат (тип элемента должен быть CV_8U или CV_8S)

dst(I)=( (lower(I)<= src(I)) && (src(I)< upper(I)) )*255;

Проверка проводится для каждого пикселя, причем для каждого пикселя имеется свой собственный интервал.

Если проверка проходит, в соответствующей позиции результирующей матрицы устанавливается значение 255.

InRangeS

Проверяет лежат ли элементы матрицы в интервале, заданном двумя значениями.

void cvInRangeS( const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst );

src - проверяемая матрица.

lower - значение нижней границы допустимого диапазона.

upper - значение верхней границы допустимого диапазона.

dst - результат (тип элемента должен быть CV_8U или CV_8S)

dst(I)=( (lower > src(I)) && (src(I)< upper ) )*255;

Проверка проводится для каждого пикселя, интервал для всех элементов один и тот же.

Если проверка проходит, в соответствующей позиции результирующей матрицы устанавливается значение 255.

Max

Находит максимальные элементы из двух матриц. Функция сравнивает поэлементно две матрицы, и помещает в соответствующую позицию результирующей матрицы, максимальный из двух сравниваемых элементов с теми же координатами.

void cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );

src1 - первая входная матрица

src2 - вторая входная матрица

dst - результирующая матрица

dst(I)=max(src1(I), src2(I));

Все матрицы должны быть одноканальными, иметь одинаковый размер и тип элементов.

MaxS

Находит максимальные элементы из матрицы и числа. Функция сравнивает поэлементно матрицу и число, и помещает в соответствующую позицию результирующей матрицы, максимальный из двух сравниваемых элементов с теми же координатами.

void cvMaxS( const CvArr* src, double value, CvArr* dst );

src - входная матрица

value - число с которым сравниваются элементы матрицы

dst - результирующая матрица

dst(I)=max(src(I), value);

Все матрицы должны быть одноканальными, иметь одинаковый размер и тип элементов.

Min

Находит минимальные элементы из двух матриц. Функция сравнивает поэлементно две матрицы, и помещает в соответствующую позицию результирующей матрицы, минимальный из двух сравниваемых элементов с теми же координатами.

void cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );

src1 - первая входная матрица

src2 - вторая входная матрица

dst - результирующая матрица

dst(I)=min(src1(I), src2(I));

Все матрицы должны быть одноканальными, иметь одинаковый размер и тип элементов.

MinS

Находит минимальные элементы из матрицы и числа. Функция сравнивает поэлементно матрицу и число, и помещает в соответствующую позицию результирующей матрицы, минимальный из двух сравниваемых элементов с теми же координатами.

void cvMinS( const CvArr* src, double value, CvArr* dst );

src - входная матрица

value - число с которым сравниваются элементы матрицы

dst - результирующая матрица

dst(I)=min(src(I), value);

Все матрицы должны быть одноканальными, иметь одинаковый размер и тип элементов.

AbsDiff

Находит поэлементное абсолютное значение разности двух матриц.

void cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );

src1 - первая входная матрица

src2 - вторая входная матрица

dst - результирующая матрица

dst(I)= abs(src1(I) - src2(I)).

Все матрицы должны быть одноканальными, иметь одинаковый размер и тип элементов.

AbsDiffS

Находит поэлементное абсолютное значение разности матрицы и числа.

void cvAbsDiffS( const CvArr* src, double value, CvArr* dst );

src - входная матрица

value - число

dst - результирующая матрица

dst(I)= abs(src1(I) - value).

Все матрицы должны быть одноканальными, иметь одинаковый размер и тип элементов.