initialization time.
}
}
-static BinaryFunc maxTab[] =
+static BinaryFunc* getMaxTab()
{
- (BinaryFunc)GET_OPTIMIZED(max8u), (BinaryFunc)GET_OPTIMIZED(max8s),
- (BinaryFunc)GET_OPTIMIZED(max16u), (BinaryFunc)GET_OPTIMIZED(max16s),
- (BinaryFunc)GET_OPTIMIZED(max32s),
- (BinaryFunc)GET_OPTIMIZED(max32f), (BinaryFunc)max64f,
- 0
-};
+ static BinaryFunc maxTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(max8u), (BinaryFunc)GET_OPTIMIZED(max8s),
+ (BinaryFunc)GET_OPTIMIZED(max16u), (BinaryFunc)GET_OPTIMIZED(max16s),
+ (BinaryFunc)GET_OPTIMIZED(max32s),
+ (BinaryFunc)GET_OPTIMIZED(max32f), (BinaryFunc)max64f,
+ 0
+ };
+
+ return maxTab;
+}
-static BinaryFunc minTab[] =
+static BinaryFunc* getMinTab()
{
- (BinaryFunc)GET_OPTIMIZED(min8u), (BinaryFunc)GET_OPTIMIZED(min8s),
- (BinaryFunc)GET_OPTIMIZED(min16u), (BinaryFunc)GET_OPTIMIZED(min16s),
- (BinaryFunc)GET_OPTIMIZED(min32s),
- (BinaryFunc)GET_OPTIMIZED(min32f), (BinaryFunc)min64f,
- 0
-};
+ static BinaryFunc minTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(min8u), (BinaryFunc)GET_OPTIMIZED(min8s),
+ (BinaryFunc)GET_OPTIMIZED(min16u), (BinaryFunc)GET_OPTIMIZED(min16s),
+ (BinaryFunc)GET_OPTIMIZED(min32s),
+ (BinaryFunc)GET_OPTIMIZED(min32f), (BinaryFunc)min64f,
+ 0
+ };
+
+ return minTab;
+}
}
void cv::max( InputArray src1, InputArray src2, OutputArray dst )
{
- binary_op(src1, src2, dst, noArray(), maxTab, false );
+ binary_op(src1, src2, dst, noArray(), getMaxTab(), false );
}
void cv::min( InputArray src1, InputArray src2, OutputArray dst )
{
- binary_op(src1, src2, dst, noArray(), minTab, false );
+ binary_op(src1, src2, dst, noArray(), getMinTab(), false );
}
void cv::max(const Mat& src1, const Mat& src2, Mat& dst)
{
OutputArray _dst(dst);
- binary_op(src1, src2, _dst, noArray(), maxTab, false );
+ binary_op(src1, src2, _dst, noArray(), getMaxTab(), false );
}
void cv::min(const Mat& src1, const Mat& src2, Mat& dst)
{
OutputArray _dst(dst);
- binary_op(src1, src2, _dst, noArray(), minTab, false );
+ binary_op(src1, src2, _dst, noArray(), getMinTab(), false );
}
void cv::max(const Mat& src1, double src2, Mat& dst)
{
OutputArray _dst(dst);
- binary_op(src1, src2, _dst, noArray(), maxTab, false );
+ binary_op(src1, src2, _dst, noArray(), getMaxTab(), false );
}
void cv::min(const Mat& src1, double src2, Mat& dst)
{
OutputArray _dst(dst);
- binary_op(src1, src2, _dst, noArray(), minTab, false );
+ binary_op(src1, src2, _dst, noArray(), getMinTab(), false );
}
/****************************************************************************************\
}
}
-static BinaryFunc addTab[] =
+static BinaryFunc* getAddTab()
{
- (BinaryFunc)GET_OPTIMIZED(add8u), (BinaryFunc)GET_OPTIMIZED(add8s),
- (BinaryFunc)GET_OPTIMIZED(add16u), (BinaryFunc)GET_OPTIMIZED(add16s),
- (BinaryFunc)GET_OPTIMIZED(add32s),
- (BinaryFunc)GET_OPTIMIZED(add32f), (BinaryFunc)add64f,
- 0
-};
+ static BinaryFunc addTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(add8u), (BinaryFunc)GET_OPTIMIZED(add8s),
+ (BinaryFunc)GET_OPTIMIZED(add16u), (BinaryFunc)GET_OPTIMIZED(add16s),
+ (BinaryFunc)GET_OPTIMIZED(add32s),
+ (BinaryFunc)GET_OPTIMIZED(add32f), (BinaryFunc)add64f,
+ 0
+ };
-static BinaryFunc subTab[] =
+ return addTab;
+}
+
+static BinaryFunc* getSubTab()
{
- (BinaryFunc)GET_OPTIMIZED(sub8u), (BinaryFunc)GET_OPTIMIZED(sub8s),
- (BinaryFunc)GET_OPTIMIZED(sub16u), (BinaryFunc)GET_OPTIMIZED(sub16s),
- (BinaryFunc)GET_OPTIMIZED(sub32s),
- (BinaryFunc)GET_OPTIMIZED(sub32f), (BinaryFunc)sub64f,
- 0
-};
+ static BinaryFunc subTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(sub8u), (BinaryFunc)GET_OPTIMIZED(sub8s),
+ (BinaryFunc)GET_OPTIMIZED(sub16u), (BinaryFunc)GET_OPTIMIZED(sub16s),
+ (BinaryFunc)GET_OPTIMIZED(sub32s),
+ (BinaryFunc)GET_OPTIMIZED(sub32f), (BinaryFunc)sub64f,
+ 0
+ };
+
+ return subTab;
+}
-static BinaryFunc absdiffTab[] =
+static BinaryFunc* getAbsDiffTab()
{
- (BinaryFunc)GET_OPTIMIZED(absdiff8u), (BinaryFunc)GET_OPTIMIZED(absdiff8s),
- (BinaryFunc)GET_OPTIMIZED(absdiff16u), (BinaryFunc)GET_OPTIMIZED(absdiff16s),
- (BinaryFunc)GET_OPTIMIZED(absdiff32s),
- (BinaryFunc)GET_OPTIMIZED(absdiff32f), (BinaryFunc)absdiff64f,
- 0
-};
+ static BinaryFunc absDiffTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(absdiff8u), (BinaryFunc)GET_OPTIMIZED(absdiff8s),
+ (BinaryFunc)GET_OPTIMIZED(absdiff16u), (BinaryFunc)GET_OPTIMIZED(absdiff16s),
+ (BinaryFunc)GET_OPTIMIZED(absdiff32s),
+ (BinaryFunc)GET_OPTIMIZED(absdiff32f), (BinaryFunc)absdiff64f,
+ 0
+ };
+
+ return absDiffTab;
+}
}
void cv::add( InputArray src1, InputArray src2, OutputArray dst,
InputArray mask, int dtype )
{
- arithm_op(src1, src2, dst, mask, dtype, addTab );
+ arithm_op(src1, src2, dst, mask, dtype, getAddTab() );
}
void cv::subtract( InputArray src1, InputArray src2, OutputArray dst,
}
}
#endif
- arithm_op(src1, src2, dst, mask, dtype, subTab );
+ arithm_op(src1, src2, dst, mask, dtype, getSubTab() );
}
void cv::absdiff( InputArray src1, InputArray src2, OutputArray dst )
{
- arithm_op(src1, src2, dst, noArray(), -1, absdiffTab);
+ arithm_op(src1, src2, dst, noArray(), -1, getAbsDiffTab());
}
/****************************************************************************************\
}
-static BinaryFunc mulTab[] =
+static BinaryFunc* getMulTab()
{
- (BinaryFunc)mul8u, (BinaryFunc)mul8s, (BinaryFunc)mul16u,
- (BinaryFunc)mul16s, (BinaryFunc)mul32s, (BinaryFunc)mul32f,
- (BinaryFunc)mul64f, 0
-};
+ static BinaryFunc mulTab[] =
+ {
+ (BinaryFunc)mul8u, (BinaryFunc)mul8s, (BinaryFunc)mul16u,
+ (BinaryFunc)mul16s, (BinaryFunc)mul32s, (BinaryFunc)mul32f,
+ (BinaryFunc)mul64f, 0
+ };
+
+ return mulTab;
+}
-static BinaryFunc divTab[] =
+static BinaryFunc* getDivTab()
{
- (BinaryFunc)div8u, (BinaryFunc)div8s, (BinaryFunc)div16u,
- (BinaryFunc)div16s, (BinaryFunc)div32s, (BinaryFunc)div32f,
- (BinaryFunc)div64f, 0
-};
+ static BinaryFunc divTab[] =
+ {
+ (BinaryFunc)div8u, (BinaryFunc)div8s, (BinaryFunc)div16u,
+ (BinaryFunc)div16s, (BinaryFunc)div32s, (BinaryFunc)div32f,
+ (BinaryFunc)div64f, 0
+ };
-static BinaryFunc recipTab[] =
+ return divTab;
+}
+
+static BinaryFunc* getRecipTab()
{
- (BinaryFunc)recip8u, (BinaryFunc)recip8s, (BinaryFunc)recip16u,
- (BinaryFunc)recip16s, (BinaryFunc)recip32s, (BinaryFunc)recip32f,
- (BinaryFunc)recip64f, 0
-};
+ static BinaryFunc recipTab[] =
+ {
+ (BinaryFunc)recip8u, (BinaryFunc)recip8s, (BinaryFunc)recip16u,
+ (BinaryFunc)recip16s, (BinaryFunc)recip32s, (BinaryFunc)recip32f,
+ (BinaryFunc)recip64f, 0
+ };
+ return recipTab;
+}
}
void cv::multiply(InputArray src1, InputArray src2,
OutputArray dst, double scale, int dtype)
{
- arithm_op(src1, src2, dst, noArray(), dtype, mulTab, true, &scale);
+ arithm_op(src1, src2, dst, noArray(), dtype, getMulTab(), true, &scale);
}
void cv::divide(InputArray src1, InputArray src2,
OutputArray dst, double scale, int dtype)
{
- arithm_op(src1, src2, dst, noArray(), dtype, divTab, true, &scale);
+ arithm_op(src1, src2, dst, noArray(), dtype, getDivTab(), true, &scale);
}
void cv::divide(double scale, InputArray src2,
OutputArray dst, int dtype)
{
- arithm_op(src2, src2, dst, noArray(), dtype, recipTab, true, &scale);
+ arithm_op(src2, src2, dst, noArray(), dtype, getRecipTab(), true, &scale);
}
/****************************************************************************************\
addWeighted_<double, double>(src1, step1, src2, step2, dst, step, sz, scalars);
}
-static BinaryFunc addWeightedTab[] =
+static BinaryFunc* getAddWeightedTab()
{
- (BinaryFunc)GET_OPTIMIZED(addWeighted8u), (BinaryFunc)GET_OPTIMIZED(addWeighted8s), (BinaryFunc)GET_OPTIMIZED(addWeighted16u),
- (BinaryFunc)GET_OPTIMIZED(addWeighted16s), (BinaryFunc)GET_OPTIMIZED(addWeighted32s), (BinaryFunc)addWeighted32f,
- (BinaryFunc)addWeighted64f, 0
-};
+ static BinaryFunc addWeightedTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(addWeighted8u), (BinaryFunc)GET_OPTIMIZED(addWeighted8s), (BinaryFunc)GET_OPTIMIZED(addWeighted16u),
+ (BinaryFunc)GET_OPTIMIZED(addWeighted16s), (BinaryFunc)GET_OPTIMIZED(addWeighted32s), (BinaryFunc)addWeighted32f,
+ (BinaryFunc)addWeighted64f, 0
+ };
+
+ return addWeightedTab;
+}
}
double beta, double gamma, OutputArray dst, int dtype )
{
double scalars[] = {alpha, beta, gamma};
- arithm_op(src1, src2, dst, noArray(), dtype, addWeightedTab, true, scalars);
+ arithm_op(src1, src2, dst, noArray(), dtype, getAddWeightedTab(), true, scalars);
}
cmp_(src1, step1, src2, step2, dst, step, size, *(int*)_cmpop);
}
-static BinaryFunc cmpTab[] =
+static BinaryFunc getCmpFunc(int depth)
{
- (BinaryFunc)GET_OPTIMIZED(cmp8u), (BinaryFunc)GET_OPTIMIZED(cmp8s),
- (BinaryFunc)GET_OPTIMIZED(cmp16u), (BinaryFunc)GET_OPTIMIZED(cmp16s),
- (BinaryFunc)GET_OPTIMIZED(cmp32s),
- (BinaryFunc)GET_OPTIMIZED(cmp32f), (BinaryFunc)cmp64f,
- 0
-};
+ static BinaryFunc cmpTab[] =
+ {
+ (BinaryFunc)GET_OPTIMIZED(cmp8u), (BinaryFunc)GET_OPTIMIZED(cmp8s),
+ (BinaryFunc)GET_OPTIMIZED(cmp16u), (BinaryFunc)GET_OPTIMIZED(cmp16s),
+ (BinaryFunc)GET_OPTIMIZED(cmp32s),
+ (BinaryFunc)GET_OPTIMIZED(cmp32f), (BinaryFunc)cmp64f,
+ 0
+ };
+ return cmpTab[depth];
+}
static double getMinVal(int depth)
{
_dst.create(src1.size(), CV_8UC(cn));
Mat dst = _dst.getMat();
Size sz = getContinuousSize(src1, src2, dst, src1.channels());
- cmpTab[src1.depth()](src1.data, src1.step, src2.data, src2.step, dst.data, dst.step, sz, &op);
+ getCmpFunc(src1.depth())(src1.data, src1.step, src2.data, src2.step, dst.data, dst.step, sz, &op);
return;
}
size_t esz = src1.elemSize();
size_t blocksize0 = (size_t)(BLOCK_SIZE + esz-1)/esz;
- BinaryFunc func = cmpTab[depth1];
+ BinaryFunc func = getCmpFunc(depth1);
if( !haveScalar )
{
typedef void (*InRangeFunc)( const uchar* src1, size_t step1, const uchar* src2, size_t step2,
const uchar* src3, size_t step3, uchar* dst, size_t step, Size sz );
-static InRangeFunc inRangeTab[] =
+static InRangeFunc getInRangeFunc(int depth)
{
- (InRangeFunc)GET_OPTIMIZED(inRange8u), (InRangeFunc)GET_OPTIMIZED(inRange8s), (InRangeFunc)GET_OPTIMIZED(inRange16u),
- (InRangeFunc)GET_OPTIMIZED(inRange16s), (InRangeFunc)GET_OPTIMIZED(inRange32s), (InRangeFunc)GET_OPTIMIZED(inRange32f),
- (InRangeFunc)inRange64f, 0
-};
+ static InRangeFunc inRangeTab[] =
+ {
+ (InRangeFunc)GET_OPTIMIZED(inRange8u), (InRangeFunc)GET_OPTIMIZED(inRange8s), (InRangeFunc)GET_OPTIMIZED(inRange16u),
+ (InRangeFunc)GET_OPTIMIZED(inRange16s), (InRangeFunc)GET_OPTIMIZED(inRange32s), (InRangeFunc)GET_OPTIMIZED(inRange32f),
+ (InRangeFunc)inRange64f, 0
+ };
+
+ return inRangeTab[depth];
+}
}
_dst.create(src.dims, src.size, CV_8U);
Mat dst = _dst.getMat();
- InRangeFunc func = inRangeTab[depth];
+ InRangeFunc func = getInRangeFunc(depth);
const Mat* arrays_sc[] = { &src, &dst, 0 };
const Mat* arrays_nosc[] = { &src, &dst, &lb, &ub, 0 };
typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
-static SplitFunc splitTab[] =
+static SplitFunc getSplitFunc(int depth)
{
- (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split16u), (SplitFunc)GET_OPTIMIZED(split16u),
- (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split64s), 0
-};
+ static SplitFunc splitTab[] =
+ {
+ (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split16u), (SplitFunc)GET_OPTIMIZED(split16u),
+ (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split64s), 0
+ };
+
+ return splitTab[depth];
+}
-static MergeFunc mergeTab[] =
+static MergeFunc getMergeFunc(int depth)
{
- (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge16u),
- (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge64s), 0
-};
+ static MergeFunc mergeTab[] =
+ {
+ (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge16u),
+ (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge64s), 0
+ };
+
+ return mergeTab[depth];
+}
}
return;
}
- SplitFunc func = splitTab[depth];
+ SplitFunc func = getSplitFunc(depth);
CV_Assert( func != 0 );
int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1();
NAryMatIterator it(arrays, ptrs, cn+1);
int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0);
- MergeFunc func = mergeTab[depth];
+ MergeFunc func = getMergeFunc(depth);
for( i = 0; i < it.nplanes; i++, ++it )
{
typedef void (*MixChannelsFunc)( const uchar** src, const int* sdelta,
uchar** dst, const int* ddelta, int len, int npairs );
-static MixChannelsFunc mixchTab[] =
+static MixChannelsFunc getMixchFunc(int depth)
{
- (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels16u,
- (MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels32s,
- (MixChannelsFunc)mixChannels64s, 0
-};
+ static MixChannelsFunc mixchTab[] =
+ {
+ (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels16u,
+ (MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels32s,
+ (MixChannelsFunc)mixChannels64s, 0
+ };
+
+ return mixchTab[depth];
+}
}
NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));
int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));
- MixChannelsFunc func = mixchTab[depth];
+ MixChannelsFunc func = getMixchFunc(depth);
for( i = 0; i < it.nplanes; i++, ++it )
{
DEF_CVT_FUNC(32f64f, float, double);
DEF_CPY_FUNC(64s, int64);
-static BinaryFunc cvtScaleAbsTab[] =
-{
- (BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,
- (BinaryFunc)cvtScaleAbs16s8u, (BinaryFunc)cvtScaleAbs32s8u, (BinaryFunc)cvtScaleAbs32f8u,
- (BinaryFunc)cvtScaleAbs64f8u, 0
-};
-
-static BinaryFunc cvtScaleTab[][8] =
+static BinaryFunc getCvtScaleAbsFunc(int depth)
{
+ static BinaryFunc cvtScaleAbsTab[] =
{
- (BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),
- (BinaryFunc)GET_OPTIMIZED(cvtScale16s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8u),
- (BinaryFunc)cvtScale64f8u, 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvtScale8u8s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8s),
- (BinaryFunc)GET_OPTIMIZED(cvtScale16s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8s),
- (BinaryFunc)cvtScale64f8s, 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvtScale8u16u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u),
- (BinaryFunc)GET_OPTIMIZED(cvtScale16s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16u),
- (BinaryFunc)cvtScale64f16u, 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvtScale8u16s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u16s),
- (BinaryFunc)GET_OPTIMIZED(cvtScale16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16s),
- (BinaryFunc)cvtScale64f16s, 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvtScale8u32s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32s),
- (BinaryFunc)GET_OPTIMIZED(cvtScale16s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f32s),
- (BinaryFunc)cvtScale64f32s, 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvtScale8u32f), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32f),
- (BinaryFunc)GET_OPTIMIZED(cvtScale16s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32f),
- (BinaryFunc)cvtScale64f32f, 0
- },
- {
- (BinaryFunc)cvtScale8u64f, (BinaryFunc)cvtScale8s64f, (BinaryFunc)cvtScale16u64f,
- (BinaryFunc)cvtScale16s64f, (BinaryFunc)cvtScale32s64f, (BinaryFunc)cvtScale32f64f,
- (BinaryFunc)cvtScale64f, 0
- },
- {
- 0, 0, 0, 0, 0, 0, 0, 0
- }
-};
+ (BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,
+ (BinaryFunc)cvtScaleAbs16s8u, (BinaryFunc)cvtScaleAbs32s8u, (BinaryFunc)cvtScaleAbs32f8u,
+ (BinaryFunc)cvtScaleAbs64f8u, 0
+ };
-static BinaryFunc cvtTab[][8] =
-{
- {
- (BinaryFunc)(cvt8u), (BinaryFunc)GET_OPTIMIZED(cvt8s8u), (BinaryFunc)GET_OPTIMIZED(cvt16u8u),
- (BinaryFunc)GET_OPTIMIZED(cvt16s8u), (BinaryFunc)GET_OPTIMIZED(cvt32s8u), (BinaryFunc)GET_OPTIMIZED(cvt32f8u),
- (BinaryFunc)GET_OPTIMIZED(cvt64f8u), 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvt8u8s), (BinaryFunc)cvt8u, (BinaryFunc)GET_OPTIMIZED(cvt16u8s),
- (BinaryFunc)GET_OPTIMIZED(cvt16s8s), (BinaryFunc)GET_OPTIMIZED(cvt32s8s), (BinaryFunc)GET_OPTIMIZED(cvt32f8s),
- (BinaryFunc)GET_OPTIMIZED(cvt64f8s), 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvt8u16u), (BinaryFunc)GET_OPTIMIZED(cvt8s16u), (BinaryFunc)cvt16u,
- (BinaryFunc)GET_OPTIMIZED(cvt16s16u), (BinaryFunc)GET_OPTIMIZED(cvt32s16u), (BinaryFunc)GET_OPTIMIZED(cvt32f16u),
- (BinaryFunc)GET_OPTIMIZED(cvt64f16u), 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvt8u16s), (BinaryFunc)GET_OPTIMIZED(cvt8s16s), (BinaryFunc)GET_OPTIMIZED(cvt16u16s),
- (BinaryFunc)cvt16u, (BinaryFunc)GET_OPTIMIZED(cvt32s16s), (BinaryFunc)GET_OPTIMIZED(cvt32f16s),
- (BinaryFunc)GET_OPTIMIZED(cvt64f16s), 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvt8u32s), (BinaryFunc)GET_OPTIMIZED(cvt8s32s), (BinaryFunc)GET_OPTIMIZED(cvt16u32s),
- (BinaryFunc)GET_OPTIMIZED(cvt16s32s), (BinaryFunc)cvt32s, (BinaryFunc)GET_OPTIMIZED(cvt32f32s),
- (BinaryFunc)GET_OPTIMIZED(cvt64f32s), 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvt8u32f), (BinaryFunc)GET_OPTIMIZED(cvt8s32f), (BinaryFunc)GET_OPTIMIZED(cvt16u32f),
- (BinaryFunc)GET_OPTIMIZED(cvt16s32f), (BinaryFunc)GET_OPTIMIZED(cvt32s32f), (BinaryFunc)cvt32s,
- (BinaryFunc)GET_OPTIMIZED(cvt64f32f), 0
- },
- {
- (BinaryFunc)GET_OPTIMIZED(cvt8u64f), (BinaryFunc)GET_OPTIMIZED(cvt8s64f), (BinaryFunc)GET_OPTIMIZED(cvt16u64f),
- (BinaryFunc)GET_OPTIMIZED(cvt16s64f), (BinaryFunc)GET_OPTIMIZED(cvt32s64f), (BinaryFunc)GET_OPTIMIZED(cvt32f64f),
- (BinaryFunc)(cvt64s), 0
- },
- {
- 0, 0, 0, 0, 0, 0, 0, 0
- }
-};
+ return cvtScaleAbsTab[depth];
+}
BinaryFunc getConvertFunc(int sdepth, int ddepth)
{
+ static BinaryFunc cvtTab[][8] =
+ {
+ {
+ (BinaryFunc)(cvt8u), (BinaryFunc)GET_OPTIMIZED(cvt8s8u), (BinaryFunc)GET_OPTIMIZED(cvt16u8u),
+ (BinaryFunc)GET_OPTIMIZED(cvt16s8u), (BinaryFunc)GET_OPTIMIZED(cvt32s8u), (BinaryFunc)GET_OPTIMIZED(cvt32f8u),
+ (BinaryFunc)GET_OPTIMIZED(cvt64f8u), 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvt8u8s), (BinaryFunc)cvt8u, (BinaryFunc)GET_OPTIMIZED(cvt16u8s),
+ (BinaryFunc)GET_OPTIMIZED(cvt16s8s), (BinaryFunc)GET_OPTIMIZED(cvt32s8s), (BinaryFunc)GET_OPTIMIZED(cvt32f8s),
+ (BinaryFunc)GET_OPTIMIZED(cvt64f8s), 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvt8u16u), (BinaryFunc)GET_OPTIMIZED(cvt8s16u), (BinaryFunc)cvt16u,
+ (BinaryFunc)GET_OPTIMIZED(cvt16s16u), (BinaryFunc)GET_OPTIMIZED(cvt32s16u), (BinaryFunc)GET_OPTIMIZED(cvt32f16u),
+ (BinaryFunc)GET_OPTIMIZED(cvt64f16u), 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvt8u16s), (BinaryFunc)GET_OPTIMIZED(cvt8s16s), (BinaryFunc)GET_OPTIMIZED(cvt16u16s),
+ (BinaryFunc)cvt16u, (BinaryFunc)GET_OPTIMIZED(cvt32s16s), (BinaryFunc)GET_OPTIMIZED(cvt32f16s),
+ (BinaryFunc)GET_OPTIMIZED(cvt64f16s), 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvt8u32s), (BinaryFunc)GET_OPTIMIZED(cvt8s32s), (BinaryFunc)GET_OPTIMIZED(cvt16u32s),
+ (BinaryFunc)GET_OPTIMIZED(cvt16s32s), (BinaryFunc)cvt32s, (BinaryFunc)GET_OPTIMIZED(cvt32f32s),
+ (BinaryFunc)GET_OPTIMIZED(cvt64f32s), 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvt8u32f), (BinaryFunc)GET_OPTIMIZED(cvt8s32f), (BinaryFunc)GET_OPTIMIZED(cvt16u32f),
+ (BinaryFunc)GET_OPTIMIZED(cvt16s32f), (BinaryFunc)GET_OPTIMIZED(cvt32s32f), (BinaryFunc)cvt32s,
+ (BinaryFunc)GET_OPTIMIZED(cvt64f32f), 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvt8u64f), (BinaryFunc)GET_OPTIMIZED(cvt8s64f), (BinaryFunc)GET_OPTIMIZED(cvt16u64f),
+ (BinaryFunc)GET_OPTIMIZED(cvt16s64f), (BinaryFunc)GET_OPTIMIZED(cvt32s64f), (BinaryFunc)GET_OPTIMIZED(cvt32f64f),
+ (BinaryFunc)(cvt64s), 0
+ },
+ {
+ 0, 0, 0, 0, 0, 0, 0, 0
+ }
+ };
+
return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
}
BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)
{
+ static BinaryFunc cvtScaleTab[][8] =
+ {
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),
+ (BinaryFunc)GET_OPTIMIZED(cvtScale16s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8u),
+ (BinaryFunc)cvtScale64f8u, 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvtScale8u8s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8s),
+ (BinaryFunc)GET_OPTIMIZED(cvtScale16s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8s),
+ (BinaryFunc)cvtScale64f8s, 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvtScale8u16u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u),
+ (BinaryFunc)GET_OPTIMIZED(cvtScale16s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16u),
+ (BinaryFunc)cvtScale64f16u, 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvtScale8u16s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u16s),
+ (BinaryFunc)GET_OPTIMIZED(cvtScale16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16s),
+ (BinaryFunc)cvtScale64f16s, 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvtScale8u32s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32s),
+ (BinaryFunc)GET_OPTIMIZED(cvtScale16s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f32s),
+ (BinaryFunc)cvtScale64f32s, 0
+ },
+ {
+ (BinaryFunc)GET_OPTIMIZED(cvtScale8u32f), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32f),
+ (BinaryFunc)GET_OPTIMIZED(cvtScale16s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32f),
+ (BinaryFunc)cvtScale64f32f, 0
+ },
+ {
+ (BinaryFunc)cvtScale8u64f, (BinaryFunc)cvtScale8s64f, (BinaryFunc)cvtScale16u64f,
+ (BinaryFunc)cvtScale16s64f, (BinaryFunc)cvtScale32s64f, (BinaryFunc)cvtScale32f64f,
+ (BinaryFunc)cvtScale64f, 0
+ },
+ {
+ 0, 0, 0, 0, 0, 0, 0, 0
+ }
+ };
+
return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
}
double scale[] = {alpha, beta};
_dst.create( src.dims, src.size, CV_8UC(cn) );
Mat dst = _dst.getMat();
- BinaryFunc func = cvtScaleAbsTab[src.depth()];
+ BinaryFunc func = getCvtScaleAbsFunc(src.depth());
CV_Assert( func != 0 );
if( src.dims <= 2 )
typedef void (*TransformFunc)( const uchar* src, uchar* dst, const uchar* m, int, int, int );
-static TransformFunc transformTab[] =
+static TransformFunc getTransformFunc(int depth)
{
- (TransformFunc)transform_8u, (TransformFunc)transform_8s, (TransformFunc)transform_16u,
- (TransformFunc)transform_16s, (TransformFunc)transform_32s, (TransformFunc)transform_32f,
- (TransformFunc)transform_64f, 0
-};
+ static TransformFunc transformTab[] =
+ {
+ (TransformFunc)transform_8u, (TransformFunc)transform_8s, (TransformFunc)transform_16u,
+ (TransformFunc)transform_16s, (TransformFunc)transform_32s, (TransformFunc)transform_32f,
+ (TransformFunc)transform_64f, 0
+ };
+
+ return transformTab[depth];
+}
-static TransformFunc diagTransformTab[] =
+static TransformFunc getDiagTransformFunc(int depth)
{
- (TransformFunc)diagtransform_8u, (TransformFunc)diagtransform_8s, (TransformFunc)diagtransform_16u,
- (TransformFunc)diagtransform_16s, (TransformFunc)diagtransform_32s, (TransformFunc)diagtransform_32f,
- (TransformFunc)diagtransform_64f, 0
-};
+ static TransformFunc diagTransformTab[] =
+ {
+ (TransformFunc)diagtransform_8u, (TransformFunc)diagtransform_8s, (TransformFunc)diagtransform_16u,
+ (TransformFunc)diagtransform_16s, (TransformFunc)diagtransform_32s, (TransformFunc)diagtransform_32f,
+ (TransformFunc)diagtransform_64f, 0
+ };
+
+ return diagTransformTab[depth];
+}
}
}
}
- TransformFunc func = isDiag ? diagTransformTab[depth] : transformTab[depth];
+ TransformFunc func = isDiag ? getDiagTransformFunc(depth): getTransformFunc(depth);
CV_Assert( func != 0 );
const Mat* arrays[] = {&src, &dst, 0};
typedef double (*DotProdFunc)(const uchar* src1, const uchar* src2, int len);
-static DotProdFunc dotProdTab[] =
+static DotProdFunc getDotProdFunc(int depth)
{
- (DotProdFunc)GET_OPTIMIZED(dotProd_8u), (DotProdFunc)GET_OPTIMIZED(dotProd_8s),
- (DotProdFunc)dotProd_16u, (DotProdFunc)dotProd_16s,
- (DotProdFunc)dotProd_32s, (DotProdFunc)GET_OPTIMIZED(dotProd_32f),
- (DotProdFunc)dotProd_64f, 0
-};
+ static DotProdFunc dotProdTab[] =
+ {
+ (DotProdFunc)GET_OPTIMIZED(dotProd_8u), (DotProdFunc)GET_OPTIMIZED(dotProd_8s),
+ (DotProdFunc)dotProd_16u, (DotProdFunc)dotProd_16s,
+ (DotProdFunc)dotProd_32s, (DotProdFunc)GET_OPTIMIZED(dotProd_32f),
+ (DotProdFunc)dotProd_64f, 0
+ };
+
+ return dotProdTab[depth];
+}
double Mat::dot(InputArray _mat) const
{
Mat mat = _mat.getMat();
int cn = channels();
- DotProdFunc func = dotProdTab[depth()];
+ DotProdFunc func = getDotProdFunc(depth());
CV_Assert( mat.type() == type() && mat.size == size && func != 0 );
if( isContinuous() && mat.isContinuous() )
typedef int (*SumFunc)(const uchar*, const uchar* mask, uchar*, int, int);
-static SumFunc sumTab[] =
+static SumFunc getSumFunc(int depth)
{
- (SumFunc)GET_OPTIMIZED(sum8u), (SumFunc)sum8s,
- (SumFunc)sum16u, (SumFunc)sum16s,
- (SumFunc)sum32s,
- (SumFunc)GET_OPTIMIZED(sum32f), (SumFunc)sum64f,
- 0
-};
+ static SumFunc sumTab[] =
+ {
+ (SumFunc)GET_OPTIMIZED(sum8u), (SumFunc)sum8s,
+ (SumFunc)sum16u, (SumFunc)sum16s,
+ (SumFunc)sum32s,
+ (SumFunc)GET_OPTIMIZED(sum32f), (SumFunc)sum64f,
+ 0
+ };
+
+ return sumTab[depth];
+}
template<typename T>
static int countNonZero_(const T* src, int len )
typedef int (*CountNonZeroFunc)(const uchar*, int);
-static CountNonZeroFunc countNonZeroTab[] =
+static CountNonZeroFunc getCountNonZeroTab(int depth)
{
- (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u),
- (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u),
- (CountNonZeroFunc)GET_OPTIMIZED(countNonZero32s), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero32f),
- (CountNonZeroFunc)GET_OPTIMIZED(countNonZero64f), 0
-};
+ static CountNonZeroFunc countNonZeroTab[] =
+ {
+ (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u),
+ (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u),
+ (CountNonZeroFunc)GET_OPTIMIZED(countNonZero32s), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero32f),
+ (CountNonZeroFunc)GET_OPTIMIZED(countNonZero64f), 0
+ };
+ return countNonZeroTab[depth];
+}
template<typename T, typename ST, typename SQT>
static int sumsqr_(const T* src0, const uchar* mask, ST* sum, SQT* sqsum, int len, int cn )
typedef int (*SumSqrFunc)(const uchar*, const uchar* mask, uchar*, uchar*, int, int);
-static SumSqrFunc sumSqrTab[] =
+static SumSqrFunc getSumSqrTab(int depth)
{
- (SumSqrFunc)GET_OPTIMIZED(sqsum8u), (SumSqrFunc)sqsum8s, (SumSqrFunc)sqsum16u, (SumSqrFunc)sqsum16s,
- (SumSqrFunc)sqsum32s, (SumSqrFunc)GET_OPTIMIZED(sqsum32f), (SumSqrFunc)sqsum64f, 0
-};
+ static SumSqrFunc sumSqrTab[] =
+ {
+ (SumSqrFunc)GET_OPTIMIZED(sqsum8u), (SumSqrFunc)sqsum8s, (SumSqrFunc)sqsum16u, (SumSqrFunc)sqsum16s,
+ (SumSqrFunc)sqsum32s, (SumSqrFunc)GET_OPTIMIZED(sqsum32f), (SumSqrFunc)sqsum64f, 0
+ };
+
+ return sumSqrTab[depth];
+}
}
}
#endif
- SumFunc func = sumTab[depth];
+ SumFunc func = getSumFunc(depth);
CV_Assert( cn <= 4 && func != 0 );
int cv::countNonZero( InputArray _src )
{
Mat src = _src.getMat();
- CountNonZeroFunc func = countNonZeroTab[src.depth()];
+ CountNonZeroFunc func = getCountNonZeroTab(src.depth());
CV_Assert( src.channels() == 1 && func != 0 );
}
#endif
- SumFunc func = sumTab[depth];
+ SumFunc func = getSumFunc(depth);
CV_Assert( cn <= 4 && func != 0 );
CV_Assert( mask.empty() || mask.type() == CV_8U );
int k, cn = src.channels(), depth = src.depth();
- SumSqrFunc func = sumSqrTab[depth];
+ SumSqrFunc func = getSumSqrTab(depth);
CV_Assert( func != 0 );
typedef void (*MinMaxIdxFunc)(const uchar*, const uchar*, int*, int*, size_t*, size_t*, int, size_t);
-static MinMaxIdxFunc minmaxTab[] =
+static MinMaxIdxFunc getMinmaxTab(int depth)
{
- (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8s),
- (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16s),
- (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_32s),
- (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_32f), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_64f),
- 0
-};
+ static MinMaxIdxFunc minmaxTab[] =
+ {
+ (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8s),
+ (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16s),
+ (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_32s),
+ (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_32f), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_64f),
+ 0
+ };
+
+ return minmaxTab[depth];
+}
static void ofs2idx(const Mat& a, size_t ofs, int* idx)
{
CV_Assert( (cn == 1 && (mask.empty() || mask.type() == CV_8U)) ||
(cn >= 1 && mask.empty() && !minIdx && !maxIdx) );
- MinMaxIdxFunc func = minmaxTab[depth];
+ MinMaxIdxFunc func = getMinmaxTab(depth);
CV_Assert( func != 0 );
const Mat* arrays[] = {&src, &mask, 0};
typedef int (*NormFunc)(const uchar*, const uchar*, uchar*, int, int);
typedef int (*NormDiffFunc)(const uchar*, const uchar*, const uchar*, uchar*, int, int);
-static NormFunc normTab[3][8] =
+static NormFunc getNormFunc(int normType, int depth)
{
+ static NormFunc normTab[3][8] =
{
- (NormFunc)GET_OPTIMIZED(normInf_8u), (NormFunc)GET_OPTIMIZED(normInf_8s), (NormFunc)GET_OPTIMIZED(normInf_16u), (NormFunc)GET_OPTIMIZED(normInf_16s),
- (NormFunc)GET_OPTIMIZED(normInf_32s), (NormFunc)GET_OPTIMIZED(normInf_32f), (NormFunc)normInf_64f, 0
- },
- {
- (NormFunc)GET_OPTIMIZED(normL1_8u), (NormFunc)GET_OPTIMIZED(normL1_8s), (NormFunc)GET_OPTIMIZED(normL1_16u), (NormFunc)GET_OPTIMIZED(normL1_16s),
- (NormFunc)GET_OPTIMIZED(normL1_32s), (NormFunc)GET_OPTIMIZED(normL1_32f), (NormFunc)normL1_64f, 0
- },
- {
- (NormFunc)GET_OPTIMIZED(normL2_8u), (NormFunc)GET_OPTIMIZED(normL2_8s), (NormFunc)GET_OPTIMIZED(normL2_16u), (NormFunc)GET_OPTIMIZED(normL2_16s),
- (NormFunc)GET_OPTIMIZED(normL2_32s), (NormFunc)GET_OPTIMIZED(normL2_32f), (NormFunc)normL2_64f, 0
- }
-};
+ {
+ (NormFunc)GET_OPTIMIZED(normInf_8u), (NormFunc)GET_OPTIMIZED(normInf_8s), (NormFunc)GET_OPTIMIZED(normInf_16u), (NormFunc)GET_OPTIMIZED(normInf_16s),
+ (NormFunc)GET_OPTIMIZED(normInf_32s), (NormFunc)GET_OPTIMIZED(normInf_32f), (NormFunc)normInf_64f, 0
+ },
+ {
+ (NormFunc)GET_OPTIMIZED(normL1_8u), (NormFunc)GET_OPTIMIZED(normL1_8s), (NormFunc)GET_OPTIMIZED(normL1_16u), (NormFunc)GET_OPTIMIZED(normL1_16s),
+ (NormFunc)GET_OPTIMIZED(normL1_32s), (NormFunc)GET_OPTIMIZED(normL1_32f), (NormFunc)normL1_64f, 0
+ },
+ {
+ (NormFunc)GET_OPTIMIZED(normL2_8u), (NormFunc)GET_OPTIMIZED(normL2_8s), (NormFunc)GET_OPTIMIZED(normL2_16u), (NormFunc)GET_OPTIMIZED(normL2_16s),
+ (NormFunc)GET_OPTIMIZED(normL2_32s), (NormFunc)GET_OPTIMIZED(normL2_32f), (NormFunc)normL2_64f, 0
+ }
+ };
-static NormDiffFunc normDiffTab[3][8] =
+ return normTab[normType][depth];
+}
+
+static NormDiffFunc getNormDiffFunc(int normType, int depth)
{
+ static NormDiffFunc normDiffTab[3][8] =
{
- (NormDiffFunc)GET_OPTIMIZED(normDiffInf_8u), (NormDiffFunc)normDiffInf_8s,
- (NormDiffFunc)normDiffInf_16u, (NormDiffFunc)normDiffInf_16s,
- (NormDiffFunc)normDiffInf_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffInf_32f),
- (NormDiffFunc)normDiffInf_64f, 0
- },
- {
- (NormDiffFunc)GET_OPTIMIZED(normDiffL1_8u), (NormDiffFunc)normDiffL1_8s,
- (NormDiffFunc)normDiffL1_16u, (NormDiffFunc)normDiffL1_16s,
- (NormDiffFunc)normDiffL1_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL1_32f),
- (NormDiffFunc)normDiffL1_64f, 0
- },
- {
- (NormDiffFunc)GET_OPTIMIZED(normDiffL2_8u), (NormDiffFunc)normDiffL2_8s,
- (NormDiffFunc)normDiffL2_16u, (NormDiffFunc)normDiffL2_16s,
- (NormDiffFunc)normDiffL2_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL2_32f),
- (NormDiffFunc)normDiffL2_64f, 0
- }
-};
+ {
+ (NormDiffFunc)GET_OPTIMIZED(normDiffInf_8u), (NormDiffFunc)normDiffInf_8s,
+ (NormDiffFunc)normDiffInf_16u, (NormDiffFunc)normDiffInf_16s,
+ (NormDiffFunc)normDiffInf_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffInf_32f),
+ (NormDiffFunc)normDiffInf_64f, 0
+ },
+ {
+ (NormDiffFunc)GET_OPTIMIZED(normDiffL1_8u), (NormDiffFunc)normDiffL1_8s,
+ (NormDiffFunc)normDiffL1_16u, (NormDiffFunc)normDiffL1_16s,
+ (NormDiffFunc)normDiffL1_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL1_32f),
+ (NormDiffFunc)normDiffL1_64f, 0
+ },
+ {
+ (NormDiffFunc)GET_OPTIMIZED(normDiffL2_8u), (NormDiffFunc)normDiffL2_8s,
+ (NormDiffFunc)normDiffL2_16u, (NormDiffFunc)normDiffL2_16s,
+ (NormDiffFunc)normDiffL2_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL2_32f),
+ (NormDiffFunc)normDiffL2_64f, 0
+ }
+ };
+
+ return normDiffTab[normType][depth];
+}
}
return result;
}
- NormFunc func = normTab[normType >> 1][depth];
+ NormFunc func = getNormFunc(normType >> 1, depth);
CV_Assert( func != 0 );
const Mat* arrays[] = {&src, &mask, 0};
return result;
}
- NormDiffFunc func = normDiffTab[normType >> 1][depth];
+ NormDiffFunc func = getNormDiffFunc(normType >> 1, depth);
CV_Assert( func != 0 );
const Mat* arrays[] = {&src1, &src2, &mask, 0};